/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*       SMTP MTM UI

*

*/

// MODULE - SMTP MTM UI

// Standard includes

#include <apacmdln.h>   //CApaCommandLine

#include <apgcli.h>

#include <apaid.h>

#include <txtrich.h>    //CRichText

#include <eikdialg.h>   //CEikDialog

#include <eikenv.h>     //CEikonEnv

#include <eikrutil.h>   //EikResourceUtils

#include <MtmExtendedCapabilities.hrh>

#include <akninputblock.h> // CAknInputBlock

#include <StringLoader.h>

#include <avkon.mbg> // bitmaps for progress

#include <etelpckt.h>

#include <aknViewAppUi.h> //CAknViewAppUi

#include <eikapp.h>     //CEikApplication

#include <aknclearer.h> // CAknLocalScreenClearer

// SMTP & POP includes

#include <smtcmtm.h>

#include <smtpset.h>

#include <pop3set.h>

#include <imapset.h>

#include <etel.h> // KErrEtelBusyDetected

// Messaging includes

#include <MuiuMsgEditorLauncher.h>

#include <muiumsvuiserviceutilitiesinternal.h>

#include <mtmuidef.hrh>

#include <imum.rsg>

#include <MuiuMsvProgressReporterOperation.h>

#include <iapprefs.h>

#include <ImumInternalApi.h>                        // CImumInternalApi

// Specific includes

#include "SmtpMtmUi.h"

#include "ImumMtmLogging.h"

#include "ImumPanic.h"

#include <imum.rsg>

#include "EmailPreCreation.h"

#include "SmtpCreateNewOp.h"

#include "SmtpCancelSendingOp.h"

#include "SmtpCopyMoveOp.h"

#include "SmtpResetPreCreationOp.h"

#include "EmailFeatureUtils.h"

#include "EmailUtils.H"

#include "MsvEmailConnectionProgressProvider.h"

#include "EmailEditorViewerUids.h"

#include "SenduiMtmUids.h"

#include "ComDbUtl.h"

#include <Muiumsginfo.h>

#include <Muiumsginfo.hrh>

#include <MuiuOperationWait.h> // CMuiuOperationWait

#include <messagingvariant.hrh>

#include "IMSSettingsNoteUi.h"

#include <ImumInSettingsData.h>             // CImumInSettingsData

#include <ImumInSettingsDataCollection.h>   // CImumInSettingsDataCollection

#include <ImumInMailboxServices.h>          // MImumInMailboxServices

#include <ImumInHealthServices.h>           // MImumInHealthServices

#include "ImumMboxSettingsUtils.h"          // ImumMboxSettingsUtils

#include "ImumCreatorPredefinedMailbox.h"   // CImumCreatorPredefinedMailbox

// CONSTANTS

const TInt KImumEntriesDoneReplaceIndex     = 0;

const TInt KImumTotalEntriesReplaceIndex    = 1;

const TInt KImumMessageInfoDateBufferLength = 30;

const TInt KImumMessageInfoSizeBufferLength = 20;

const TInt KImumMessagePriorityBufferLength = 32;

_LIT(KSmtpuMtmUiResourceFile,"IMUM");

const TUid KMceMessageListViewId    = { 0x02 };

const TUid KMceMainViewListViewId   = { 0x01 };

const TInt KMceUid = 0x100058C5;

// ----------------------------------------------------------------------------

// CSmtpMtmUi::NewSMTUMtmUiL()

// ----------------------------------------------------------------------------

EXPORT_C CBaseMtmUi* NewSMTUMtmUiL(CBaseMtm& aMtm, CRegisteredMtmDll& aRegisteredDll)

    {

    return CSmtpMtmUi::NewL(aMtm, aRegisteredDll);

    }

// ----------------------------------------------------------------------------

// CSmtpMtmUi::NewL()

// ----------------------------------------------------------------------------

CSmtpMtmUi* CSmtpMtmUi::NewL(CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll)

    {

    IMUM_STATIC_CONTEXT( CSmtpMtmUi::NewL, 0, mtm, KImumMtmLog );

    IMUM_IN();

    CSmtpMtmUi* self=new(ELeave) CSmtpMtmUi(aBaseMtm, aRegisteredMtmDll);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    IMUM_OUT();

    return self;

    }

// ----------------------------------------------------------------------------

// CSmtpMtmUi::CSmtpMtmUi()

// ----------------------------------------------------------------------------

