diff -r 000000000000 -r 72b543305e3a email/imum/Mtms/Src/SmtpMtmUi.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/email/imum/Mtms/Src/SmtpMtmUi.cpp Thu Dec 17 08:44:11 2009 +0200 @@ -0,0 +1,1902 @@ +/* +* 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 //CApaCommandLine +#include +#include +#include //CRichText +#include //CEikDialog +#include //CEikonEnv +#include //EikResourceUtils +#include +#include // CAknInputBlock +#include +#include // bitmaps for progress +#include +#include //CAknViewAppUi +#include //CEikApplication +#include // CAknLocalScreenClearer + + +// SMTP & POP includes +#include +#include +#include +#include +#include // KErrEtelBusyDetected + +// Messaging includes +#include +#include +#include +#include +#include +#include +#include // CImumInternalApi + +// Specific includes +#include "SmtpMtmUi.h" +#include "ImumMtmLogging.h" +#include "ImumPanic.h" +#include +#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 +#include +#include // CMuiuOperationWait +#include +#include "IMSSettingsNoteUi.h" +#include // CImumInSettingsData +#include // CImumInSettingsDataCollection +#include // MImumInMailboxServices +#include // 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 dateBuf; + TBuf timeBuf; + TBuf sizeBuf; + TBuf priorityBuf; + MsvEmailMtmUiUtils::SetMessageInfoDataLCCCCC( + infoData,BaseMtm(), + *iEikonEnv, + dateBuf, + timeBuf, + sizeBuf, + priorityBuf + ); + + TBuf 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 + findService = Session().GetEntry(entry.iRelatedId, smtpService, entry); + } + } + + if ( findService == KErrNotFound ) + { + + // this will dispay 'check email settings' note + User::Leave( KSmtpUnknownErr ); + } + else + { + User::LeaveIfError( findService ); + } + + + //smtp auth fix 23092002 + CheckAndRestoreSmtpUserAndPasswordL( smtpService ); + //fix end + } + + + TEditorParameters editorParams; + editorParams.iFlags |= EMsgCreateMessageToService; + editorParams.iId = smtpService; + TPckgC paramPack(ESmtpMtmUiEditing); + if(!iEditorFilename) + ResolveEditorFileNameL(); + const TUint preferences = Preferences(); + editorParams.iFlags &= ~(EMsgLaunchEditorEmbedded | EMsgLaunchEditorThenWait); + if(preferences & EMtmUiFlagEditorPreferEmbedded) + { + editorParams.iFlags |= EMsgLaunchEditorEmbedded; + } + if(!(preferences & EMtmUiFlagEditorNoWaitForExit)) + { + editorParams.iFlags |= EMsgLaunchEditorThenWait; + } + + IMUM_OUT(); + + return CSmtpCreateNewOp::NewL(*iMailboxApi, aStatus, editorParams, *iEditorFilename, paramPack); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::OpenL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::OpenL(TRequestStatus& aStatus) + { + IMUM_CONTEXT( CSmtpMtmUi::OpenL, 0, KImumMtmLog ); + IMUM_IN(); + + // Context is entry to open. + const TMsvEntry& context=iBaseMtm.Entry().Entry(); + __ASSERT_ALWAYS(context.iMtm==Type(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiWrongMtm)); + + const TUid type(context.iType); + __ASSERT_ALWAYS(type!=KUidMsvFolderEntry, User::Panic(KImumMtmUiPanic, ESmtpMtmUiFoldersNotSupported)); + + //check that message is not corrupted and open + CMsvEntry& tmpEntry = iBaseMtm.Entry(); + TBool hasStore = tmpEntry.HasStoreL(); + + if( hasStore ) + { + IMUM_OUT(); + return EditL(aStatus); + } + else//if corrupt + { + User::Leave( KErrCorrupt ); + IMUM_OUT(); + return NULL;//execution never gets here...but complier will + } + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::OpenL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::OpenL(TRequestStatus& aStatus, const CMsvEntrySelection& aSelection) + { + IMUM_CONTEXT( CSmtpMtmUi::OpenL, 0, KImumMtmLog ); + IMUM_IN(); + + // Context is irrelevant. + __ASSERT_ALWAYS(aSelection.Count(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiEmptySelection)); + iBaseMtm.Entry().SetEntryL(aSelection[0]); + IMUM_OUT(); + return OpenL(aStatus); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::CloseL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::CloseL(TRequestStatus& aStatus) + { + IMUM_CONTEXT( CSmtpMtmUi::CloseL, 0, KImumMtmLog ); + IMUM_IN(); + + // Context is entry to close. + __ASSERT_DEBUG(iBaseMtm.Entry().Entry().iMtm==Type(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiWrongMtm)); + __ASSERT_DEBUG(iBaseMtm.Entry().Entry().iType!=KUidMsvFolderEntry, User::Panic(KImumMtmUiPanic, ESmtpMtmUiFoldersNotSupported)); + // No explicit close of SMTP entries. + CMsvCompletedOperation* op=CMsvCompletedOperation::NewL( Session(), Type(), KNullDesC8, KMsvLocalServiceIndexEntryId, aStatus); + IMUM_OUT(); + return op; + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::CloseL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::CloseL(TRequestStatus& aStatus, const CMsvEntrySelection& aSelection) + { + IMUM_CONTEXT( CSmtpMtmUi::CloseL, 0, KImumMtmLog ); + IMUM_IN(); + + // Context is irrelevant. + __ASSERT_ALWAYS(aSelection.Count(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiEmptySelection)); + iBaseMtm.Entry().SetEntryL(aSelection.At(0)); + IMUM_OUT(); + return CloseL(aStatus); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::EditL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::EditL(TRequestStatus& aStatus) + { + IMUM_CONTEXT( CSmtpMtmUi::EditL, 0, KImumMtmLog ); + IMUM_IN(); + + // Context is entry to edit. + __ASSERT_ALWAYS(iBaseMtm.Entry().Entry().iMtm==Type(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiWrongMtm)); + __ASSERT_DEBUG(iBaseMtm.Entry().Entry().iType!=KUidMsvFolderEntry, User::Panic(KImumMtmUiPanic, ESmtpMtmUiFoldersNotSupported)); + + switch (iBaseMtm.Entry().Entry().iType.iUid) + { + case KUidMsvMessageEntryValue: + IMUM_OUT(); + return LaunchEditorApplicationL(aStatus, EFalse, EFalse, iBaseMtm.Entry().Session() ); + //break; // Unreachable + case KUidMsvServiceEntryValue: + IMUM_OUT(); + return LaunchSettingsDialogL(aStatus); + //break; // Unreachable + default: + User::Leave(KErrNotSupported); + break; + }; + IMUM_OUT(); + return NULL; // Unreachable in practice. + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::EditL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::EditL(TRequestStatus& aStatus, const CMsvEntrySelection& aSelection) + { + IMUM_CONTEXT( CSmtpMtmUi::EditL, 0, KImumMtmLog ); + IMUM_IN(); + + // Context is irrelevant. + __ASSERT_ALWAYS(aSelection.Count(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiEmptySelection)); + iBaseMtm.Entry().SetEntryL(aSelection[0]); + IMUM_OUT(); + return EditL(aStatus); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::ViewL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::ViewL(TRequestStatus& aStatus) + { + IMUM_CONTEXT( CSmtpMtmUi::ViewL, 0, KImumMtmLog ); + IMUM_IN(); + + // Context is message to view. + __ASSERT_ALWAYS(iBaseMtm.Entry().Entry().iMtm==Type(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiWrongMtm)); + __ASSERT_ALWAYS(iBaseMtm.Entry().Entry().iType!=KUidMsvFolderEntry, User::Panic(KImumMtmUiPanic, ESmtpMtmUiFoldersNotSupported)); + + IMUM_OUT(); + return LaunchEditorApplicationL(aStatus, ETrue, EFalse, Session()); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::ViewL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::ViewL(TRequestStatus& aStatus, const CMsvEntrySelection& aSelection) + { + IMUM_CONTEXT( CSmtpMtmUi::ViewL, 0, KImumMtmLog ); + IMUM_IN(); + + // Context is irrelevant. + __ASSERT_ALWAYS(aSelection.Count(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiEmptySelection)); + iBaseMtm.Entry().SetEntryL(aSelection[0]); + IMUM_OUT(); + return ViewL(aStatus); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::CancelL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::CancelL(TRequestStatus& aStatus, const CMsvEntrySelection& aSelection) + { + IMUM_CONTEXT( CSmtpMtmUi::CancelL, 0, KImumMtmLog ); + IMUM_IN(); + + // Context is irrelevant. + __ASSERT_ALWAYS(aSelection.Count(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiEmptySelection)); + IMUM_OUT(); + return CSmtpCancelSendingOp::NewL( *iMailboxApi, aStatus, aSelection.CopyL()); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::CopyFromL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::CopyFromL(const CMsvEntrySelection& /*aSelection*/, TMsvId /*aTargetId*/, TRequestStatus& /*aStatus*/) + { + IMUM_CONTEXT( CSmtpMtmUi::CopyFromL, 0, KImumMtmLog ); + IMUM_IN(); + + User::Panic(KImumMtmUiPanic, ESmtpMtmUiCannotCopyOrMoveFromSmtpServiceOrFolder); + IMUM_OUT(); + return NULL; + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::MoveFromL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::MoveFromL(const CMsvEntrySelection& /*aSelection*/, TMsvId /*aTargetId*/, TRequestStatus& /*aStatus*/) + { + IMUM_CONTEXT( CSmtpMtmUi::MoveFromL, 0, KImumMtmLog ); + IMUM_IN(); + + User::Panic(KImumMtmUiPanic, ESmtpMtmUiCannotCopyOrMoveFromSmtpServiceOrFolder); + IMUM_OUT(); + return NULL; + } + +// ---------------------------------------------------------------------------- +// MoveToL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::MoveToL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus) + { + IMUM_CONTEXT( CSmtpMtmUi::MoveToL, 0, KImumMtmLog ); + IMUM_IN(); + IMUM_OUT(); + + return DoCopyMoveToL(aSelection, aStatus, ETrue); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::CopyToL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::CopyToL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus) + { + IMUM_CONTEXT( CSmtpMtmUi::CopyToL, 0, KImumMtmLog ); + IMUM_IN(); + IMUM_OUT(); + + return DoCopyMoveToL(aSelection, aStatus, EFalse); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::DoCopyMoveToL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::DoCopyMoveToL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus, TBool aMoving) + { + IMUM_CONTEXT( CSmtpMtmUi::DoCopyMoveToL, 0, KImumMtmLog ); + IMUM_IN(); + + // Context is service to send to. + const TMsvEntry& context=BaseMtm().Entry().Entry(); + __ASSERT_ALWAYS(context.iMtm==Type(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiWrongMtm)); + __ASSERT_ALWAYS(context.iType==KUidMsvServiceEntry, User::Panic(KImumMtmUiPanic, ESmtpMtmUiNotAService)); + + //smtp auth fix 23092002 + CheckAndRestoreSmtpUserAndPasswordL( BaseMtm().Entry().EntryId() ); + //fix end + + TInt cc = aSelection.Count(); + if(!cc) + { + // Nothing to do. + return CMsvCompletedOperation::NewL(Session(), Type(), KNullDesC8, KMsvLocalServiceIndexEntryId, aStatus); + } + // Iterate entries in selection and check them. + TBool changed = EFalse; + TMsvEntry entry; + TMsvId id = KMsvNullIndexEntryId; + User::LeaveIfError(Session().GetEntry(aSelection[0], id, entry)); + CMsvEntry* parent = Session().GetEntryL(entry.Parent()); + CleanupStack::PushL(parent); + CMsvEntry* centry = Session().GetEntryL(entry.Id()); + CleanupStack::PushL(centry); + while(cc--) + { + id = aSelection[cc]; + entry = parent->ChildDataL(id); + if(entry.iServiceId != context.Id()) + { + // If service ID does not match context, set to context ID. + entry.iServiceId = context.Id(); + changed = ETrue; + } + if(entry.SendingState() == KMsvSendStateSuspended) + { + // If the entry is suspended, set it to scheduled, or it will not be sent. + entry.SetSendingState(KMsvSendStateWaiting); + changed = ETrue; + } + if(changed) + { + if(centry->EntryId() != entry.Id()) + { + centry->SetEntryL(entry.Id()); + } + centry->ChangeL(entry); + changed = EFalse; + } + } + CleanupStack::PopAndDestroy(2, parent); // CSI: 47 # centry, parent. + + // Create send operation. + CMsvProgressReporterOperation* reporter = + CMsvProgressReporterOperation::NewL( + EFalse, + ETrue, + Session(), + aStatus, + EMbmAvkonQgn_note_mail ); + CleanupStack::PushL(reporter); + CMsvOperation* op = CSmtpCopyMoveOp::NewL(*iMailboxApi, reporter->RequestStatus(), + *reporter, context.Id(), aSelection, aMoving); + reporter->SetOperationL(op); // Takes immediate ownership + CleanupStack::Pop(); // reporter + IMUM_OUT(); + return reporter; + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::DisplayProgressSummary() +// ---------------------------------------------------------------------------- +TInt CSmtpMtmUi::DisplayProgressSummary(const TDesC8& aProgress) const + { + IMUM_CONTEXT( CSmtpMtmUi::DisplayProgressSummary, 0, KImumMtmLog ); + IMUM_IN(); + + // Context is irrelevent. + if( (!aProgress.Length()) || (aProgress.Size() == sizeof(TMsvLocalOperationProgress)) ) + { + IMUM_OUT(); + return KErrCancel; + } + + if( aProgress.Size() == sizeof(TMsvId) ) + { + // reason for this is that for CImEmailOperation did not fill iMtm correctly (it was always 0) + // and that caused that in mce app's CMceUi::DoOperationCompletedL leaves + // when trying to create mtm for displaying progress summary and execution + // never came here. Now CImEmailOperation sets its iMtm correctly and + // now CMceUi::DoOperationCompletedL works correcly and execution comes here. + // problem now is that how to make difference between imum's internal progress + // and CImEmailOperation progress since CImEmailOperation's progress is just + // TMsvId of the created mail message. This needs to be solved. + IMUM_OUT(); + return KErrNone; + } + + + // First element of progress should be identifier of the operation type + TPckgC progressType(0); + progressType.Set(aProgress.Left(sizeof(TInt))); + if(progressType()==ESmtpMtmUiEditing) + { + IMUM_OUT(); + return KErrNone; + } + + // SMTP MTM operations + __ASSERT_ALWAYS(aProgress.Size() == sizeof(TImSmtpProgress), User::Panic(KImumMtmUiPanic, ESmtpMtmUiBadProgress)); + TPckgBuf paramPack; + paramPack.Copy(aProgress); + const TImSmtpProgress& progress = paramPack(); + TInt err = progress.Error(); + if( err != KErrNone && err != KErrCancel && err != KErrGeneral && + err != KErrEtelBusyDetected && err != KErrAbort ) + { + if( err == KErrGprsServicesNotAllowed ) + { + err = KImskErrorActiveSettingIsDifferent; + } + TRAP_IGNORE( iErrorResolver->ShowGlobalErrorNoteL( err ) ); + } + IMUM_OUT(); + return err; + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::GetProgress() +// ---------------------------------------------------------------------------- +TInt CSmtpMtmUi::GetProgress( + const TDesC8& aProgress, + TBuf& aReturnString, + TInt& aTotalEntryCount, + TInt& aEntriesDone, + TInt& aCurrentEntrySize, + TInt& aCurrentBytesTrans) const + { + IMUM_CONTEXT( CSmtpMtmUi::GetProgress, 0, KImumMtmLog ); + IMUM_IN(); + + aEntriesDone=0; + aTotalEntryCount=0; + aCurrentBytesTrans=0; + aCurrentEntrySize=0; + aReturnString.Zero(); + + if( (!aProgress.Length()) || + (aProgress.Size() == sizeof(TMsvLocalOperationProgress)) ) + { + IMUM_OUT(); + return KErrNone; + } + + // First element of progress should be identifier of the operation type + TPckgC type( 0 ); + type.Set( aProgress.Left( sizeof( TInt ) ) ); + switch ( type() ) + { + case ESmtpMtmUiEditing: + IMUM_OUT(); + // Editor operation + return KErrNone; + + case EUiProgTypeConnecting: + IMUM_OUT(); + // Connecting progress + return GetConnectionProgress(aProgress, aReturnString); + + default: + break; + } + + // SMTP MTM operations + __ASSERT_ALWAYS(aProgress.Size() == sizeof(TImSmtpProgress), User::Panic(KImumMtmUiPanic, ESmtpMtmUiBadProgress)); + TPckgBuf paramPack; + paramPack.Copy(aProgress); + const TImSmtpProgress& progress = paramPack(); + + aTotalEntryCount = progress.SendTotal(); + aEntriesDone = Min(aTotalEntryCount, progress.MsgNo()+1); + aCurrentEntrySize = progress.iSendFileProgress.iBytesToSend; + aCurrentBytesTrans = progress.iSendFileProgress.iBytesSent; + + TInt err = progress.Error(); + switch(progress.Status()) + { + case EMsgOutboxProgressSending: + { + TInt resId = (aTotalEntryCount == 1) ? (R_SMTP_SENDING_PROGRESS) : (R_SMTP_SENDING_PROGRESS_MULTIPLE); + StringLoader::Load( aReturnString, resId, iCoeEnv); + if ( aTotalEntryCount>1 ) + { + TBuf tempBuffer; + StringLoader::Format( + tempBuffer, + aReturnString, + KImumEntriesDoneReplaceIndex, + aEntriesDone ); + StringLoader::Format( + aReturnString, + tempBuffer, + KImumTotalEntriesReplaceIndex, + aTotalEntryCount ); + } + err = progress.Error(); + } + break; + case EMsgOutboxProgressWaiting: + case EMsgOutboxProgressConnecting: + default: + // Should not get any other statuses, get UI connection progress instead. + aReturnString.Zero(); + break; + } + IMUM_OUT(); + return err; + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::GetConnectionProgress() +// ---------------------------------------------------------------------------- +TInt CSmtpMtmUi::GetConnectionProgress(const TDesC8& aProgress, TBuf& aReturnString) const + { + IMUM_CONTEXT( CSmtpMtmUi::GetConnectionProgress, 0, KImumMtmLog ); + IMUM_IN(); + + __ASSERT_ALWAYS(aProgress.Size() == sizeof(TMsvEmailConnectionProgress), User::Panic(KImumMtmUiPanic, ESmtpMtmUiBadProgress)); + TPckgBuf paramPack; + paramPack.Copy(aProgress); + const TMsvEmailConnectionProgress& connectProgress = paramPack(); + + MsvEmailMtmUiUtils::CreateConnectingToText( aReturnString, + Session(), connectProgress.iService ); + IMUM_OUT(); + + return KErrNone; + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::DoExitL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::DoExitL( + TRequestStatus& aStatus, + const TBool aIssueQuit ) + { + IMUM_CONTEXT( CSmtpMtmUi::DoExitL, 0, KImumMtmLog ); + IMUM_IN(); + + TInt err = aIssueQuit ? EEikCmdExit : EEikCmdCanceled; + IMUM_OUT(); + + // Nothing to do, so return a completed operation. + return CMsvCompletedOperation::NewL( + Session(), Type(), KNullDesC8, + KMsvLocalServiceIndexEntryId, aStatus, err ); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::LaunchEditorApplicationL() +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::LaunchEditorApplicationL( + TRequestStatus& aStatus, + TBool aReadOnly, + TBool aNewMsg, + CMsvSession& aSession, + TMsvId aNewMsgServiceId) + { + IMUM_CONTEXT( CSmtpMtmUi::LaunchEditorApplicationL, 0, KImumMtmLog ); + IMUM_IN(); + + // Context is irrelevant. + + // Create the parameters necessary for the editor + TEditorParameters editorParams; + TMsvEntry entry = BaseMtm().Entry().Entry(); + if ( entry.Parent() != KMsvDraftEntryId ) + { + aReadOnly = ETrue; + } + if (aReadOnly) + { + editorParams.iFlags|=EMsgReadOnly; + } + + if ( !aReadOnly ) + { + // we are opening the editor, check that there is at least one mail service defined + TMsvId serviceId = entry.iServiceId; + TSmtpMtmUiCreateNewServiceParameters aSaveParameters; + + if ( !CheckMailboxesBeforeEditL( serviceId, aSaveParameters ) ) + { + if ( aSaveParameters == ESmtpMtmUiCreateNewServiceExit ) + { + return CMsvCompletedOperation::NewL(Session(), Type(), KNullDesC8, KMsvLocalServiceIndexEntryId, aStatus, EEikCmdExit ); + } + else + { + return CMsvCompletedOperation::NewL(Session(), Type(), KNullDesC8, KMsvLocalServiceIndexEntryId, aStatus); + } + } + if ( serviceId != entry.iServiceId ) + { + // service has been changed, change it to the entry too... + entry.iServiceId = serviceId; + BaseMtm().Entry().ChangeL( entry ); + } + } + + if (aNewMsg) + { + // Creating new message. The EMsgCreateMessageToService flag specifies that + // editorParams.iId is the SMTP service to use for the message. + __ASSERT_DEBUG(aNewMsgServiceId != KMsvNullIndexEntryIdValue, User::Panic(KImumMtmUiPanic, ESmtpMtmUiNullNewMsgService)); + editorParams.iFlags |= EMsgCreateMessageToService; + editorParams.iId = aNewMsgServiceId; + } + else + { + editorParams.iId=BaseMtm().Entry().EntryId(); + } + + // + // --- This is a MTM UI operation only, so make an appropriate progress package --- + // --- Editor progress is blank, except for the opreation identifier --- + TPckgC paramPack(ESmtpMtmUiEditing); + HBufC* appName = NULL; + if(aReadOnly) + { + if(!iViewerFilename) + ResolveViewerFileNameL(); + appName = iViewerFilename; + } + else + { + if(!iEditorFilename) + ResolveEditorFileNameL(); + appName = iEditorFilename; + } + + const TUint preferences = Preferences(); + editorParams.iFlags &= ~(EMsgLaunchEditorEmbedded | EMsgLaunchEditorThenWait); + if(preferences & EMtmUiFlagEditorPreferEmbedded) + { + editorParams.iFlags |= EMsgLaunchEditorEmbedded; + } + if(!(preferences & EMtmUiFlagEditorNoWaitForExit)) + { + editorParams.iFlags |= EMsgLaunchEditorThenWait; + } + IMUM_OUT(); + + return MsgEditorLauncher::LaunchEditorApplicationL( + aSession, Type(), aStatus, editorParams, *appName, paramPack ); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::HandleNoAccountsL() +// ---------------------------------------------------------------------------- +TMsvId CSmtpMtmUi::HandleNoAccountsL(TSmtpMtmUiCreateNewServiceParameters& aSaveParameters ) + { + IMUM_CONTEXT( CSmtpMtmUi::HandleNoAccountsL, 0, KImumMtmLog ); + IMUM_IN(); + + // Context is irrelevant. + if ( !CIMSSettingsNoteUi::ShowQueryL( + R_SMTP_CREATE_NEED_MAILBOX_TITLE, R_EMAIL_CONFIRMATION_QUERY ) ) + { + // User cancelled. + aSaveParameters = ESmtpMtmUiCreateNewServiceNotCreated; + return KMsvNullIndexEntryId; + } + + //Show empty navipane + CEikStatusPane* sp = iEikonEnv->AppUiFactory()->StatusPane(); + CAknNavigationControlContainer* naviPane = static_cast( + sp->ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ) ); + CAknNavigationDecorator* naviDecorator = naviPane->CreateNavigationLabelL(); + CleanupStack::PushL(naviDecorator); + naviPane->PushL( *naviDecorator ); + + TMsvEntry nentry; + nentry.iMtm = Type(); + nentry.iType = KUidMsvServiceEntry; + nentry.iDate.HomeTime(); + nentry.iServiceId = KMsvNullIndexEntryId; + + // Note that we don't pre-create a message for this account here since we will + // be launching an editor immediately afterwards. + IMUM_OUT(); + + // Newly created service will be the default. + TMsvId serviceId = CreateNewServiceL(nentry, aSaveParameters); + //Remove empty navipane + naviPane->Pop( naviDecorator ); + CleanupStack::PopAndDestroy( naviDecorator ); + return serviceId; + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::PrepareCommandL() +// ---------------------------------------------------------------------------- +// +CMsvOperation* CSmtpMtmUi::PrepareCommandL( + TEditorParameters& aParameters, + TMsvId aDestination, + TMsvPartList aPartlist, + TRequestStatus& aCompletionStatus ) + { + IMUM_CONTEXT( CSmtpMtmUi::PrepareCommandL, 0, KImumMtmLog ); + IMUM_IN(); + + const TMsvEntry& entry = BaseMtm().Entry().Entry(); + + if ( entry.iType.iUid != KUidMsvMessageEntryValue ) + { + User::Leave( KErrNotSupported ); + } + + // Set editor name + HBufC* appName = NULL; + if(!iEditorFilename) + { + ResolveEditorFileNameL(); + } + appName = iEditorFilename; + + // Set params + aParameters.iId=entry.Id(); + aParameters.iPartList = aPartlist; + aParameters.iDestinationFolderId = aDestination; + + // Mark as read + ChangeUnreadFlagL( entry.Id(), EFalse ); + + // Handle preferences + const TUint preferences = Preferences(); + aParameters.iFlags &= + ~( EMsgLaunchEditorEmbedded | EMsgLaunchEditorThenWait ); + + if ( preferences & EMtmUiFlagEditorPreferEmbedded ) + { + aParameters.iFlags |= EMsgLaunchEditorEmbedded; + } + if ( !( preferences & EMtmUiFlagEditorNoWaitForExit ) ) + { + aParameters.iFlags |= EMsgLaunchEditorThenWait; + } + + // Launch editor + TPckgC paramPack( ESmtpMtmUiEditing ); + IMUM_OUT(); + return MsgEditorLauncher::LaunchEditorApplicationL( + Session(), Type(), aCompletionStatus, aParameters, + *appName, paramPack); + } + + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::ReplyL() +// ---------------------------------------------------------------------------- +// +CMsvOperation* CSmtpMtmUi::ReplyL( + TMsvId aDestination, + TMsvPartList aPartlist, + TRequestStatus& aCompletionStatus ) + { + IMUM_CONTEXT( CSmtpMtmUi::ReplyL, 0, KImumMtmLog ); + IMUM_IN(); + + TEditorParameters editorParams; + editorParams.iFlags |= EMsgReplyToMessageAll; + IMUM_OUT(); + + return PrepareCommandL( + editorParams, aDestination, aPartlist, aCompletionStatus ); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::ForwardL() +// ---------------------------------------------------------------------------- +// +CMsvOperation* CSmtpMtmUi::ForwardL( + TMsvId aDestination, + TMsvPartList aPartlist, + TRequestStatus& aCompletionStatus) + { + IMUM_CONTEXT( CSmtpMtmUi::ForwardL, 0, KImumMtmLog ); + IMUM_IN(); + + TEditorParameters editorParams; + editorParams.iFlags |= EMsgForwardMessage; + IMUM_OUT(); + + return PrepareCommandL( + editorParams, aDestination, aPartlist, aCompletionStatus ); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::GetMailboxNameL() +// ---------------------------------------------------------------------------- +HBufC* CSmtpMtmUi::GetMailboxNameL(TMsvId aServiceId) const + { + IMUM_CONTEXT( CSmtpMtmUi::GetMailboxNameL, 0, KImumMtmLog ); + IMUM_IN(); + + TMsvEntry serviceEntry = + iMailboxApi->MailboxUtilitiesL().GetMailboxEntryL( aServiceId ); + IMUM_OUT(); + return serviceEntry.iDetails.AllocL(); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::CheckMailboxesBeforeEditL() +// ---------------------------------------------------------------------------- +TBool CSmtpMtmUi::CheckMailboxesBeforeEditL( TMsvId& aServiceId, TSmtpMtmUiCreateNewServiceParameters& aSaveParameters ) + { + IMUM_CONTEXT( CSmtpMtmUi::CheckMailboxesBeforeEditL, 0, KImumMtmLog ); + IMUM_IN(); + + // checks if aServiceId exists and if not checks that there is default service and + // if no services, then asks to create one + TMsvEntry serviceEntry; + TMsvId serviceId; + aSaveParameters = ESmtpMtmUiCreateNewServiceNotCreated; + if ( Session().GetEntry( aServiceId, serviceId, serviceEntry ) == KErrNone ) + { + IMUM_OUT(); + // given service exists + return ETrue; + } + + // given service does not exists, check if there is default one: + serviceId = MsvUiServiceUtilitiesInternal::DefaultServiceForMTML( + Session(), + Type(), + ETrue ); + + if ( serviceId != KMsvUnknownServiceIndexEntryId ) + { + // default exists! + aServiceId = serviceId; + IMUM_OUT(); + return ETrue; + } + + // no mailboxes, ask to create one + serviceId = HandleNoAccountsL( aSaveParameters ); + + if ( serviceId != KMsvUnknownServiceIndexEntryId && + serviceId != KMsvNullIndexEntryId && + aSaveParameters == ESmtpMtmUiCreateNewServiceSave ) + { + aServiceId = serviceId; + IMUM_OUT(); + return ETrue; + } + IMUM_OUT(); + return EFalse; + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::ChangeUnreadFlagL() +// ---------------------------------------------------------------------------- +// +void CSmtpMtmUi::ChangeUnreadFlagL( + const TMsvId aEmailId, + const TBool aNewState ) + { + IMUM_CONTEXT( CSmtpMtmUi::ChangeUnreadFlagL, 0, KImumMtmLog ); + IMUM_IN(); + + // Prepare the entry + CMsvEntry* entry = ( CMsvEntry::NewL( + *iMsvSession, aEmailId, TMsvSelectionOrdering() ) ); + CleanupStack::PushL( entry ); + TMsvEntry email = entry->Entry(); + + // Set the unread flag + email.SetUnread( aNewState ); + entry->ChangeL( email ); + + CleanupStack::PopAndDestroy( entry ); + entry = NULL; + IMUM_OUT(); + } + + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::LaunchSettingsDialogL +// ---------------------------------------------------------------------------- +CMsvOperation* CSmtpMtmUi::LaunchSettingsDialogL( + TRequestStatus& aStatus ) + { + IMUM_CONTEXT( CSmtpMtmUi::LaunchSettingsDialogL, 0, KImumMtmLog ); + IMUM_IN(); + + // Get the TMsvEntry for the service. + TMsvEntry msvEntry( BaseMtm().Entry().Entry() ); + TMsvEntry rcvEntry = iUtils->GetMailboxEntryL( msvEntry.iRelatedId ); + + // Do this earlies phase possible, to guarrentee there won't be any + // useless mailboxes around + iMailboxApi->HealthServicesL().CleanupUnhealthyMailboxes(); + + TBool quit( EFalse ); + + // Mailbox should not be connected when settings are edited + if ( !rcvEntry.Connected() || + MsvEmailMtmUiUtils::DisconnectMailboxL( rcvEntry, Session() ) ) + { + // Create and load email account + CImumInSettingsData* accountSettings = + iMailboxApi->MailboxServicesL().LoadMailboxSettingsL( + msvEntry.Id() ); + CleanupStack::PushL( accountSettings ); + + // Create message for receiving protocol and send it to Always Online + TPckgBuf param = msvEntry.iRelatedId; + TRAP_IGNORE( iAOClient.SendSinglePacketL( + EServerAPIEmailTurnOff, param ) ); + + // Bring the settings to user + TImumUiExitCodes exitcode = EImumUiNoChanges; + CIMSSettingsUi::EditAccountL( exitcode, *accountSettings, *iMsvSession ); + + // Create completed operation to finish the settings + quit = SettingsDialogExitL( *accountSettings, exitcode ); + + // Get the emn setting + TInt emn = TImumDaSettings::EValueNotificationsOff; + accountSettings->GetAttr( + TImumDaSettings::EKeyAutoNotifications, emn ); + + // Get the always online setting + TInt alwaysOnline = TImumDaSettings::EValueAutoOff; + accountSettings->GetAttr( + TImumDaSettings::EKeyAutoRetrieval, alwaysOnline ); + + // Send turn on message to plugin, if either AO or EMN is turned on. + TAlwaysOnlineServerAPICommands command = + ( alwaysOnline != EMailAoOff || emn != EMailEmnOff ) ? + EServerAPIEmailTurnOn : EServerAPIEmailAgentRemove; + + CleanupStack::PopAndDestroy( accountSettings ); + accountSettings = NULL; + + // Turn on the Always Online to current mailbox + iAOClient.SendSinglePacketL( command, param ); + } + if ( quit ) + { + // Delete precreated emails because they might contain old signature. + // Since we're in a hurry to exit, we don't recreate them. + iPreCreate->DeleteAllPreCreatedEmailsL( msvEntry.Id() ); + + IMUM_OUT(); + return DoExitL( aStatus, quit ); + } + else + { + IMUM_OUT(); + //Let's start the empty email creation + return CSmtpResetPreCreationOp::NewL( + Session(), aStatus, msvEntry.Id() ); + } + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::SettingsDialogExitL() +// ---------------------------------------------------------------------------- +// +TBool CSmtpMtmUi::SettingsDialogExitL( + CImumInSettingsData& aSettings, + const TImumUiExitCodes& aExitCode ) + { + IMUM_CONTEXT( CSmtpMtmUi::SettingsDialogExitL, 0, KImumMtmLog ); + IMUM_IN(); + + TBool quit = EFalse; + // Check the exit code + switch( aExitCode ) + { + // Save the settings + case EImumUiSaveAndClose: + SettingsDialogExitSaveAndExitL( aSettings ); + break; + + // Save the settings and quit + case EImumUiSaveAndExit: + SettingsDialogExitSaveAndExitL( aSettings ); + + //lint -fallthrough + case EImumUiExit: + quit = ETrue; + break; + + default: + // Nothing to do + break; + } + IMUM_OUT(); + + return quit; + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::SettingsDialogExitSaveAndExitL() +// ---------------------------------------------------------------------------- +// +void CSmtpMtmUi::SettingsDialogExitSaveAndExitL( + CImumInSettingsData& aSettings ) + { + IMUM_CONTEXT( CSmtpMtmUi::SettingsDialogExitSaveAndExitL, 0, KImumMtmLog ); + IMUM_IN(); + + TInt ao = ImumMboxSettingsUtils::QuickGetL( + aSettings, TImumDaSettings::EKeyAutoRetrieval ); + + //restore original alwaysonline setting + if ( ImumMboxSettingsUtils::IsImap4( aSettings ) && + ao == TImumDaSettings::EValueAutoOff ) + { + //switching off, set default syncrate + aSettings.GetInSetL( 0 ).Reset( TImumInSettings::EKeySyncRate ); + } + + // Save the settings + iMailboxApi->MailboxServicesL().SaveMailboxSettingsL( aSettings ); + TMsvId id = ImumMboxSettingsUtils::QuickGetL( + aSettings, TImumDaSettings::EKeyMailboxId, 0 ); + IMUM_OUT(); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::CreateNewServiceL +// ---------------------------------------------------------------------------- +TMsvId CSmtpMtmUi::CreateNewServiceL( + const TMsvEntry& aEntry, + TSmtpMtmUiCreateNewServiceParameters& aSaveParameters ) + { + IMUM_CONTEXT( CSmtpMtmUi::CreateNewServiceL, 0, KImumMtmLog ); + IMUM_IN(); + + // This function is called, when new account is to be created. The account + // is created, after user has succesfully finished the mailbox settings + // wizard. + // Do this earlies phase possible, to guarrentee there won't be any + // useless mailboxes around + iMailboxApi->HealthServicesL().CleanupUnhealthyMailboxes(); + + // Make sure empty index has been given + if ( aEntry.iServiceId != KMsvNullIndexEntryId && + aEntry.iServiceId != KMsvUnknownServiceIndexEntryId ) + { + User::Leave( KErrUnknown ); + } + + // Run the mailbox settings + TMsvId id = 0; + TImumUiExitCodes exitcode = EImumUiNoChanges; + + //Check if mail settings are locked + if( iMailboxApi->IsEmailFeatureSupportedL( + CImumInternalApi::EMailLockedSettings, R_QTN_SELEC_PROTECTED_SETTING ) ) + { + aSaveParameters = ESmtpMtmUiCreateNewServiceNotCreated; + } + else + { + // Settings wizard fills in the settings object + CImumInSettingsData* accountSettings = + iMailboxApi->MailboxServicesL().CreateSettingsDataL( TUid::Uid( 0 ) ); + CleanupStack::PushL( accountSettings ); + + // lets clear the screen so that MCE is not seen on the background after wizard is + // finished and new view is activated + CAknLocalScreenClearer* localScreenClearer = + CAknLocalScreenClearer::NewLC( EFalse ); + + // Add ScreenClearer to control stack + CEikonEnv::Static()->EikAppUi()->AddToStackL( + localScreenClearer, ECoeStackPriorityDefault, + ECoeStackFlagRefusesAllKeys|ECoeStackFlagRefusesFocus ); + + // If application leaves make sure the screen clearer is removed + // from control stack. + CleanupStack::PushL( TCleanupItem( &ScreenClearerCleanupOperation, + localScreenClearer ) ); + + + // Run wizard, run! + id = CIMSSettingsUi::NewAccountL( + exitcode, *accountSettings, *iMsvSession ); + aSaveParameters = SaveParams( exitcode ); + + TMsvEntry tentry; + + if( exitcode != EImumUiExtWizardCreated ) + { + if ( aSaveParameters == ESmtpMtmUiCreateNewServiceSave || + aSaveParameters == ESmtpMtmUiCreateNewServiceSaveAndExit ) + { + id = iMailboxApi->MailboxServicesL().CreateMailboxL( + *accountSettings ); + } + } + + if ( exitcode == EImumUiExtWizardCreated || + aSaveParameters == ESmtpMtmUiCreateNewServiceSave || + aSaveParameters == ESmtpMtmUiCreateNewServiceSaveAndExit ) + { + // check that there is actually a mailbox generated + if( iMailboxApi->MailboxUtilitiesL().IsMailbox( id ) ) + { + tentry = iMailboxApi->MailboxUtilitiesL().GetMailboxEntryL( id ); + } + } + + // If view is activated when EImumUiExit, MCE will be reopened which + // is not desirable. + if ( exitcode != EImumUiExit ) + { + // check which view should be activated after wizard is run + if( tentry.iMtm.iUid == KErrNone ) + { + /* + * No actual mailbox was defined, so activate MCE + * main view. + * + * This could be the case for example with webmail + * accounts that don't actually create an actual + * mailbox entry. + */ + ActivateViewL( EImumUiNoChanges, id ); + } + else + { + // POP/IMAP mailbox entry created, open correct view + ActivateViewL( exitcode, tentry.iRelatedId ); + } + } + + // Pop and destroy TCleanupItem, localScreenClearer and accountSettings + // TCleanupItem calls ScreenClearerCleanupOperation that removes + // ScreenClearer from control stack. + CleanupStack::PopAndDestroy( 3, accountSettings ); + localScreenClearer = NULL; + accountSettings = NULL; + } + IMUM_OUT(); + + // Return the mailbox id + return id; + } + +// ---------------------------------------------------------------------------. +// CSmtpMtmUi::SaveParams() +// --------------------------------------------------------------------------- +// +CSmtpMtmUi::TSmtpMtmUiCreateNewServiceParameters CSmtpMtmUi::SaveParams( + const TImumUiExitCodes& aUiExitCode ) + { + IMUM_CONTEXT( CSmtpMtmUi::TSmtpMtmUiCreateNewServiceParameters, 0, KImumMtmLog ); + IMUM_IN(); + + TSmtpMtmUiCreateNewServiceParameters params = + ESmtpMtmUiCreateNewServiceNotCreated; + + // Map account settings exit values to save parameters + switch ( aUiExitCode ) + { + case EImumUiNoChanges: // Nothing has changed, no need for save + case EImumUiClose: // After back key has been pressed, exit settings + default: + params = ESmtpMtmUiCreateNewServiceNotCreated; + break; + + // After back key has been pressed, save and exit settings + case EImumUiSaveAndClose: + // External wizard created a new mailbox. ESmtpMtmUiCreateNewServiceSave + // must be set to param because we have to inform that the mailbox is + // created. So in this case we must not save the mailbox because + // External Wizard is already saved it. + case EImumUiExtWizardCreated: + params = ESmtpMtmUiCreateNewServiceSave; + break; + + // After options->exit has been chose, exit settings + case EImumUiExit: + params = ESmtpMtmUiCreateNewServiceExit; + break; + + // After options->exit has been chose, save and exit settings + case EImumUiSaveAndExit: + params = ESmtpMtmUiCreateNewServiceSaveAndExit; + break; + + } + IMUM_OUT(); + + return params; + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::HandlePredefinedMailboxCreationL +// ---------------------------------------------------------------------------- +void CSmtpMtmUi::HandlePredefinedMailboxCreationL() + { + IMUM_CONTEXT( CSmtpMtmUi::HandlePredefinedMailboxCreationL, 0, KImumMtmLog ); + IMUM_IN(); + + // First, it needs to be check, does the system contain previously defined + // mailboxes. This is to prevent failure cases, when mtm attempts to + // initialise email mtm's several times in row. + MImumInHealthServices::RMailboxIdArray mailboxes; + iMailboxApi->HealthServicesL().GetMailboxList( mailboxes ); + TBool allowCreation = ETrue; + + // Check if there's any predefined mailboxes available + for ( TInt mailbox = mailboxes.Count(); + allowCreation && --mailbox >= 0; ) + { + // If the key is not set, the mailbox is propably created by the + // user + TRAP_IGNORE( allowCreation = !ImumMboxSettingsUtils::QuickLoadL( // CSI: 59 # codescanner gives critical error for some reason + *iMailboxApi, + mailboxes[mailbox], + TImumInSettings::EKeyIsPredefinedMailbox ) ); + } + mailboxes.Reset(); + + // The mailbox creation can start + if ( allowCreation ) + { + // Create the mailbox creator unit + CImumCreatorPredefinedMailbox* creator = + CImumCreatorPredefinedMailbox::NewLC( *iMailboxApi ); + TUid protocol = TUid::Uid( 0 ); + + // Create all possible mailboxes + for ( TInt i=0; iMailboxServicesL().CreateSettingsDataL( + protocol ); + CleanupStack::PushL( account ); + + if ( creator->DefinePredefinedMailboxL( i, *account ) ) + { + iMailboxApi->MailboxServicesL().CreateMailboxL( *account ); + } + + // Mailbox has been saved, remove the object + CleanupStack::PopAndDestroy( account ); + account = NULL; + } + + CleanupStack::PopAndDestroy( creator ); + } + IMUM_OUT(); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::CheckAndRestoreSmtpUserAndPasswordL +// ---------------------------------------------------------------------------- +void CSmtpMtmUi::CheckAndRestoreSmtpUserAndPasswordL( TMsvId aSmtpServiceId ) + { + IMUM_CONTEXT( CSmtpMtmUi::CheckAndRestoreSmtpUserAndPasswordL, 0, KImumMtmLog ); + IMUM_IN(); + + // Get settings. + TBuf8 username8; + TBuf8 password8; + TBool isPasswordTemporary = EFalse; + + // Load login information + ImumMboxSettingsUtils::GetLoginInformationL( + *iMailboxApi, + username8, + password8, + isPasswordTemporary, + aSmtpServiceId ); + + // Temporary information is not accepted as valid data + if ( isPasswordTemporary ) + { + // Have a valid password. + password8.Zero(); + + // Save login information + ImumMboxSettingsUtils::SetLoginInformationL( + *iMailboxApi, + username8, + password8, + isPasswordTemporary, + aSmtpServiceId ); + } + IMUM_OUT(); + } + + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::ValidateServiceL +// ---------------------------------------------------------------------------- +void CSmtpMtmUi::ValidateServiceL( TDes8& aParameter ) + { + IMUM_CONTEXT( CSmtpMtmUi::ValidateServiceL, 0, KImumMtmLog ); + IMUM_IN(); + + DoValidateServiceL( iUtils->DefaultMailboxId(), aParameter ); + IMUM_OUT(); + } + +// --------------------------------------------------------------------------- +// CSmtpMtmUi::ValidateServiceL() +// --------------------------------------------------------------------------- +// +void CSmtpMtmUi::ValidateServiceL( + const CMsvEntrySelection& aSelection, + TDes8& aParameter ) + { + IMUM_CONTEXT( CSmtpMtmUi::ValidateServiceL, 0, KImumMtmLog ); + IMUM_IN(); + + if ( aSelection.Count() ) + { + DoValidateServiceL( aSelection[0], aParameter ); + } + IMUM_OUT(); + } + +// --------------------------------------------------------------------------- +// CSmtpMtmUi::DoValidateServiceL() +// --------------------------------------------------------------------------- +// +void CSmtpMtmUi::DoValidateServiceL( + const TMsvId aMailboxId, + TDes8& aParameter ) + { + IMUM_CONTEXT( CSmtpMtmUi::DoValidateServiceL, 0, KImumMtmLog ); + IMUM_IN(); + + TInt result = + iMailboxApi->HealthServicesL().IsMailboxHealthy( aMailboxId ); + // 0 = KErrNone, other values indicate error + TPckgBuf resultPackage( !result ); + aParameter.Copy( resultPackage ); + IMUM_OUT(); + } +// --------------------------------------------------------------------------- +// CSmtpMtmUi::ActivateViewL() +// Activates right view after email wizard +// --------------------------------------------------------------------------- +// +void CSmtpMtmUi::ActivateViewL( TImumUiExitCodes aExitCode, TMsvId aId ) + { + IMUM_CONTEXT( CSmtpMtmUi::DoValidateServiceL, 0, KImumMtmLog ); + IMUM_IN(); + CAknViewAppUi* appUi = reinterpret_cast + (CEikonEnv::Static()->EikAppUi()); + + // If launched oustide of MCE, mce-view shouldn't be activated + if ( appUi->Application()->AppDllUid() == TUid::Uid( KMceUid ) ) + { + switch( aExitCode ) + { + // If no mailbox created, let's return to main view + case EImumUiNoChanges: + case EImumUiClose: + case EImumUiExit: + appUi->ActivateLocalViewL( KMceMainViewListViewId ); + break; + // If mailbox created, let's open it + case EImumUiSaveAndExit: + case EImumUiSaveAndClose: + case EImumUiExtWizardCreated: + appUi->ActivateLocalViewL( KMceMessageListViewId, + TUid::Uid( aId ), KNullDesC8 ); + break; + default: + break; + } + } + IMUM_OUT(); + } + +// ---------------------------------------------------------------------------- +// CSmtpMtmUi::ScreenClearerCleanupOperation +// ---------------------------------------------------------------------------- +// +void CSmtpMtmUi::ScreenClearerCleanupOperation( TAny* aScreenClearer ) + { + CEikonEnv::Static()->EikAppUi()->RemoveFromStack( + static_cast( aScreenClearer ) ); + } + +// End of File + + +