CSmtpMtmUi::CSmtpMtmUi(CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll)

    :

    CImumMtmBaseMtmUi( aBaseMtm, aRegisteredMtmDll )

    {

    IMUM_CONTEXT( CSmtpMtmUi::CSmtpMtmUi, 0, KImumMtmLog );

    IMUM_IN();

    //don't wait for msg editors to exit.

    iFlags = EMtmUiFlagEditorNoWaitForExit;

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// CSmtpMtmUi::ConstructL()

// ----------------------------------------------------------------------------

void CSmtpMtmUi::ConstructL()

    {

    IMUM_CONTEXT( CSmtpMtmUi::ConstructL, 0, KImumMtmLog );

    IMUM_IN();

    // Construct own base MTM UI

    CImumMtmBaseMtmUi::ConstructL();

    // Create a 'message pre-creator'.

    iPreCreate = CEmailPreCreation::NewL( *iMailboxApi );

    //VARIATION START

    iNewSecureSettingOn =

        MsvEmailMtmUiFeatureUtils::LocalFeatureL(

            KCRUidMuiuVariation, KMuiuEmailConfigFlags,

            KEmailFeatureIdSecureSettings );

    //VARIATION END

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// CSmtpMtmUi::ResolveEditorFileNameL()

// ----------------------------------------------------------------------------

void CSmtpMtmUi::ResolveEditorFileNameL()

    {

    IMUM_CONTEXT( CSmtpMtmUi::ResolveEditorFileNameL, 0, KImumMtmLog );

    IMUM_IN();

    __ASSERT_DEBUG(

        iEditorFilename == NULL,

            User::Panic(KImumMtmUiPanic, ESmtpMtmUiEditorFilenameDuplicate ) );

    iEditorFilename = MsvUiEditorUtilities::ResolveAppFileNameL(

        KUidMsgInternetMailEditor );

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// CSmtpMtmUi::ResolveViewerFileNameL()

// ----------------------------------------------------------------------------

void CSmtpMtmUi::ResolveViewerFileNameL()

    {

    IMUM_CONTEXT( CSmtpMtmUi::ResolveViewerFileNameL, 0, KImumMtmLog );

    IMUM_IN();

    __ASSERT_DEBUG(

        iViewerFilename == NULL,

            User::Panic(KImumMtmUiPanic, ESmtpMtmUiEditorFilenameDuplicate ) );

    iViewerFilename = MsvUiEditorUtilities::ResolveAppFileNameL(

        KUidMsgInternetMailViewer );

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// CSmtpMtmUi::GetResourceFileName()

// ----------------------------------------------------------------------------

void CSmtpMtmUi::GetResourceFileName( TFileName& aFileName ) const

    {

    IMUM_CONTEXT( CSmtpMtmUi::GetResourceFileName, 0, KImumMtmLog );

    IMUM_IN();

    aFileName=KSmtpuMtmUiResourceFile;

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// CSmtpMtmUi::~CSmtpMtmUi()

// ----------------------------------------------------------------------------

CSmtpMtmUi::~CSmtpMtmUi()

    {

    IMUM_CONTEXT( CSmtpMtmUi::~CSmtpMtmUi, 0, KImumMtmLog );

    IMUM_IN();

    delete iPreCreate;

    iPreCreate = NULL;

    delete iEditorFilename;

    iEditorFilename = NULL;

    delete iViewerFilename;

    iViewerFilename = NULL;

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// CSmtpMtmUi::QueryCapability()

// ----------------------------------------------------------------------------

TInt CSmtpMtmUi::QueryCapability(TUid aCapability, TInt& aResponse)

    {

    IMUM_CONTEXT( CSmtpMtmUi::QueryCapability, 0, KImumMtmLog );

    IMUM_IN();

    if ( aCapability.iUid == KUidMsvMtmUiQueryMessagingInitialisation )

        {

        aResponse=ETrue;

        IMUM_OUT();

        return KErrNone;

        }

    else if( aCapability.iUid == KUidMsvMtmQuerySupportValidateService )

        {

        aResponse=ETrue;

        IMUM_OUT();

        return KErrNone;

        }

    else if ( aCapability.iUid == KUidMsvMtmQuerySupportValidateSelection )

        {

        aResponse=ETrue;

        IMUM_OUT();

        return KErrNone;

        }

    else

        {

        IMUM_OUT();

        return CBaseMtmUi::QueryCapability( aCapability, aResponse );

        }

    }

// ----------------------------------------------------------------------------

// CSmtpMtmUi::InvokeAsyncFunctionL()

// ----------------------------------------------------------------------------

CMsvOperation* CSmtpMtmUi::InvokeAsyncFunctionL(

    TInt aFunctionId,

    const CMsvEntrySelection& aSelection,

    TRequestStatus& aStatus,

    TDes8& aParameter )

    {

    IMUM_CONTEXT( CSmtpMtmUi::InvokeAsyncFunctionL, 0, KImumMtmLog );

    IMUM_IN();

    if(aFunctionId == KMtmUiFunctionMessageInfo)

        {

        return ShowMessageInfoL(aStatus, aParameter);

        }

    if ( aFunctionId == KMtmUiFunctionPreCreateMessage )

        {

        CEmailPreCreation* preCreate = CEmailPreCreation::NewL( *iMailboxApi );

        CleanupStack::PushL( preCreate );

        CMsvOperation* op =

            preCreate->DeleteAllPreCreatedEmailsL( aSelection.At(0), aStatus );

        CleanupStack::PopAndDestroy( preCreate );

        IMUM_OUT();

        return op;

        }

    IMUM_OUT();

    return CBaseMtmUi::InvokeAsyncFunctionL( aFunctionId,

                                             aSelection,

                                             aStatus,

                                             aParameter);

    }

// ----------------------------------------------------------------------------

// CSmtpMtmUi::ShowMessageInfoL()

// ----------------------------------------------------------------------------

CMsvOperation* CSmtpMtmUi::ShowMessageInfoL(

    TRequestStatus& aCompletionStatus,

    TDes8& /*aParameter*/ )

    {

    IMUM_CONTEXT( CSmtpMtmUi::ShowMessageInfoL, 0, KImumMtmLog );

    IMUM_IN();

    TMsgInfoMessageInfoData infoData;

    TBuf<KImumMessageInfoDateBufferLength> dateBuf;

    TBuf<KImumMessageInfoDateBufferLength> timeBuf;

    TBuf<KImumMessageInfoSizeBufferLength> sizeBuf;

    TBuf<KImumMessagePriorityBufferLength> priorityBuf;

    MsvEmailMtmUiUtils::SetMessageInfoDataLCCCCC(

        infoData,BaseMtm(),

        *iEikonEnv,

        dateBuf,

        timeBuf,

        sizeBuf,

        priorityBuf

        );

    TBuf<KImumMessageInfoDateBufferLength> type;

    StringLoader::Load( type, R_SMTP_MESSAGE_INFO_MAIL_TYPE, iCoeEnv );

    infoData.iType.Set( type );

    CMsgInfoMessageInfoDialog* infoDialog = CMsgInfoMessageInfoDialog::NewL();

    infoDialog->ExecuteLD( infoData, CMsgInfoMessageInfoDialog::EEmailEditor );

    CleanupStack::PopAndDestroy( 5 ); // CSI: 47 # 5 C's on end of SetMessageInfoDataLCCCCC

    IMUM_OUT();

    return CMsvCompletedOperation::NewL(

        Session(),

        KUidMsvLocalServiceMtm,

        KNullDesC8,

        KMsvLocalServiceIndexEntryId,

        aCompletionStatus,

        KErrNone

        );

    }

// ----------------------------------------------------------------------------

// CSmtpMtmUi::InvokeSyncFunctionL()

// ----------------------------------------------------------------------------

void CSmtpMtmUi::InvokeSyncFunctionL(

    TInt aFunctionId,

    const CMsvEntrySelection& aSelection,

    TDes8& aParameter)

    {

    IMUM_CONTEXT( CSmtpMtmUi::InvokeSyncFunctionL, 0, KImumMtmLog );

    IMUM_IN();

    // Context is dependant on function ID.

    switch (aFunctionId)

        {

        case KMtmUiMessagingInitialisation:

            HandlePredefinedMailboxCreationL();

            break;

        case KMtmUiFunctionValidateService://servicevalidation

            ValidateServiceL( aParameter );

            break;

        case KUidMsvMtmQuerySupportValidateSelection:

            ValidateServiceL( aSelection, aParameter );

            break;

        default:

            CBaseMtmUi::InvokeSyncFunctionL(aFunctionId, aSelection, aParameter);

            break;

        };

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// CSmtpMtmUi::CreateExecutePreCreationL()

// ----------------------------------------------------------------------------

//

CMsvOperation* CSmtpMtmUi::CreateExecutePreCreationL(

    const TMsvId aSmtpService, TRequestStatus& aStatus ) const

    {

    IMUM_CONTEXT( CSmtpMtmUi::CreateExecutePreCreationL, 0, KImumMtmLog );

    IMUM_IN();

    if ( aSmtpService != KMsvNullIndexEntryId )

        {

        TMsvEntry mailbox = iUtils->GetMailboxEntryL( aSmtpService );

        // Precreate email only for regular mailboxes

        if ( iUtils->IsMailMtm( mailbox.iMtm ) )

            {

            // Create waiter operation and precreation operation

            CMsvOperation* op = CSmtpResetPreCreationOp::NewL(

                iMailboxApi->MsvSession(), aStatus, aSmtpService );

            IMUM_OUT();

            return op;

            }

        }

    IMUM_OUT();

    return NULL;

    }

// ----------------------------------------------------------------------------

// CSmtpMtmUi::CreateEmailServiceL()

// ----------------------------------------------------------------------------

//

CMsvOperation* CSmtpMtmUi::CreateEmailServiceL(

    const TMsvEntry& aEntry,

    TRequestStatus& aStatus )

    {

    IMUM_CONTEXT( CSmtpMtmUi::CreateEmailServiceL, 0, KImumMtmLog );

    IMUM_IN();

    // Prepare creation of the email

    TInt exitCode = KErrCancel; // JYKA: Changed from EEikCmdExit to allow proper error handling

    TSmtpMtmUiCreateNewServiceParameters saveParameters = ESmtpMtmUiCreateNewServiceExit;

    TMsvId smtpService = CreateNewServiceL( aEntry, saveParameters );

    CMsvOperation* preCreationOperation = NULL;

    // Return value decided the continuation

    switch ( saveParameters )

        {

        default:

        case ESmtpMtmUiCreateNewServiceNotCreated:

            exitCode = KErrCancel;

            break;

        case ESmtpMtmUiCreateNewServiceSave:

            preCreationOperation = CreateExecutePreCreationL( smtpService, aStatus );

            exitCode = KErrNone;

            break;

        case ESmtpMtmUiCreateNewServiceSaveAndExit:

            preCreationOperation = CreateExecutePreCreationL( smtpService, aStatus );

        //lint -fallthrough

        case ESmtpMtmUiCreateNewServiceExit:

            exitCode = EEikCmdExit;

            break;

        }

    IMUM_OUT();

    if ( preCreationOperation )

        {

        return preCreationOperation;

        }

    // Finally return the completed operation

    return CMsvCompletedOperation::NewL(

        Session(), Type(), KNullDesC8,

        KMsvLocalServiceIndexEntryId,

        aStatus, exitCode );

    }

// ----------------------------------------------------------------------------

// CSmtpMtmUi::CreateL()

// ----------------------------------------------------------------------------

CMsvOperation* CSmtpMtmUi::CreateL(

    const TMsvEntry& aEntry,

    CMsvEntry& /* aParent */,

    TRequestStatus& aStatus )

    {

    IMUM_CONTEXT( CSmtpMtmUi::CreateL, 0, KImumMtmLog );

    IMUM_IN();

    // Context is irrelevant.

    __ASSERT_ALWAYS( aEntry.iMtm==Type(),

        User::Panic(KImumMtmUiPanic, ESmtpMtmUiWrongMtm ) );

    TMsvId smtpService = KMsvNullIndexEntryId;

    // If service value provided, create the new mailbox

    if ( aEntry.iType.iUid == KUidMsvServiceEntryValue )

        {

        CMsvOperation* op = CreateEmailServiceL( aEntry, aStatus );

        IMUM_OUT();

        return op;

        }

    else if ( aEntry.iType.iUid != KUidMsvMessageEntryValue )

        {

        User::Leave( KErrNotSupported );

        }

    smtpService = aEntry.iServiceId;

    if( smtpService == KMsvNullIndexEntryId ||

        smtpService == KMsvUnknownServiceIndexEntryId )

        {

        // No accounts, offer to create one.

        TSmtpMtmUiCreateNewServiceParameters saveParameters;

        smtpService = HandleNoAccountsL( saveParameters );

        if(  saveParameters == ESmtpMtmUiCreateNewServiceNotCreated )

            {

            IMUM_OUT();

            // User cancelled.

            return CMsvCompletedOperation::NewL(

                Session(), Type(), KNullDesC8,

                KMsvLocalServiceIndexEntryId,

                aStatus, KErrCancel);

            }

        else if(  saveParameters == ESmtpMtmUiCreateNewServiceExit )

            {

            IMUM_OUT();

            // User pressed Exit

            return CMsvCompletedOperation::NewL(

                Session(), Type(),

                KNullDesC8, KMsvLocalServiceIndexEntryId,

                aStatus, EEikCmdExit);

            }

        }

    else

        {

        // Pass to the editor the service Id of the SMTP service to use to send the new message.

        // The message centre will pass a POP3 or IMAP4 service id in aEntry.iServiceId,

        // if so find the SMTP service associated with it.

        TMsvEntry entry;

        TInt findService = Session().GetEntry(aEntry.iServiceId, smtpService, entry);

        if ( findService == KErrNone )

            {

            if ( entry.iMtm != KUidMsgTypeSMTP )

                {

                // mce passed pop3 or imap4 service, so we need to find related smtp service