--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/messagingappbase/mce/src/mceui.cpp Thu Dec 17 08:44:11 2009 +0200
@@ -0,0 +1,6906 @@
+/*
+* Copyright (c) 2002 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:
+* Defines methods for CMceUi
+*
+*/
+
+
+
+
+// INCLUDE FILES
+#include <bldvariant.hrh>
+#include <featmgr.h>
+
+#include <messagingvariant.hrh>
+#include <centralrepository.h>
+#include <messaginginternalcrkeys.h>
+#include <CoreApplicationUIsSDKCRKeys.h>
+
+// security data caging
+#include <data_caging_path_literals.hrh>
+
+#include <mtudreg.h> // cmtmuidataregistry
+#include <MTMStore.h> // cmtmstore
+#include <miutset.h>
+#include <MuiuMsvProgressReporterOperation.h> // cmsvprogressreporteroperation
+#include <mtmdef.h> // KUidMtmQueryCanSendMsgValue
+#include <msvids.h>
+#include <msvuids.h>
+#include <mtud.hrh> // EMtudCommandTransferSend, EMtudCommandTransferSend, EMtudCommandTransferReceive
+#include <MuiuMessageIterator.h>// cmessageiterator
+#include <MuiuMsgEmbeddedEditorWatchingOperation.h> // tmsgexitmode
+#include <MuiuOperationWait.h> // cmuiuoperationwait
+#include <muiumsvuiserviceutilitiesinternal.h> // msvuiserviceutilitiesinternal
+#include <MuiuMsvUiServiceUtilities.h> // msvuiserviceutilities
+class CGulIcon;
+#include <MsgFolderSelectionDialog.h>
+#include <PushMtmCommands.hrh> // epushmtmcmdcollectgarbage
+#include <smutcmds.hrh> // KMtmUiFunctionSmumRemoveSMSC
+#include <MsgBioUids.h> // kmsgbiouidpicturemsg
+#include <mtuireg.h> // CMtmUiRegistry
+#include <mmsconst.h>
+#include <obexclientmtm.h>
+#include <MuiuOperationWait.h> // cmuiuoperationwait
+#include <muiu.mbg>
+#include <muiu.rsg>
+#include <MuiuMsvUiServiceUtilities.h>
+#include <mtmuidef.hrh>
+
+#include <SenduiMtmUids.h> // mtm uids
+#include <SendUiConsts.h>
+
+// MMS.Content.Upload
+#include <CSendingServiceInfo.h>
+#include <sendui.h>
+#include <CMessageData.h>
+
+
+#include <aknappui.h>
+#include <StringLoader.h> // stringloader
+#include <akntabgrp.h>
+#include <aknnavide.h>
+#include <aknclearer.h>
+#include <aknnotewrappers.h>
+#include <akninputblock.h> // cakninputblock
+#include <akntitle.h>
+#include <ErrorUI.h> // cerrorui
+#include <aknnotedialog.h>
+#include <akninputblock.h> // cakninputblock
+#include <akncontext.h>
+
+#include <gfxtranseffect/gfxtranseffect.h> // for transition effects
+#include <akntranseffect.h> // for transition effects
+
+#include <DocumentHandler.h>
+
+
+#include <RCustomerServiceProfileCache.h>
+
+
+// MMS.Content.Upload
+#include <muiumsguploadparam.h>
+#include <CSendingServiceInfo.h>
+
+#include <ImumInternalApi.h> // cimuminternalapi
+#include <ImumInMailboxServices.h> // mimuminmailboxservices
+#include <ImumInSettingsData.h> // cimuminsettingsdata
+#include <ImumInSettingsKeys.h> // timuminsettings
+#include <UiklafInternalCRKeys.h>
+
+#include <MNcnInternalNotification.h>
+#include <NcnNotificationDefs.h>
+
+#include <BTSapDomainPSKeys.h>
+#include <e32property.h>
+
+#include <muiulock.h>
+
+#include <messaginginternalpskeys.h> // kpsuidmuiu, kmuiukeycurrentmsg
+#include <e32property.h> // RProperty
+
+#include <CPhCltUssd.h>
+
+#include <RPhCltServer.h>
+
+#include <hlplch.h> // For HlpLauncher
+
+// For Muiu split
+#include <muiumsvuiserviceutilitiesinternal.h>
+
+#include <ImumInternalApi.h> // cimuminternalapi
+
+#ifdef RD_MULTIPLE_DRIVE
+#include <driveinfo.h>
+#endif // RD_MULTIPLE_DRIVE
+
+#include <mce.rsg>
+#include "MceCommands.hrh"
+#include "mceui.h"
+#include "MceSessionHolder.h"
+#include "MceMessageListView.h"
+//#include "MceMessageListbox.h"
+#include "MceMainViewListView.h"
+#include <mcesettingsdialog.h>
+#include <mcesettingsarrays.h>
+#include "MceMessageListContainerBase.h"
+//#include "MceMessageListContainer.h"
+#include "MceMainViewListContainer.h"
+#include "MceBitmapResolver.h"
+#include "MceConnectMailboxTimer.h"
+#include "MceSendOperation.h"
+#include "McePanic.h"
+#include "MceLogEngine.h"
+#include "MceDeliveryReportView.h"
+//#include "MceMessageListItemArray.h"
+#include "MceMainViewListItemArray.h"
+#include "MceIdleMtmLoader.h"
+#include "MceNaviPaneFolderIndicator.h"
+//#include "MceEmailEditorResetTimer.h"
+#include "MceCancelSendingOperation.h"
+#include "MceChangeFlagOperation.h" // cmceremovenewflag
+#include "MceEmailNotifHandler.h"
+#include "MceAttachmentAddition.h"
+#include "mceiaupdateutils.h"
+
+
+#include <miutset.h>
+#include <mtmuids.h>
+#include <MessagingDomainCRKeys.h>
+#include <mcesettingsemailsel.h>
+#include <mtmuids.h>
+#include <MessagingDomainCRKeys.h>
+//CR:422-271
+#include <mmscodecclient.h>
+#include "mmsclient.h"
+#include "mmsconst.h"
+#include "e32cmn.h"
+// CONSTANTS
+
+const TInt KMceArrayGranularity = 4;
+const TUid KMceCBSApplication = {0x101F4CD3};
+const TInt KMceCBSApplicationStartView = 2;
+
+_LIT( KMceDirAndFile,"muiu.mbm" );
+// CONSTANTS
+
+const TInt KMceAnswerToLifeUniverseAndEverything = 42;
+const TInt KMceMaxFolderLength = 35;
+const TInt KMceTextLength = 120;
+ // Estimate disk value for move or copy
+const TInt KMceDiskSpaceForMoveOrCopy = 65536;
+const TInt KMceMaxDateString(12); // _mm/dd/yyyy_
+const TInt KMceOneMMSNotificationFailed = 1;
+
+_LIT8 ( KMceMMSNotifOne8, "1" ); // 8 bit one
+
+#define KMessagingCentreMainViewUid TVwsViewId( \
+ TUid::Uid( KMceApplicationUidValue ), \
+ TUid::Uid( KMceMainViewListViewIdValue ) )
+
+#ifdef _DEBUG
+_LIT( KPanicText, "Mce" );
+const TInt KCRepositorySettingFailure = 1;
+#endif
+
+const TInt KMceProgressReporterThreshold = 10;
+
+const TUid KMailTechnologyTypeUid = { 0x10001671 };
+
+//cmail update
+#define KUidMsgTypeFsMtmVal 0x2001F406
+//CR:422-271
+_LIT( KMmsMessageDumpDirectory, "C:\\Private\\1000484b\\mmsvar");
+_LIT( KRootPath, "C:\\" );
+const TInt KMmsCodecClientChunkSize = 1024;
+
+// LOCAL FUNCTION PROTOTYPES
+
+// ==================== LOCAL FUNCTIONS ====================
+//
+
+GLDEF_C void Panic(TMceUiPanic aPanic)
+ // Panic function
+ {
+ User::Panic(_L("Mce"), aPanic);
+ }
+
+
+// ================= MEMBER FUNCTIONS =======================
+
+
+CMceUi::CMceUi()
+ :CAknViewAppUi(),
+ iMsgTypesWritePopup( KMceArrayGranularity ),
+ iMsgTypesWriteSubmenu( KMceArrayGranularity ),
+ iMsgTypesSettings( KMceArrayGranularity ),
+ iOperations( KMsvSingleOpWatcherArrayGranularity ),
+ iMceIAUpdate( NULL ),
+ iMoveOrCopyMailOperation(-1),
+ iHandleNewMsgToInbox ( EFalse ),
+ iAnchorId( NULL ),
+ iEmailClientIntegration(EFalse),
+ iSelectableEmail(EFalse),
+ iEmailFramework(EFalse)
+ {
+ iMceUiFlags.SetMceFlag( EMceUiFlagsExitOnMsvMediaAvailableEvent );
+ }
+
+CMceUi::~CMceUi()
+ {
+ MCELOGGER_ENTERFN("~CMceUi()");
+ iCoeEnv->RemoveForegroundObserver( *this ); // CR : 401-1806
+ delete iBitmapResolver;
+ if(iMtmLoader)
+ {
+ iMtmLoader->Cancel();
+ delete iMtmLoader;
+ }
+
+#ifdef _DEBUG
+ MCELOGGER_WRITE_FORMAT("iOperations.Count = %d", iOperations.Count() );
+ const TInt count = iOperations.Count();
+ for ( TInt loop = 0; loop < count; loop++ )
+ {
+ MCELOGGER_WRITE_FORMAT("loop = %d", loop );
+ MCELOGGER_WRITE_FORMAT("operation id = %d", iOperations[loop]->Operation().Id() );
+ }
+#endif
+ iOperations.ResetAndDestroy();
+ delete iMTMFunctionsArray;
+ delete iUiRegistry;
+ delete iEntry;
+ delete iRootEntry;
+ delete iMtmStore;
+ delete iConnectMailboxTimer;
+ if ( iSessionHolder )
+ {
+ // must not delete sessionholder, it will kill itself...
+ iSessionHolder->RemoveClient();
+ // must not delete iSession, session holder takes care of that
+ }
+ delete iMceLogEngine;
+ delete iMessageIterator;
+ delete iFolderIndicator;
+ delete iTabsArray;
+ delete iMMSNotifications;
+ delete iDecoratedTabGroup;
+ delete iMceErrorUi;
+ delete iLocalScreenClearer;
+ // iSession and iMceDeliveryView owned by iSessionHolder
+ // don't delete iMessageTypesDlg, dialog will delete itself.
+ delete iMailAccountItemArray;
+ // MMS.Content.Upload
+ iUploadServices.ResetAndDestroy();
+ delete iEmailApi;
+ delete iEmailNotifHandler;
+ delete iCancelExitFlagOperation;
+ delete iMceIAUpdate;
+
+ if ( iIdArray )
+ {
+ delete iIdArray;
+ iIdArray = NULL;
+ }
+ // close connection monitor
+ if ( iAlwaysOnline )
+ {
+ iConnectionMonitor.Close();
+ }
+
+ // delete KPSUidMuiu property
+ RProperty::Delete( KPSUidMuiu, KMuiuKeyCurrentMsg );
+ if ( iFeatureMgrEnabled ) // CR : 401-1806
+ {
+ FeatureManager::UnInitializeLib();
+ iFeatureMgrEnabled = EFalse ; // CR : 401-1806
+ }
+ if(iEncodeBuffer)
+ {
+ delete iEncodeBuffer;
+ }
+ iFs.Close();
+
+ MCELOGGER_LEAVEFN("~CMceUi()");
+ MCELOGGER_DELETE;
+ }
+
+void CMceUi::ConstructL()
+ {
+ MCELOGGER_CREATE
+ MCELOGGER_ENTERFN("ConstructL()");
+ MCELOGGER_WRITE_TIMESTAMP("Time: ");
+
+ if ( AknLayoutUtils::MSKEnabled() )
+ {
+ BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );
+ }
+ else
+ {
+ BaseConstructL( EAknEnableSkin | EAknSingleClickCompatible );
+ }
+
+ // SIM access profiles
+ CheckSIMAccessProfileL();
+
+ // security data caging
+ TParse fp;
+ fp.Set( KMceDirAndFile, &KDC_APP_BITMAP_DIR , NULL );
+ iFilename = fp.FullName();
+
+ FeatureManager::InitializeLibL();
+ iFeatureMgrEnabled = ETrue ; // CR : 401-1806
+
+ //check if 'Memory in use' -option is enabled in mce settings
+ iMemoryInUse = MceUtils::MemoryInUseOptionL();
+
+ iAlwaysOnline = AlwaysOnlineL();
+
+ iCancelExitFlagOperation = CIdle::NewL( CActive::EPriorityIdle );
+
+ // Are CSP bits supported
+ iCsp = CspBitsL();
+ iSessionHolder = CMceSessionHolder::NewL( *this );
+ iSession = iSessionHolder->Session();
+
+ RFs& fs=iEikonEnv->FsSession();
+ TBool storeChanged = EFalse;
+ TBool storeOnPhoneMemory = ETrue;
+#ifdef RD_MULTIPLE_DRIVE
+ TInt phoneDrive;
+ // At this point, try avoid using any predefined numbers E.G. EDriveC
+ // in order to increase the safety and code flexibility
+ User::LeaveIfError( DriveInfo::GetDefaultDrive( DriveInfo:: EDefaultPhoneMemory, phoneDrive ) );
+ TInt currentDrive = TInt( iSession->CurrentDriveL() );
+ if ( currentDrive != phoneDrive )
+#else
+ if ( TInt(iSession->CurrentDriveL()) == EDriveE )
+#endif //RD_MULTIPLE_DRIVE
+ {
+ storeOnPhoneMemory = EFalse;
+ TBool storeMounted = EFalse;
+ TRAPD( error, storeMounted = (*iSession).MessageStoreDrivePresentL( ) );
+ TBool driveContainsStore = EFalse;
+#ifdef RD_MULTIPLE_DRIVE
+ TRAPD( error2, driveContainsStore = iSession->DriveContainsStoreL( currentDrive ) );
+#else
+ TRAPD( error2, driveContainsStore = iSession->DriveContainsStoreL( EDriveE ) );
+#endif // RD_MULTIPLE_DRIVE
+ if ( error || !storeMounted || error2 || !driveContainsStore )
+ {
+ //change the message store to phone
+ storeChanged = ETrue;
+
+ //Change message store to phones internal memory(EDriveC)
+ MsvUiServiceUtilitiesInternal::ChangeMessageStoreToPhoneL( *iSession );
+ iMceUiFlags.ClearMceFlag( EMceUiFlagsExitOnMsvMediaAvailableEvent );
+ }
+ }
+
+ iMTMFunctionsArray=new (ELeave) CMsgFuncArray( KMceArrayGranularity );
+
+ iBitmapResolver = CMceBitmapResolver::NewL( iSession, *this, ETrue );
+
+ CMceMainViewListView* mainView = CMceMainViewListView::NewL(
+ iSession,
+ *iSessionHolder,
+ *iBitmapResolver );
+ CleanupStack::PushL( mainView );
+ AddViewL(mainView); // transfer ownership to CAknAppUi
+ CleanupStack::Pop( mainView );
+ iMceMainView = mainView;
+ SetDefaultViewL( *iMceMainView );
+ SetMceViewActive( EMceMainViewActive );
+
+ iMceLogEngine = CMceLogEngine::NewL();
+
+ CEikStatusPane* sp = StatusPane();
+ iNaviPane = (CAknNavigationControlContainer *)sp->ControlL(TUid::Uid(EEikStatusPaneUidNavi));
+
+ // iMessageIterator created when opening the message
+
+ // Create IMAP folder indicator
+
+ CMceNaviPaneFolderIndicator* folder =
+ CMceNaviPaneFolderIndicator::NewL( storeOnPhoneMemory, 0 );
+
+ CAknNavigationDecorator* tmp = CAknNavigationDecorator::NewL(
+ iNaviPane, folder, CAknNavigationDecorator::ENotSpecified );
+
+ CleanupStack::PushL( tmp );
+ tmp->SetContainerWindowL( *iNaviPane );
+ CleanupStack::Pop( tmp );
+ tmp->MakeScrollButtonVisible( EFalse );
+ iFolderIndicator = tmp;
+
+ iMailAccountItemArray = new(ELeave) CMceMailAccountItemArray(
+ KMceArrayGranularity );
+
+ iMceIAUpdate = CMceIAUpdateUtils::NewL();
+
+ if ( iAlwaysOnline )
+ {
+ iConnectionMonitor.ConnectL();
+ iConnectionMonitor.NotifyEventL( *this );
+ }
+
+ iMceUiFlags.SetMceFlag( EMceUiFlagsFinishedConstruction );
+
+ if ( storeChanged )
+ {
+ // message store switching ate EMsvServerReady so do it once again,
+ // when all has been constructed
+ storeChanged = EFalse;
+ HandleSessionEventL( MMsvSessionObserver::EMsvServerReady, NULL, NULL, NULL );
+ }
+
+ // Contents of uploadservices
+ if ( FeatureManager::FeatureSupported(KFeatureIdSenduiMmsUpload) )
+ {
+ CSendUi* sendui = CSendUi::NewLC( );
+ sendui->AvailableServicesL( iUploadServices, KMmsDirectUpload );
+ sendui->AvailableServicesL( iUploadServices, KMmsIndirectUpload );
+ CleanupStack::PopAndDestroy( sendui );
+ }
+
+ iAudioMsgEnabled = EFalse ; // CR : 401-1806
+ iPostcardEnabled = EFalse ; // CR : 401-1806
+ if ( FeatureManager::FeatureSupported( KFeatureIdEmailMceIntegration ) )
+ {
+ iEmailClientIntegration = ETrue;
+ }
+ if ( FeatureManager::FeatureSupported( KFeatureIdSelectableEmail ) )
+ {
+ iSelectableEmail = ETrue;
+ }
+ if ( FeatureManager::FeatureSupported( KFeatureIdFfEmailFramework ) )
+ {
+ iEmailFramework = ETrue;
+ }
+ iMsgDeletedStatus = EFalse;
+ iServerStarted = EFalse ;
+
+ // Handling of NCN reset
+ TRAPD( err, iEmailNotifHandler = CMceEmailNotifHandler::NewL() );
+ MCELOGGER_WRITE_FORMAT("ConstructL iEmailNotifHandler err %d", err);
+ if ( err )
+ {
+ iEmailNotifHandler = NULL;
+ }
+
+ ZoomLevelChangedL( ReadZoomLevelL() );
+
+ iEmailApi = CreateEmailApiL( iSession );
+
+ SetDiskSpaceForMoveOrCopyL();
+ //CR:422-271
+ //initializing the encodebuffer for MMS templates
+ iEncodeBuffer = CBufFlat::NewL( 1 );//To remove hardcoding
+ User::LeaveIfError( iFs.Connect() );
+ iFs.SetSessionPath( KRootPath );
+
+ MCELOGGER_LEAVEFN("ConstructL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::HandleSessionEventL
+// ----------------------------------------------------
+void CMceUi::HandleSessionEventL(
+ TMsvSessionEvent aEvent,
+ TAny* aArg1,
+ TAny* aArg2,
+ TAny* /*aArg3*/ )
+ {
+ MCELOGGER_WRITE_TIMESTAMP("CMceUi::HandleSessionEventL() start");
+ MCELOGGER_WRITE_FORMAT("aEvent=%d", aEvent);
+
+ if ( !iMceUiFlags.MceFlag( EMceUiFlagsFinishedConstruction ) )
+ {
+ return;
+ }
+
+ TMsvId folderId = KMsvNullIndexEntryId;
+
+ // ConstructL must have left as we have returned to the active scheduler
+ // before complete construction
+ TInt err;
+ switch (aEvent)
+ {
+ case EMsvServerReady:
+ case EMsvCorruptedIndexRebuilt:
+ iMceUiFlags.ClearMceFlag( EMceUiFlagsMediaUnavailable );
+ TRAP(err, HandleServerStartupL());
+ if (err!=KErrNone)
+ {
+ // close...
+ MCELOGGER_WRITE_FORMAT("HandleServerStartupL: %d", err);
+ iMceUiFlags.SetMceFlag( EMceUiFlagsWantToExit );
+ iCoeEnv->HandleError( err );
+ Exit();
+ }
+ // Messaging application is started to background in bootup.
+ // However messaging main view is not activated in background startup.
+ // Because of that startup of messaging application after background startup is not as fast as other startups.
+ // This can be optimized by activating main view same way than when messaging application is hide to background.
+ if ( !IsForeground() )
+ {
+ HideOrExit();
+ }
+ break;
+ case EMsvMediaChanged:
+ case EMsvMtmGroupInstalled:
+ case EMsvMtmGroupDeInstalled:
+ iMceUiFlags.ClearMceFlag( EMceUiFlagsMediaUnavailable );
+ HandleMTMChangeL();
+ break;
+ case EMsvEntriesCreated:
+ case EMsvEntriesDeleted:
+ iMceUiFlags.ClearMceFlag( EMceUiFlagsMediaUnavailable );
+ folderId = (*(TMsvId*) (aArg2));
+ if ( folderId == KMsvRootIndexEntryId )
+ {
+ if ( IsPresent( KSenduiMtmSyncMLEmailUid ) )
+ {
+ // check if syncml item should be added/removed
+ // in new message dialog
+ SyncMlNewMessageItemL( (CMsvEntrySelection*) aArg1, aEvent );
+ }
+ // something changed in root i.e. mailbox created or deleted...
+ RemoveTabsAndUpdateArray();
+ }
+ // fall through
+ case EMsvEntriesChanged:
+ folderId = (*(TMsvId*) (aArg2));
+ if ( folderId == KMsvRootIndexEntryId && iMceUiFlags.MceFlag( EMceUiFlagsTabsActive ) )
+ {
+ CMsvEntrySelection* selection = (CMsvEntrySelection*) aArg1; // do not take ownership
+ const TInt count = selection->Count();
+ TInt selectedIndex = KErrNotFound;
+ for ( TInt loop = 0; loop < count && selectedIndex == KErrNotFound; loop++ )
+ {
+ selectedIndex = iTabsArray->Find( selection->At( loop ) );
+ }
+
+ if ( selectedIndex != KErrNotFound )
+ {
+ CheckRemoteMailboxTabIconsL();
+ }
+ }
+ // list update done by active view so do nothing here
+ break;
+ case EMsvServerFailedToStart:
+ case EMsvServerTerminated:
+ case EMsvCloseSession:
+ iMceUiFlags.SetMceFlag( EMceUiFlagsWantToExit );
+ iAvkonViewAppUi->ProcessCommandL( EAknCmdExit );
+ break;
+ case EMsvGeneralError:
+ {
+ const TInt leave=*STATIC_CAST(TInt*,aArg1);
+ if (iMceUiFlags.MceFlag( EMceUiFlagsWantToExit ) && leave==KLeaveExit)
+ {
+ User::Leave(leave);
+ }
+ break;
+ }
+ case EMsvMediaUnavailable:
+ iMceUiFlags.SetMceFlag( EMceUiFlagsMediaUnavailable );
+ if ( iMceUiFlags.MceFlag( EMceUiFlagsExitOnMsvMediaAvailableEvent ) )
+ {
+ MCELOGGER_WRITE("CMceUi::HandleSessionEventL() EMsvMediaUnavailable EXIT");
+ iMceUiFlags.SetMceFlag( EMceUiFlagsWantToExit );
+ iAvkonViewAppUi->ProcessCommandL( EAknCmdExit );
+ }
+ else
+ {
+ MCELOGGER_WRITE("CMceUi::HandleSessionEventL() EMsvMediaUnavailable Clear flag!");
+ iMceUiFlags.ClearMceFlag( EMceUiFlagsExitOnMsvMediaAvailableEvent );
+ }
+ break;
+ case EMsvMediaAvailable:
+ {
+ iMceUiFlags.ClearMceFlag( EMceUiFlagsMediaUnavailable );
+ iMceUiFlags.SetMceFlag( EMceUiFlagsExitOnMsvMediaAvailableEvent );
+ // update folders tab
+ CMceNaviPaneFolderIndicator* findicator =
+ static_cast<CMceNaviPaneFolderIndicator*>( iFolderIndicator->DecoratedControl() );
+ findicator->ChangeRootL( TInt(iSession->CurrentDriveL() == EDriveC) );
+ }
+ // fall through
+ default:
+ break;
+ }
+ MCELOGGER_WRITE_TIMESTAMP("CMceUi::HandleSessionEventL() end");
+ }
+
+// ----------------------------------------------------
+// CMceUi::HandleServerStartupL
+// ----------------------------------------------------
+void CMceUi::HandleServerStartupL()
+ {
+ iServerStarted = EFalse ;
+ LoadContextIconL();
+
+ if ( iMceUiFlags.MceFlag( EMceUiFlagsServerReady ) )
+ {
+ MCELOGGER_LEAVEFN("HandleServerStartupL(), server ready");
+
+ if ( iMemoryInUse )
+ {
+ // when iSession->ChangeDriveL is called, also HandleSessionEvent is called
+ // using EMsvServerReady
+
+ if(iMtmLoader)
+ {
+ iMtmLoader->Cancel();
+ delete iMtmLoader;
+ iMtmLoader = NULL;
+ }
+
+ delete iUiRegistry;
+ iUiRegistry=NULL;
+
+ delete iEntry;
+ iEntry = NULL;
+ iEntry=iSession->GetEntryL(KMsvRootIndexEntryId);
+
+ delete iRootEntry;
+ iRootEntry = NULL;
+ iRootEntry=CMsvEntry::NewL(
+ *iSession,
+ KMsvRootIndexEntryId,
+ TMsvSelectionOrdering(KMsvNoGrouping, EMsvSortByNone, ETrue));
+
+ delete iMtmStore;
+ iMtmStore=NULL;
+
+ iMtmStore=CMtmStore::NewL(*iSession);
+ iUiRegistry=CMtmUiDataRegistry::NewL(*iSession);
+
+ iRootEntry->SetEntryL(KMsvRootIndexEntryIdValue);
+
+ // reconstruct main view
+ iMceMainView->ConstructMainViewL();
+
+ // reconstruct tabs
+ TBool tabsActive = iMceUiFlags.MceFlag( EMceUiFlagsTabsActive );
+ RemoveTabs();
+ delete iDecoratedTabGroup;
+ iDecoratedTabGroup = NULL;
+ delete iTabsArray;
+ iTabsArray = NULL;
+
+ if ( MceViewActive( EMceMessageViewActive )
+ && tabsActive
+ && ( !iMceListView->IsImapFolderOpenL( ) ) )
+ {
+ const TMceListItem& tempItem = iMceMainView
+ ->ListContainer()->CurrentItemListItem();
+ TMsvId service;
+ TMsvEntry child;
+ User::LeaveIfError( iSession->GetEntry( tempItem.iMsvId, service, child ) );
+ ShowTabsL( child.Id() );
+ }
+
+ // update folders tab
+ CMceNaviPaneFolderIndicator* findicator =
+ static_cast<CMceNaviPaneFolderIndicator*>( iFolderIndicator->DecoratedControl() );
+ findicator->ChangeRootL( TInt(iSession->CurrentDriveL()) );
+
+ iMceMainView->ListContainer()->DrawNow();
+ }
+ iServerStarted = ETrue ;
+ return;
+ }
+
+ iEntry=iSession->GetEntryL(KMsvRootIndexEntryId);
+ iRootEntry=CMsvEntry::NewL(
+ *iSession,
+ KMsvRootIndexEntryId,
+ TMsvSelectionOrdering(KMsvNoGrouping, EMsvSortByNone, ETrue));
+ iMtmStore=CMtmStore::NewL(*iSession);
+
+ iUiRegistry=CMtmUiDataRegistry::NewL(*iSession);
+
+ CMceMessageListView* mceListView = CMceMessageListView::NewL(
+ iSession,
+ KMsvLocalServiceIndexEntryId,
+ *iSessionHolder,
+ *iBitmapResolver,
+ *iMceMainView );
+ CleanupStack::PushL( mceListView );
+ AddViewL( mceListView ); // transfer ownership to CAknAppUi
+ CleanupStack::Pop( mceListView );
+ iMceListView = mceListView;
+
+
+ // should be called after creation of iUiRegistry
+ iMceMainView->HandleMsgServerStartupL();
+
+ iAudioMsgEnabled = FeatureManager::FeatureSupported( KFeatureIdAudioMessaging ); // CR : 401-1806
+ iPostcardEnabled = FeatureManager::FeatureSupported( KFeatureIdMmsPostcard ) ; // CR : 401-1806
+
+ HandleMTMChangeL();
+
+/* CMceMessageListView* mceListView = CMceMessageListView::NewL(
+ iSession,
+ KMsvLocalServiceIndexEntryId,
+ *iSessionHolder,
+ *iBitmapResolver,
+ *iMceMainView );
+ CleanupStack::PushL( mceListView );
+ AddViewL(mceListView); // transfer ownership to CAknAppUi
+ CleanupStack::Pop(); // mceListView
+ iMceListView = mceListView;*/
+ iMceListView->HandleMsgServerStartupL();
+
+ CMceDeliveryReportView* view3 = CMceDeliveryReportView::NewL( *iSessionHolder );
+ CleanupStack::PushL( view3 );
+ AddViewL( view3 ); // transfer ownership to CAknAppUi
+ CleanupStack::Pop( view3 );
+
+ iMceDeliveryView = view3;
+
+ iMceMainView->ListContainer()->ListItems()->SetAlwaysOnline( iAlwaysOnline );
+
+ if ( iAlwaysOnline )
+ {
+ TRequestStatus status;
+ TInt registrationStatus( 0 );
+
+ //check network status
+ iConnectionMonitor.GetIntAttribute(
+ EBearerIdGSM, 0, KNetworkRegistration,
+ registrationStatus, status );
+
+ User::WaitForRequest( status );
+
+ if ( status.Int() == KErrNone )
+ {
+ iMceMainView->ListContainer()->ListItems()->SetRoaming(
+ registrationStatus == ENetworkRegistrationRoaming );
+ }
+ }
+
+ iMceUiFlags.ClearMceFlag( EMceUiFlagsWantToExit );
+ iMceUiFlags.SetMceFlag( EMceUiFlagsServerReady );
+
+ ToPhoneMemoryQueryL( iMceUiFlags.MceFlag( EMceUiFlagsMainViewActivated ) );
+
+ iCoeEnv->AddForegroundObserverL( *this ); // CR : 401-1806
+ //populate MMS templates in inbox which are preloaded KMmsMessageDumpDirectory.
+ //CR:422-271
+ PopulateMMSTemplates();
+
+ iServerStarted = ETrue ;
+ MCELOGGER_LEAVEFN("HandleServerStartupL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::Session
+// ----------------------------------------------------
+CMsvSession& CMceUi::Session()
+ {
+ return *iSession;
+ }
+
+// ----------------------------------------------------
+// CMceUi::HandleCommandL
+// ----------------------------------------------------
+void CMceUi::HandleCommandL( TInt aCommand )
+ {
+ MCELOGGER_WRITE_FORMAT("HandleCommandL: aCommand: %d", aCommand);
+
+ if ( iMceUiFlags.MceFlag( EMceUiFlagsMediaUnavailable )
+ && aCommand != EEikCmdExit
+ && aCommand != EMceCmdExit
+ && aCommand != EAknSoftkeyBack)
+ {
+ MCELOGGER_WRITE("HandleCommandL: media unavailable, leave");
+ User::Leave( KMsvIndexBackup );
+ }
+
+ switch (aCommand)
+ {
+ case EEikCmdExit:
+ Exit();
+ break;
+ case EMceCmdExit:
+ CloseConnectionsBeforeExitL();
+ if ( iMceUiFlags.MceFlag( EMceUiFlagsWantToExit ) )
+ {
+ HideOrExit();
+ }
+ break;
+ case EAknCmdHideInBackground:
+ HideOrExit();
+ break;
+ case EMceCmdNewFolder:
+ CreateNewFolderL( );
+ break;
+ case EMceCmdRenameFolder:
+ RenameFolderL();
+ break;
+ case EMceCmdSettings:
+ SettingsDialogL();
+ break;
+ case EMceCmdDelete:
+ HandleDeleteL();
+ break;
+ case EMceCmdUndelete:
+ HandleUndeleteL();
+ break;
+ case EMceCmdCopy:
+ MoveOrCopyEntriesL( ETrue );
+ break;
+ case EMceCmdMove:
+ MoveOrCopyEntriesL( EFalse );
+ break;
+ case EMceCmdFetchNew:
+ FetchNewL();
+ break;
+ case EMceCmdFetchSelected:
+ FetchSelectedL();
+ break;
+ case EMceCmdFetchAll:
+ FetchAllL();
+ break;
+ case EAknSoftkeyBack:
+ RemoveTabs();
+ ActivateLocalViewL( KMceMainViewListViewId );
+ break;
+ case EMceCmdOutboxStart:
+ SendNowL();
+ break;
+ case EMceCmdOutboxSuspend:
+ CancelSendingL();
+ break;
+ case EMceCmdOutboxMoveToDrafts:
+ {
+ if ( iMceListView->SyncMlOutboxInbox( KMsvGlobalOutBoxIndexEntryId ) )
+ {
+ SyncMlMoveFromOutboxToDraftsL();
+ }
+ else
+ {
+ MoveFromOutboxToDraftsL();
+ }
+ }
+ break;
+ case EMceCmdCBSApplication:
+ LaunchCBSApplicationL();
+ break;
+ case EMceCmdUSSDEditor:
+ LaunchServiceCommandEditorL();
+ break;
+
+ case EAknCmdHelp:
+ LaunchHelpL();
+ break;
+
+ case EAknCmdOpen:
+ case EMceCmdConnect:
+ case EMceCmdCloseConnection:
+ case EAknCmdUnmark:
+ case EAknCmdMark:
+ case EAknMarkAll:
+ case EAknUnmarkAll:
+ // these should be handled by view
+ break;
+
+ case EMceCmdReply:
+ ReplyL(aCommand);
+ break;
+
+ case EMceCmdMarkAsRead:
+ case EMceCmdMarkAsReadMsg:
+ case EMceCmdMarkAsReadMsgs:
+ case EMceCmdMarkAsReadEmails:
+ MarkAsReadL();
+ break;
+
+ case EMceCmdMarkAsUnread:
+ case EMceCmdMarkAsUnreadMsg:
+ case EMceCmdMarkAsUnreadMsgs:
+ case EMceCmdMarkAsUnreadEmails:
+ MarkAsReadL( EFalse );
+ break;
+
+ case EMceCmdMailboxSettings:
+ OpenMailboxSettingsL();
+ break;
+
+ case EMceCmdForward:
+ ForwardL(aCommand);
+ break;
+
+ case EMceCmdZoomValueAutomatic:
+ case EMceCmdZoomValueSmall:
+ case EMceCmdZoomValueMedium:
+ case EMceCmdZoomValueLarge:
+ HandleZoomLevelChangeL( aCommand );
+ break;
+ case EMceCmdLanuchUniEditor:
+ LaunchUniEditorL();
+ break;
+
+ case EMceCmdLaunchEmailEditor:
+ CreateNewMessageL( GetToBeCreatedEmailType () );
+ break;
+
+ default:
+ if ( aCommand >= EMceCmdFirstMTMFunction && aCommand < EMceCmdFirstMTMContextFunction )
+ {
+ const TMsgFunctionInfo* info=&iMTMFunctionsArray->At(aCommand-EMceCmdFirstMTMFunction);
+ HandleMTMFunctionL(*info);
+ }
+ else if ( aCommand > EMceCmdCreateNewCommands && aCommand < EMceCmdFirstMTMFunction )
+ {
+ const TInt messageIndex =
+ aCommand - EMceCmdCreateNewCommands - 1;
+ __ASSERT_ALWAYS( messageIndex < iMsgTypesWriteSubmenu.Count(),
+ Panic( EMceUiErrCreateNewMessageCommand ) );
+ CreateNewMessageL( iMsgTypesWriteSubmenu[messageIndex].iUid.iUid );
+ }
+ break;
+ } // switch
+ MCELOGGER_LEAVEFN("HandleCommandL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::DynInitMenuPaneL
+// ----------------------------------------------------
+void CMceUi::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* aMenuPane )
+ {
+ ForceMtmLoaderFinish();
+ TBool cbs = EFalse;
+ if ( FeatureManager::FeatureSupported( KFeatureIdCellBroadcast ) )
+ {
+ cbs = ETrue;
+ if ( iCsp )
+ {
+ cbs = CheckCspBitL();
+ }
+ }
+ switch ( aResourceId )
+ {
+ case R_MCE_MAIN_VIEW_MENU:
+ {
+ // Run time Cell Broadcast variant.
+ // Enable/disable CBS
+ aMenuPane->SetItemDimmed( EMceCmdCBSApplication, !cbs );
+ // Run time USSD variant.
+ aMenuPane->SetItemDimmed( EMceCmdUSSDEditor,
+ !FeatureManager::FeatureSupported( KFeatureIdUSSD ));
+
+ aMenuPane->SetItemDimmed( EAknCmdHelp,
+ !FeatureManager::FeatureSupported( KFeatureIdHelp ) );
+
+ if ( iMsgTypesWriteSubmenu.Count() == 0 )
+ {
+ aMenuPane->SetItemDimmed( EMceCmdNewMessage, ETrue );
+ }
+ if ( MceViewActive( EMceMainViewActive ) )
+ {
+ AddMTMFunctionsL(*aMenuPane, EMceCmdCloseConnection);
+
+ const CMceMainViewListContainer* listContainer =
+ iMceMainView->ListContainer();
+ const TMceListItem listItem =
+ listContainer->CurrentItemListItem();
+ if ( listItem.iExtraItem )
+ {
+ aMenuPane->SetItemDimmed( EMceCmdConnect, ETrue );
+ }
+ else
+ {
+ const TUid connectCapability =
+ { KUidMsvMtmUiQueryConnectionOrientedServices };
+ TInt rid;
+
+ iEntry->SetEntryL( listItem.iMsvId );
+ TUid uid = iEntry->Entry().iMtm;
+ CBaseMtmUiData* uiData = NULL;
+ if ( uid != KUidMsvLocalServiceMtm )
+ {
+ uiData=GetMtmUiDataL( uid );
+ }
+ if ( uiData && ( uid != KSenduiMtmSyncMLEmailUid )
+ && uiData->QueryCapability( connectCapability, rid )
+ == KErrNone )
+ {
+ // need to check if connected or not
+ if ( iEntry->Entry().Connected() )
+ {
+ aMenuPane->SetItemDimmed( EMceCmdConnect, ETrue );
+ }
+ }
+ else
+ {
+ aMenuPane->SetItemDimmed( EMceCmdConnect, ETrue );
+ }
+ }
+ // if we have at least one connection open then do not delete EMceCmdCloseConnection
+ CMsvEntrySelection* connectedAccounts = ConnectedServicesLC();
+ if ( connectedAccounts->Count() == 0)
+ {
+ aMenuPane->SetItemDimmed( EMceCmdCloseConnection, ETrue );
+ }
+ CleanupStack::PopAndDestroy( connectedAccounts );
+
+ } // if ( MceViewActive( EMceMainViewActive ) )
+ break;
+ }
+ case R_MCE_NEW_MESSAGE_MENU:
+ {
+ CEikMenuPaneItem::SData item;
+ item.iCommandId = EMceCmdCreateNewCommands;
+ item.iFlags = 0;
+ item.iCascadeId = 0;
+ const TInt count = iMsgTypesWriteSubmenu.Count();
+ for(TInt loop = 0; loop < count; loop++)
+ {
+ item.iText = iMsgTypesWriteSubmenu[loop].iName;
+ item.iCommandId++;
+ aMenuPane->AddMenuItemL(item);
+ }
+ break;
+ }
+ case R_MCE_FOLDER_MENU:
+ {
+ aMenuPane->SetItemDimmed( EAknCmdHelp,
+ !FeatureManager::FeatureSupported( KFeatureIdHelp ) );
+
+ AddMTMFunctionsL(*aMenuPane, EAknCmdOpen);
+ }
+ break;
+ case R_MCE_LOCAL_ZOOM_VALUE:
+ {
+ HandleZoomSubMenu( aMenuPane );
+ }
+ break;
+ default:
+ break;
+ }// end switch
+ }
+
+// ----------------------------------------------------
+// CMceUi::SendViaL
+// ----------------------------------------------------
+void CMceUi::SendViaL( TMsvId aId, TUid aMtm )
+ {
+ __ASSERT_DEBUG( aMtm == KSenduiMtmIrUid || aMtm == KSenduiMtmBtUid,
+ Panic(EMceUiErrCanSendViaOnlyBtOrIr) );
+
+ LeaveIfDiskSpaceUnderCriticalLevelL();
+
+ // Get the file name
+ TFileName fileName;
+ TInt fileSize;
+ RFile fileHandle;
+ MceUtils::GetIrFilePathL( *iSession, aId, fileName, fileHandle, fileSize );
+ CleanupClosePushL( fileHandle );
+
+ // Required capabilities for message types
+ TSendingCapabilities capabilities(
+ 0,
+ 0,
+ TSendingCapabilities::ESupportsAttachments );
+
+ // Create the message
+ CMessageData* messageData = CMessageData::NewL();
+ CleanupStack::PushL( messageData );
+ messageData->AppendAttachmentHandleL( fileHandle );
+
+ // Send the message with SendUI
+ CSendUi* sendui = CSendUi::NewLC();
+ sendui->CreateAndSendMessageL( aMtm, messageData, KNullUid, ETrue );
+
+ CleanupStack::PopAndDestroy( 3 ); // sendui, messageData, fileHandle
+ }
+
+// ----------------------------------------------------
+// CMceUi::HandleKeyEventL
+// ----------------------------------------------------
+TKeyResponse CMceUi::HandleKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
+ {
+ if ( iEditorOperation )
+ {
+ MCELOGGER_WRITE_FORMAT("HandleKeyEventL: iEditorOperation set 0x%x so don't do anything", iEditorOperation );
+ return EKeyWasConsumed;
+ }
+
+ if ( iMceUiFlags.MceFlag( EMceUiFlagsTabsActive ) && aType == EEventKey )
+ {
+ CAknTabGroup* tabGroup = NULL;
+ if ( iDecoratedTabGroup )
+ {
+ tabGroup = ( CAknTabGroup* ) iDecoratedTabGroup->DecoratedControl();
+ }
+
+ if ( !tabGroup )
+ {
+ return EKeyWasNotConsumed;
+ }
+
+ return tabGroup->OfferKeyEventL( aKeyEvent, aType );
+ }
+
+ return EKeyWasNotConsumed;
+ }
+
+// ----------------------------------------------------
+// CMceUi::LogEngine
+// ----------------------------------------------------
+CMceLogEngine* CMceUi::LogEngine()
+ {
+ return iMceLogEngine;
+ }
+
+// ----------------------------------------------------
+// CMceUi::LaunchHelpL
+// ----------------------------------------------------
+void CMceUi::LaunchHelpL()
+ {
+ // activate Help application
+ CArrayFix<TCoeHelpContext>* helpContext = AppHelpContextL();
+ HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(), helpContext );
+ }
+
+// ----------------------------------------------------
+// CMceUi::HandleOpenNextPreviousL
+// ----------------------------------------------------
+void CMceUi::HandleOpenNextPreviousL( TBool aOpenNext )
+ {
+ MCELOGGER_ENTERFN("HandleOpenNextPreviousL()");
+ __ASSERT_DEBUG( iMessageIterator, Panic(EMceUiMessageIteratorNotCreated));
+
+ if ( iMessageIterator )
+ {
+ TInt error = (aOpenNext ?
+ iMessageIterator->SetNextMessage() : iMessageIterator->SetPreviousMessage() );
+ if ( error == KErrNone )
+ {
+ TBool local = iMceListView->ListContainer()->FolderEntry().iServiceId == KMsvLocalServiceIndexEntryId;
+ if ( local && !iLocalScreenClearer )
+ {
+ iLocalScreenClearer = CAknLocalScreenClearer::NewL( ETrue );
+ }
+
+ // TODO
+ CMceMessageListContainerBase* container = iMceListView->ListContainer();
+ TMsvId currentItemId = iMessageIterator->CurrentMessage().Id();
+ if ( container )
+ {
+ container->SetCurrentItemIdL( currentItemId );
+ container->DrawNow();
+/*
+ TInt currentItemIndex = container->ItemIndex( currentItemId );
+ if ( currentItemIndex != KErrNotFound )
+ {
+ container->ListBox()->SetCurrentItemIndex( currentItemIndex );
+ container->ListBox()->DrawDeferred();
+ }*/
+ }
+
+ TMsvEntry currentEntry;
+ TMsvId serviceId; // not used here but needed by GetEntry function
+ if ( iSession->GetEntry( currentItemId, serviceId, currentEntry ) == KErrNone &&
+ currentEntry.iType == KUidMsvMessageEntry )
+ {
+ TRAPD( err, EditMTMEntryL( currentEntry ) );
+ if ( err )
+ {
+ if ( iLocalScreenClearer )
+ {
+ delete iLocalScreenClearer;
+ iLocalScreenClearer = NULL;
+ }
+ User::Leave( err );
+ }
+ }
+ } // end if ( container )
+ } // end if ( error == KErrNone )
+ MCELOGGER_LEAVEFN("HandleOpenNextPreviousL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::LaunchCBSApplicationL
+// ----------------------------------------------------
+void CMceUi::LaunchCBSApplicationL()
+ {
+ TVwsViewId id;
+ id.iAppUid = KMceCBSApplication;
+ id.iViewUid.iUid = KMceCBSApplicationStartView;
+ ActivateViewL( id );
+ }
+
+// ----------------------------------------------------
+// CMceUi::LaunchServiceCommandEditorL
+// ----------------------------------------------------
+void CMceUi::LaunchServiceCommandEditorL() const
+ {
+ CPhCltUssd* ussdClient = CPhCltUssd::NewL( EFalse );
+ CleanupStack::PushL( ussdClient );
+ ussdClient->StartUssdEditor();
+ CleanupStack::PopAndDestroy( ussdClient );
+ }
+
+// ----------------------------------------------------
+// CMceUi::HandleResourceChangeL
+// ----------------------------------------------------
+void CMceUi::HandleResourceChangeL( TInt aType )
+ {
+ if ( !iServerStarted )
+ {
+ return ;
+ }
+
+ CAknViewAppUi::HandleResourceChangeL( aType );
+ if( aType == KEikDynamicLayoutVariantSwitch )
+ {
+ if ( iLocalScreenClearer )
+ {
+ delete iLocalScreenClearer;
+ iLocalScreenClearer = NULL;
+ iLocalScreenClearer = CAknLocalScreenClearer::NewL( ETrue );
+ }
+
+ if ( MceViewActive( EMceDeliveryReportsViewActive ) )
+ {
+ iMceDeliveryView->HandleClientRectChange();
+ }
+ iMceMainView->HandleClientRectChange();
+
+ CMceNaviPaneFolderIndicator* findicator =
+ static_cast<CMceNaviPaneFolderIndicator*>( iFolderIndicator->DecoratedControl() );
+ findicator->HandleResourceChange( aType );
+ }
+
+ if( aType == KAknsMessageSkinChange )
+ {
+ const TInt count = iUiRegistry->NumRegisteredMtmDlls();
+ for ( TInt i = 0; i < count; i++ )
+ {
+ iMtmStore->ReleaseMtmUiData( iUiRegistry->MtmTypeUid(i) );
+ }
+
+ iBitmapResolver->ChangeBitmapInIconArrayL();
+ if ( !MceViewActive( EMceMainViewActive ) && iMceMainView )
+ {
+ //update the list icons, when delivery reports view is open and skin changes
+ iMceMainView->ListContainer()->HandleResourceChange( aType );
+ }
+ if ( !MceViewActive(EMceMessageViewActive) && iMceListView
+ && iMceListView->ListContainer() )
+ {
+ iMceListView->ListContainer()->HandleResourceChange( aType );
+ }
+
+ LoadContextIconL();
+ TitlePaneL()->DrawDeferred();
+
+ CMceNaviPaneFolderIndicator* findicator =
+ static_cast<CMceNaviPaneFolderIndicator*>( iFolderIndicator->DecoratedControl() );
+ findicator->HandleResourceChange( aType );
+
+ CAknContextPane* contextPane = (CAknContextPane *)(iEikonEnv->AppUiFactory(*this))
+ ->StatusPane()->ControlL(TUid::Uid(EEikStatusPaneUidContext));
+ contextPane->DrawDeferred();
+ }
+ if (iDecoratedTabGroup)
+ {
+ CAknTabGroup* tab = static_cast<CAknTabGroup*>( iDecoratedTabGroup->DecoratedControl() );
+ if ( tab )
+ {
+ // Inform (possibly off-screen) tab group about the change
+ tab->HandleResourceChange( aType );
+ }
+ }
+
+ iResourceChangeCalled = ETrue;
+ }
+
+// ----------------------------------------------------
+// CMceUi::CloseEditorApp
+// ----------------------------------------------------
+void CMceUi::CloseEditorApp()
+ {
+ if ( iEditorOperation )
+ {
+ TBool foundItem = EFalse;
+ TMsvOp opId = iEditorOperation->Operation().Id();
+
+ for (TInt cc=iOperations.Count()-1; cc>=0 && !foundItem; cc--)
+ {
+ if (iOperations[cc]->Operation().Id()==opId)
+ {
+ delete iOperations[cc];
+ iOperations.Delete(cc);
+ foundItem = ETrue;
+ }
+ }
+ iEditorOperation = NULL;
+
+ delete iLocalScreenClearer;
+ iLocalScreenClearer = NULL;
+ }
+ }
+
+// ----------------------------------------------------
+// CMceUi::LoadContextIconL
+// ----------------------------------------------------
+void CMceUi::LoadContextIconL( )
+ {
+ CEikStatusPane *sp = ( (CAknAppUi*)iEikonEnv->EikAppUi() )->StatusPane();
+ CAknContextPane* contextPane = (CAknContextPane *)sp->ControlL(
+ TUid::Uid(EEikStatusPaneUidContext) );
+
+ RFs& fs=iEikonEnv->FsSession();
+
+ MAknsSkinInstance* skins = AknsUtils::SkinInstance();
+ CFbsBitmap* bitmap;
+ CFbsBitmap* bitmapMask;
+
+#ifdef RD_MULTIPLE_DRIVE
+ TInt phoneDrive;
+ // At this point, try avoid using any predefined numbers E.G. EDriveC
+ // in order to increase the safety and code flexibility
+ User::LeaveIfError( DriveInfo::GetDefaultDrive( DriveInfo:: EDefaultPhoneMemory, phoneDrive ) );
+ if ( TInt( iSession->CurrentDriveL() ) != phoneDrive )
+#else
+ if ( TInt( iSession->CurrentDriveL()) == EDriveE )
+#endif //RD_MULTIPLE_DRIVE
+ {
+#ifndef __SCALABLE_ICONS
+ AknsUtils::CreateIconL( skins, KAknsIIDQgnMenuMceMmcCxt, bitmap,
+ bitmapMask, iFilename, EMbmMuiuQgn_menu_mce_mmc_cxt,
+ EMbmMuiuQgn_menu_mce_mmc_cxt + 1 );
+#else
+ AknsUtils::CreateIconL( skins, KAknsIIDQgnMenuMceMmcCxt, bitmap,
+ bitmapMask, iFilename, EMbmMuiuQgn_menu_mce_mmc,
+ EMbmMuiuQgn_menu_mce_mmc + 1 );
+#endif
+ }
+ else
+ {
+#ifndef __SCALABLE_ICONS
+ AknsUtils::CreateIconL( skins, KAknsIIDQgnMenuMceCxt, bitmap,
+ bitmapMask, iFilename, EMbmMuiuQgn_menu_mce_cxt,
+ EMbmMuiuQgn_menu_mce_cxt + 1 );
+#else
+ AknsUtils::CreateAppIconLC( skins, KMceApplicationUid,
+ EAknsAppIconTypeContext, bitmap, bitmapMask );
+ CleanupStack::Pop( 2 ); // Both bitmaps are left in the cleanup stack
+#endif
+ }
+ contextPane->SetPicture( bitmap, bitmapMask );
+ }
+
+// ----------------------------------------------------
+// CMceUi::ResourceChangeCalled
+// ----------------------------------------------------
+TBool CMceUi::ResourceChangeCalled()
+ {
+ return iResourceChangeCalled;
+ }
+
+// ----------------------------------------------------
+// CMceUi::ResetResourceChange
+// ----------------------------------------------------
+void CMceUi::ResetResourceChange()
+ {
+ iResourceChangeCalled = EFalse;
+ }
+
+// ----------------------------------------------------
+// CMceUi::CheckTechnologyTypeFromMtm
+// ----------------------------------------------------
+TBool CMceUi::CheckTechnologyTypeFromMtm( const TUid aTechnologyType, TUid aMtmType )
+ {
+ TBool isMailMtm = EFalse;
+ if ( aMtmType.iUid != 0 && aMtmType != KUidMsvLocalServiceMtm &&
+ iUiRegistry->IsPresent( aMtmType ) )
+ {
+ // get MTM technology type
+ TUid technologyType = iUiRegistry->TechnologyTypeUid( aMtmType );
+ isMailMtm = ( aTechnologyType == technologyType );
+ }
+ return isMailMtm;
+ }
+
+
+
+
+
+// ----------------------------------------------------
+// CMceUi::HandleMTMChangeL
+// ----------------------------------------------------
+void CMceUi::HandleMTMChangeL()
+ {
+ MCELOGGER_ENTERFN("HandleMTMChangeL()");
+ if( !iMtmLoader )
+ {
+ iMtmLoader = new(ELeave) CMceIdleMtmLoader(
+ *iMtmStore,
+ iMsgTypesWritePopup,
+ iMsgTypesWriteSubmenu,
+ iMsgTypesSettings,
+ *iMTMFunctionsArray,
+ *iUiRegistry );
+ }
+ else
+ {
+ iMtmLoader->Cancel();
+ }
+
+ iMtmLoader->StartL(*iSession, iAudioMsgEnabled, iPostcardEnabled); // CR : 401-1806
+ MCELOGGER_LEAVEFN("HandleMTMChangeL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::GetMtmUiDataL
+// will return NULL if no uiData found for entryType
+// ----------------------------------------------------
+CBaseMtmUiData* CMceUi::GetMtmUiDataL(TUid aMtm)
+ {
+ MCELOGGER_ENTERFN("GetMtmUiDataL()");
+ MCELOGGER_WRITE_FORMAT("GetMtmUiDataL: mtm = 0x%x", aMtm.iUid );
+
+ CBaseMtmUiData* uiData=NULL;
+ if (iMtmStore)
+ {
+ TRAPD(error, ( uiData=&(iMtmStore->MtmUiDataL(aMtm)) ) );
+ MCELOGGER_WRITE_FORMAT("GetMtmUiDataL: error = %d", error );
+ if ( iMceUiFlags.MceFlag( EMceUiFlagsServerReady ) && error != KErrNotFound )
+ {
+ // KErrNotFound cover case where MTM is not installed but messages exist
+ User::LeaveIfError( error );
+ }
+ }
+ MCELOGGER_LEAVEFN("GetMtmUiDataL()");
+ return uiData;
+ }
+
+// ----------------------------------------------------
+// CMceUi::CanCreateNewAccountL
+// ----------------------------------------------------
+TBool CMceUi::CanCreateNewAccountL(TUid aMtm)
+ {
+ TBool canCreateNewAccount = EFalse;
+ TMsvEntry serviceEntry;
+ serviceEntry.iType=KUidMsvServiceEntry;
+ serviceEntry.iMtm=aMtm;
+
+ TInt rid;
+ CBaseMtmUiData* uiData=GetMtmUiDataL(aMtm);
+ if ( uiData && uiData->CanCreateEntryL( iRootEntry->Entry(), serviceEntry, rid ) )
+ {
+ canCreateNewAccount = ETrue;
+ }
+ return canCreateNewAccount;
+ }
+
+// ----------------------------------------------------
+// CMceUi::DeleteAccountL
+// ----------------------------------------------------
+void CMceUi::DeleteAccountL(TMsvId aId)
+ {
+ TMsvEntry entry;
+ GetEntryL( aId, entry );
+ const TUid mtm = entry.iMtm;
+ CBaseMtmUi* ui = &iMtmStore->ClaimMtmUiL( mtm );
+ if (ui)
+ {
+ CMtmStoreMtmReleaser::CleanupReleaseMtmUiLC(*iMtmStore, mtm);
+ }
+
+ CMsvOperation* op = NULL;
+ __ASSERT_DEBUG( !iDeleteOperation,
+ Panic( EMceUiErrAlreadyDeletingAccount ) );
+
+// Free disk space request for delete to be added
+
+ CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( singleOpWatcher );
+
+ if (ui)
+ {
+ ui->BaseMtm().SetCurrentEntryL(iSession->GetEntryL(KMsvRootIndexEntryId));
+ CAknInputBlock::NewLC();
+ op=ui->DeleteServiceL(entry, singleOpWatcher->iStatus);
+ CleanupStack::PopAndDestroy(); // CAknInputBlock
+ CleanupStack::PushL(op);
+ }
+ else
+ {
+ // could not load mtm, so delete as normal local entry
+ iEntry->SetEntryL( KMsvRootIndexEntryId );
+
+ CMsvProgressReporterOperation* progOp =
+ CMsvProgressReporterOperation::NewL(
+ *iSession, singleOpWatcher->iStatus, EMbmAvkonQgn_note_erased);
+ CleanupStack::PushL( progOp );
+
+ CMsvEntrySelection* selection = new( ELeave ) CMsvEntrySelection();
+ CleanupStack::PushL( selection );
+ selection->AppendL( entry.Id() );
+ CMsvOperation* subOp = iEntry->DeleteL( *selection, progOp->RequestStatus());
+ CleanupStack::PopAndDestroy( selection );
+ progOp->SetOperationL( subOp ); // this takes ownership immediately, so no cleanupstack needed.
+ op = progOp;
+ }
+
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2 ); // singleOpWatcher, op
+ singleOpWatcher->SetOperation( op );
+ iDeleteOperation = singleOpWatcher;
+ iMailboxDeleteOperation = op->Id();
+ MCELOGGER_WRITE_FORMAT("free disk requested, iDeleteOperation set 0x%x", iDeleteOperation );
+ MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
+
+// Cancel the free disk space request to be added
+
+ if ( ui )
+ {
+ CleanupStack::PopAndDestroy();// release mtmUi
+ }
+
+ }
+
+// ----------------------------------------------------
+// CMceUi::SettingsDialogL
+// ----------------------------------------------------
+void CMceUi::SettingsDialogL()
+ {
+ CMceUidNameArray* tempArray = CMceUidNameArray::NewL();
+
+ if (( iSelectableEmail )&& (!iEmailFramework))
+ {
+ CleanupStack::PushL( tempArray );
+ const TInt count = iMsgTypesSettings.Count();
+
+ // get all email accounts (visible)
+ CArrayFix<TUid>* listItemUids =
+ new ( ELeave ) CArrayFixFlat<TUid>( KMceArrayGranularity );
+ CleanupStack::PushL(listItemUids);
+ CMsvEntry* entry = iSession->GetEntryL( KMsvRootIndexEntryId );
+ CleanupStack::PushL( entry );
+
+ TInt canCreateNew;
+
+ TInt cnt = entry->Count();
+ if ( cnt != 0 )
+ {
+ entry->SetSortTypeL( TMsvSelectionOrdering(
+ KMsvGroupByType | KMsvGroupByStandardFolders, EMsvSortByDetailsReverse, ETrue ) );
+
+ // Add default item first
+ for ( TInt cc = entry->Count(); --cc >= 0; )
+ {
+ TMsvEntry tentry = (*entry)[cc];
+
+ if ( tentry.iType.iUid == KUidMsvServiceEntryValue &&
+ tentry.Id() != KMsvLocalServiceIndexEntryIdValue )
+ {
+ const TBool noRelatedId = tentry.iRelatedId == KMsvNullIndexEntryId || tentry.iRelatedId == tentry.Id();
+
+ TBool appendEmail = EFalse;
+
+ if( tentry.Visible() )
+ {
+ appendEmail = ETrue;
+ }
+ else
+ {
+ CMtmUiDataRegistry* uiRegistry = CMtmUiDataRegistry::NewL( *iSession );
+ CleanupStack::PushL(uiRegistry);
+ if ( uiRegistry->IsPresent( tentry.iMtm ) &&
+ uiRegistry->IsPresent( KUidMsgTypePOP3 ) )
+ {
+ TUid mailMTMTechType = uiRegistry->TechnologyTypeUid( KUidMsgTypePOP3 );
+ if( uiRegistry->TechnologyTypeUid( tentry.iMtm ) ==
+ mailMTMTechType )
+ {
+ appendEmail = ETrue;
+ }
+ }
+ CleanupStack::PopAndDestroy( uiRegistry );
+ }
+
+ if ( appendEmail )
+ {
+ TBool append = ETrue;
+ // query capability (new message)
+ TUid entryUid;
+
+ if ( tentry.iMtm == KSenduiMtmPop3Uid ||
+ tentry.iMtm == KSenduiMtmImap4Uid)
+ {
+ entryUid = KSenduiMtmSmtpUid;
+ }
+ else
+ {
+ entryUid = tentry.iMtm;
+ }
+
+ CBaseMtmUiData* mtmUiData;
+
+ TRAPD( returnVal, mtmUiData =
+ &( iMtmStore->MtmUiDataL( entryUid ) ) );
+
+ if ( returnVal == KErrNone)
+ {
+ TInt ret = mtmUiData->QueryCapability( KUidMtmQueryCanSendMsg, canCreateNew );
+
+ if ( ret == KErrNone )
+ {
+ append = ETrue;
+ }
+ else
+ {
+ append = EFalse;
+ }
+ }
+ else
+ {
+ append = EFalse;
+ }
+
+ iMtmStore->ReleaseMtmUiData( entryUid );
+
+ if( append )
+ {
+ listItemUids->AppendL( entryUid );
+ }
+ }
+ }
+ }
+ }
+ TBool emailIncluded = EFalse;
+ TBool syncMLIncluded = EFalse;
+ TUid uidMsgValTypeEmailMtmVal = GetFsIntegratedEmailAppMtmPluginId();
+ CDesCArrayFlat* items = new(ELeave)CDesCArrayFlat( KMceArrayGranularity );
+ CleanupStack::PushL( items );
+ for ( TInt loop = 0; loop < count ; loop++)
+ {
+ if ( FindMtmInVisibleListL( iMsgTypesSettings[loop].iUid, *listItemUids ) )
+ {
+ if ( !emailIncluded &&
+ ( iMsgTypesSettings[loop].iUid == KSenduiMtmSmtpUid ) )
+ {
+ tempArray->AppendL( iMsgTypesSettings[loop] );
+ emailIncluded = ETrue;
+ }
+ // Following is added because SyncML was missing from the list
+ else if ( !syncMLIncluded &&
+ ( iMsgTypesSettings[loop].iUid == KSenduiMtmSyncMLEmailUid ) )
+ {
+ tempArray->AppendL( iMsgTypesSettings[loop] );
+ syncMLIncluded = ETrue;
+ }
+ else if(iMsgTypesSettings[loop].iUid!=uidMsgValTypeEmailMtmVal)
+ {
+ tempArray->AppendL( iMsgTypesSettings[loop] );
+ }
+ }
+ else
+ {
+ tempArray->AppendL( iMsgTypesSettings[loop] );
+ }
+ }
+ CleanupStack::PopAndDestroy( items );
+ CleanupStack::PopAndDestroy( entry );
+ CleanupStack::PopAndDestroy( listItemUids );
+ }
+ else if(iEmailFramework) //Freestyle Feature is disabled and CMail Feature is enabled
+ {
+ MCELOGGER_WRITE("CMceUi::SettingsDialogL: cmail ");
+ CleanupStack::PushL( tempArray );
+ const TInt count = iMsgTypesSettings.Count();
+ for (TInt loop=0; loop < count; loop++)
+ {
+ if ( (iMsgTypesSettings[loop].iUid == KSenduiMtmSmtpUid ) ||
+ ( iMsgTypesSettings[loop].iUid == KSenduiMtmSyncMLEmailUid )||
+ (iMsgTypesSettings[loop].iUid == KUidMsgTypeFsMtmVal))
+ {
+ MCELOGGER_WRITE_FORMAT("not Loading %x", iMsgTypesSettings[loop].iUid );
+ continue;
+ }
+ else
+ {
+ MCELOGGER_WRITE_FORMAT(" Loading %x", iMsgTypesSettings[loop].iUid);
+ tempArray->AppendL( iMsgTypesSettings[loop] );
+ }
+ }
+ }
+
+ else //Freestyle Feature is disabled and CMail Feature is disabled
+
+ {
+
+ CleanupStack::PushL( tempArray );
+ const TInt count = iMsgTypesSettings.Count();
+ for (TInt loop=0; loop < count; loop++)
+ {
+ tempArray->AppendL( iMsgTypesSettings[loop] );
+ }
+ }
+
+ TUid uid;
+ uid.iUid = KMceAnswerToLifeUniverseAndEverything;
+ // this is not used anywhere, two last items in the list are
+ // ALWAYS cbs settings and mce general settings
+
+ // Run time Cell Broadcast variant.
+ TBool cbs = EFalse;
+ if ( FeatureManager::FeatureSupported( KFeatureIdCellBroadcast ) )
+ {
+ cbs = ETrue;
+ if ( iCsp )
+ {
+ cbs = CheckCspBitL();
+ }
+ }
+ if ( cbs )
+ {
+ HBufC* text = StringLoader::LoadL( R_MCE_CBS_SETTINGS_TEXT, iEikonEnv );
+ TUidNameInfo cbsSettings( uid, *text );
+ delete text;
+ tempArray->AppendL( cbsSettings );
+ }
+
+ HBufC* text = StringLoader::LoadL( R_MCE_GENERAL_SETTINGS_TEXT, iEikonEnv );
+ TUidNameInfo generalSettings( uid, *text );
+ delete text;
+ tempArray->AppendL( generalSettings );
+
+ // This is changed to automatic because local zoom should change only listbox zoom value
+ // so settings dialog zoom value should come from general settings and so we need to change
+ // local zoom to automatic before launching settings dialog
+ // Is settings opened from General Settings
+ CMuiuLock* repositoryLock = CMuiuLock::NewL( KMuiuLockSettings );
+ CleanupStack::PushL(repositoryLock);
+ TInt err = repositoryLock->Reserve();
+
+ // Check that settings are not opened from General Settings
+ if ( !err )
+ {
+ TAknUiZoom previous = ZoomLevelChangedL( EAknUiZoomAutomatic );
+ iMceUiFlags.SetMceFlag( EMceUiFlagsSettingsDialogOpen );
+ CMceSettingsDialog* dlg = CMceSettingsDialog::NewL( *tempArray, this, iSession);
+ dlg->ExecuteLD();
+ iMceUiFlags.ClearMceFlag( EMceUiFlagsSettingsDialogOpen );
+ ZoomLevelChangedL( previous );
+ }
+ else
+ {
+ // Show information note: General Settings has opened settings
+ CAknNoteDialog* dlg = new (ELeave) CAknNoteDialog(
+ CAknNoteDialog::ENoTone, CAknNoteDialog::ELongTimeout);
+ dlg->ExecuteLD(R_MCE_NOTE_SETTINGS_OPEN_GS);
+
+ }
+ // Release repository
+ repositoryLock->Release();
+ CleanupStack::PopAndDestroy( 2 ); // tempArray, repositoryLock
+
+ }
+
+// ----------------------------------------------------
+// CMceUi::CreateNewMessageL
+// Create a new message of the given type, in the given location
+// ----------------------------------------------------
+void CMceUi::CreateNewMessageL(TInt aMessageType)
+ {
+ __ASSERT_DEBUG( aMessageType != KUidMsvLocalServiceMtmValue,
+ Panic( EMceUiErrLocalMtm ) );
+ LeaveIfDiskSpaceUnderCriticalLevelL();
+ TUid messageTypeOrig;
+ messageTypeOrig.iUid = aMessageType;
+ TUid msgTypeUid;
+ msgTypeUid.iUid = 0;
+
+ TBool tabsToCleanupStack = EFalse;
+ TMsvId service = KMsvNullIndexEntryId;
+ if ( MceViewActive( EMceMessageViewActive ) && iMceListView )
+ {
+ const TMsvEntry& entry = iMceListView->ListContainer()->FolderEntry();
+ //cmail change
+ if ( (iSelectableEmail) && (!iEmailFramework ))
+ {
+ if ( entry.iMtm == KSenduiMtmImap4Uid ||
+ entry.iMtm == KSenduiMtmPop3Uid )
+ {
+ service = entry.iServiceId;
+ }
+ }
+ else
+ {
+ if ( aMessageType == entry.iMtm.iUid ||
+ ( aMessageType == KSenduiMtmSmtpUidValue
+ && (entry.iMtm == KSenduiMtmImap4Uid
+ || entry.iMtm == KSenduiMtmPop3Uid ) ) )
+ {
+ service = entry.iServiceId;
+ }
+ }
+ }
+
+
+ if ( service == KMsvNullIndexEntryId )
+ {
+ //cmail change
+ if ( (iSelectableEmail) && (!iEmailFramework ) )
+ {
+ if ( GetDefaultServiceL( aMessageType, service, msgTypeUid )
+ == EFalse )
+ {
+ return;
+ }
+ }
+ else
+ {
+ GetDefaultServiceL( aMessageType, service );
+ }
+ }
+
+ if ( ((iSelectableEmail) && (!iEmailFramework ))&& ( messageTypeOrig == KSenduiMtmSmtpUid ) )
+ {
+ if( ( msgTypeUid == KSenduiMtmSmtpUid) ||
+ ( msgTypeUid.iUid == KMsvNullIndexEntryId ) )
+ {
+ msgTypeUid.iUid = aMessageType;
+ }
+ }
+ else
+ {
+ msgTypeUid.iUid = aMessageType;
+ }
+
+ if ( iMceUiFlags.MceFlag( EMceUiFlagsTabsActive ) )
+ {
+ // must remove tabs because if no mailboxes created then
+ // mailbox settings dialog is displayed and tabs should not be shown then.
+ RemoveTabs();
+ CleanupStack::PushL( TCleanupItem( ShowTabs, this ) );
+ tabsToCleanupStack = ETrue;
+ }
+
+ CreateAndEditNewEntryL(
+ KUidMsvMessageEntryValue,
+ msgTypeUid,
+ KMsvDraftEntryId,
+ service );
+
+ if ( tabsToCleanupStack )
+ {
+ CleanupStack::PopAndDestroy(); // TCleanupItem - will show tabs again
+ }
+
+ // NCN reset does not requied for new email creation
+
+
+ }
+
+// ----------------------------------------------------
+// CMceUi::ShowTabs
+// Static function.
+// Used in CreateNewMessageL as TCleanupItem.
+// ----------------------------------------------------
+void CMceUi::ShowTabs(TAny* aAny)
+ {
+ CMceUi* mceUi = (CMceUi*) aAny;
+ if ( mceUi && mceUi->MceViewActive( EMceMessageViewActive ) && mceUi->iMceListView )
+ {
+ TRAP_IGNORE( mceUi->ShowTabsL( mceUi->iMceListView->ListContainer()->CurrentFolderId() ) );
+ }
+ }
+
+// ----------------------------------------------------
+// CMceUi::ResetEditorOperation
+// Static function.
+// Used in CreateNewMessageL as TCleanupItem.
+// ----------------------------------------------------
+void CMceUi::ResetEditorOperation(TAny* aAny)
+ {
+ CMceUi* mceUi = (CMceUi*) aAny;
+ MCELOGGER_WRITE_FORMAT("ResetEditorOperation iEditorOperation 0x%x set NULL", mceUi->iEditorOperation );
+ mceUi->iEditorOperation = NULL;
+ }
+
+// ----------------------------------------------------
+// CMceUi::CreateAndEditNewEntryL
+// ----------------------------------------------------
+void CMceUi::CreateAndEditNewEntryL(TMsvId aParentId, TMsvEntry& aNewEntry)
+ {
+ MCELOGGER_ENTERFN("CreateAndEditNewEntryL()");
+
+ LeaveIfDiskSpaceUnderCriticalLevelL();
+
+ __ASSERT_DEBUG(aNewEntry.iMtm != KUidMsvLocalServiceMtm,
+ Panic( EMceUiErrLocalMtm ) );
+
+ aNewEntry.iDate.HomeTime();
+
+ // --- Get the MTM UI relevant to the message type ---
+ CBaseMtmUi& mtmUi = iMtmStore->GetMtmUiLC( aNewEntry.iMtm );
+ CMsvEntry* centry = iSession->GetEntryL( aParentId );
+ // this allocates memory so cleanupstack is needed
+ CleanupStack::PushL( centry );
+ CAknInputBlock::NewLC();
+
+ CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL(*this);
+ CleanupStack::PushL( singleOpWatcher );
+
+ CleanupStack::PushL( TCleanupItem( ResetEditorOperation, this ) );
+
+ mtmUi.SetPreferences( mtmUi.Preferences() | EMtmUiFlagEditorPreferEmbedded );
+
+ CMsvOperation* op = mtmUi.CreateL(
+ aNewEntry,
+ *centry,
+ singleOpWatcher->iStatus );
+
+ MCELOGGER_WRITE_FORMAT("CreateAndEditNewEntryL: iEditorOperation set 0x%x", singleOpWatcher );
+ iEditorOperation = singleOpWatcher;
+
+ CleanupStack::PushL( op );
+ MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( op ); // singleOpWatcher, op
+ CleanupStack::Pop(); // ResetEditorOperation everything ok, don't reset iEditorOperation
+ CleanupStack::Pop( singleOpWatcher );
+
+ singleOpWatcher->SetOperation( op );
+
+ if ( aNewEntry.iType == KUidMsvMessageEntry &&
+ iUiRegistry &&
+ iUiRegistry->IsPresent( op->Mtm() ) )
+ {
+ iMtmStore->ClaimMtmUiL( op->Mtm() );
+ }
+
+ CleanupStack::PopAndDestroy(3); // CAknInputBlock, centry, release MtmUi
+
+ if ( MceViewActive( EMceMessageViewActive ) )
+ {
+ iMceListView->ListContainer()->ClearSelection();
+ }
+
+ MCELOGGER_LEAVEFN("CreateAndEditNewEntryL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::CreateAndEditNewEntryL
+// ----------------------------------------------------
+void CMceUi::CreateAndEditNewEntryL(
+ TInt aEntryType,
+ TUid aMtm,
+ TMsvId aParentId,
+ TMsvId aServiceId )
+ {
+ __ASSERT_DEBUG(aMtm != KUidMsvLocalServiceMtm,
+ Panic( EMceUiErrLocalMtm ) );
+ TMsvEntry nentry;
+ nentry.iMtm = aMtm;
+ nentry.iType.iUid = aEntryType;
+ nentry.iDate.HomeTime();
+ nentry.iServiceId = aServiceId;
+ CreateAndEditNewEntryL( aParentId, nentry );
+ }
+
+// ----------------------------------------------------
+// CMceUi::GetDefaultServiceL
+// when MceIntegration runtime flag is on
+// ----------------------------------------------------
+TBool CMceUi::GetDefaultServiceL( TInt aMtm, TMsvId& aService, TUid& aMtmUid )
+ {
+ TBool retVal = ETrue;
+ TUid mtm = { aMtm };
+
+ aService = MsvUiServiceUtilities::DefaultServiceForMTML( *iSession,
+ mtm,
+ ETrue );
+
+ if ( mtm == KSenduiMtmImap4Uid || mtm == KSenduiMtmPop3Uid
+ || mtm == KSenduiMtmSmtpUid )
+ {
+ retVal = CMceSettingsEmailSel::ShowSelectEmailDlgL( aService, aMtmUid );
+ }
+
+ return retVal;
+ }
+
+// ----------------------------------------------------
+// CMceUi::GetDefaultServiceL
+// ----------------------------------------------------
+void CMceUi::GetDefaultServiceL(TInt aMtm, TMsvId& aService)
+ {
+ TUid mtm = { aMtm };
+
+ aService = MsvUiServiceUtilitiesInternal::DefaultServiceForMTML(
+ *iSession,
+ mtm,
+ ETrue );
+ }
+
+// ----------------------------------------------------
+// CMceUi::OpCompleted
+// ----------------------------------------------------
+void CMceUi::OpCompleted(
+ CMsvSingleOpWatcher& aOpWatcher,
+ TInt aCompletionCode )
+ {
+ MCELOGGER_ENTERFN("OpCompleted()");
+ CMsvOperation* op=&aOpWatcher.Operation();
+ MCELOGGER_WRITE_FORMAT("operation id=%d completed", op->Id() );
+
+ // Store the command ID
+ TMsvOp tempOpID = op->Id();
+ TUid tempOpMtm = op->Mtm();
+
+ if ( &aOpWatcher == iEditorOperation )
+ {
+ MCELOGGER_WRITE_FORMAT("iEditorOperation 0x%x set NULL", iEditorOperation );
+ iEditorOperation = NULL;
+ if ( iMtmStore && //tempOpMtm != KUidMsvLocalServiceMtm && tempOpMtm != KUidMsvNullEntry &&
+ iUiRegistry &&
+ iUiRegistry->IsPresent( tempOpMtm ) )
+ {
+ iMtmStore->ReleaseMtmUi( tempOpMtm );
+ }
+ }
+
+#ifdef _DEBUG
+ TRAPD(ignore, DoOperationCompletedL(op, aCompletionCode));
+ MCELOGGER_WRITE_FORMAT("DoOperationCompletedL ignore %d", ignore );
+#else
+ TRAP_IGNORE(DoOperationCompletedL(op, aCompletionCode));
+#endif
+
+ ClearDontExitOnNextOperationComplete();
+
+ TBool foundItem = EFalse;
+ for (TInt cc = iOperations.Count()-1; cc >= 0 && !foundItem; cc--)
+ {
+ if (iOperations[cc]->Operation().Id()==op->Id())
+ {
+ delete iOperations[cc];
+ iOperations.Delete(cc);
+ foundItem = ETrue;
+ }
+ }
+
+ if ( &aOpWatcher == iDeleteOperation )
+ {
+ MCELOGGER_WRITE_FORMAT("iDeleteOperation 0x%x set NULL", iDeleteOperation );
+ iDeleteOperation = NULL;
+
+ if ( iMMSNotifications && iMMSNotifications->Count() > 0 )
+ {
+ //delete MMS notifications
+ TBuf8<1> params;
+ params.Append( KMceMMSNotifOne8 );
+ TRAPD( error, HandleMMSNotificationsDeleteL( params ) );
+ if ( error )
+ {
+ if ( !iMceErrorUi )
+ {
+ TRAP_IGNORE( iMceErrorUi = CErrorUI::NewL(*iCoeEnv) );
+ }
+ if ( iMceErrorUi )
+ {
+ TRAP_IGNORE( iMceErrorUi->ShowGlobalErrorNoteL( error ) );
+ }
+ // ignore
+ }
+ }
+
+// Cancel free disk space request to be added
+
+ }
+
+ else if ( iMMSNotifications
+ && ( tempOpMtm == KUidMsgMMSNotification ) )
+ {
+ // check if MMS notification delete failed
+ TRAP_IGNORE( CheckMMSNotifDelFailedL() );
+ }
+ else
+ {
+ //nothing special done
+ }
+
+
+ if ( &aOpWatcher == iFetchNewOperation )
+ {
+ iFetchNewOperation = NULL;
+ // TODO
+ if ( ( iMceListView->ListContainer()->Count() )
+ && MceViewActive( EMceMessageViewActive ) )
+ {
+// iMceListView->ListContainer()->ListBox()->SetCurrentItemIndex( 0 );
+// iMceListView->ListContainer()->ListBox()->DrawDeferred();
+ }
+ }
+
+// Email messages cannot be copied or moved, show the note
+ if ( ( iMoveOrCopyMailOperation != -1 ) && ( iMoveOrCopyMailOperation == tempOpID ) )
+ {
+ TRAP_IGNORE( InformationNoteCannotMoveCopyEMailL() );
+ }
+
+ if ( iHandleNewMsgToInbox )
+ {
+ TRAP_IGNORE( HandleNewMsgToInboxL( EFalse, NULL ) );
+ }
+
+ __ASSERT_DEBUG( foundItem, Panic( EMceUiErrOperationNotFound ) );
+ MCELOGGER_LEAVEFN("OpCompleted()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::DoOperationCompletedL
+// ----------------------------------------------------
+void CMceUi::DoOperationCompletedL(
+ CMsvOperation* aOperation,
+ TInt aCompletionCode )
+ {
+ __ASSERT_DEBUG( aOperation, Panic( EMceUiErrOperationNull ) );
+ if ( !aOperation )
+ {
+ return;
+ }
+
+ if ( iLocalScreenClearer &&
+ aCompletionCode != CMsgEmbeddedEditorWatchingOperation::EMsgExitNext &&
+ aCompletionCode != CMsgEmbeddedEditorWatchingOperation::EMsgExitPrevious )
+ {
+
+ delete iLocalScreenClearer;
+ iLocalScreenClearer = NULL;
+
+ }
+
+ MCELOGGER_WRITE_FORMAT("CMceUi::DoOperationCompletedL: aCompletionCode: %d", aCompletionCode );
+
+ if ( aOperation->Id() == iMailboxDeleteOperation )
+ {
+ CMceMainViewListItemArray* array = iMceMainView->ListContainer()->ListItems();
+ if ( array )
+ {
+ array->HandleSessionEventL(EMsvEntriesDeleted, NULL, NULL, NULL );
+ }
+ }
+
+ if ( ViewUpdateSuppressionFlag() && iBlockingOperation == aOperation )
+ {
+ SetViewUpdateSuppressionFlag( EFalse, NULL );
+ iMceListView->UpdateViewL();
+ }
+
+ TInt closedEntryId = 0;
+ // Retrieve value of KMuiuKeyCurrentMsg
+ TInt r = RProperty::Get( KPSUidMuiu, KMuiuKeyCurrentMsg, closedEntryId );
+ if ( r != KErrNone )
+ {
+ closedEntryId = 0;
+ }
+ if ( aCompletionCode == EEikCmdExit &&
+ !iMceUiFlags.MceFlag( EMceUiFlagsDoNotExitAfterNextOperationComplete ) )
+ {
+ MCELOGGER_WRITE("CMceUi::DoOperationCompletedL: EXIT");
+ iAvkonViewAppUi->ProcessCommandL( EAknCmdHideInBackground );
+ return;
+ }
+ // viewer next/prev
+ else if ( aCompletionCode == CMsgEmbeddedEditorWatchingOperation::EMsgExitNext ||
+ aCompletionCode == CMsgEmbeddedEditorWatchingOperation::EMsgExitPrevious )
+ {
+ MCELOGGER_WRITE("CMceUi::DoOperationCompletedL: Opening next/previous");
+ if ( iMessageIterator && closedEntryId > 0 )
+ {
+ TMsvEntry currentEntry;
+ TMsvId serviceId; // not used here but needed by GetEntry function
+ // Get current entry
+ if ( iSession->GetEntry( closedEntryId, serviceId, currentEntry ) == KErrNone )
+ {
+ iMessageIterator->SetCurrentMessageL( currentEntry );
+ }
+ }
+ HandleOpenNextPreviousL( aCompletionCode ==
+ CMsgEmbeddedEditorWatchingOperation::EMsgExitNext );
+ if ( !IsForeground() )
+ {
+ // bring mce application to foreground
+ iEikonEnv->RootWin().SetOrdinalPosition(0);
+ }
+ return;
+ }
+ else
+ {
+ MCELOGGER_WRITE("CMceUi::DoOperationCompletedL: deleting iMessageIterator");
+ // Viewer closed
+ if ( closedEntryId > 0 && iMessageIterator )
+ {
+ CMceMessageListContainerBase* container = iMceListView->ListContainer();
+ if ( container )
+ {
+ container->SetCurrentItemIdL( closedEntryId );
+ }
+ }
+ delete iMessageIterator;
+ iMessageIterator = NULL;
+ }
+
+ if ( !iMceErrorUi )
+ {
+ iMceErrorUi = CErrorUI::NewL(*iCoeEnv);
+ }
+
+ if ( aCompletionCode == KMsvIndexRestore )
+ {
+ iMceErrorUi->ShowGlobalErrorNoteL( aCompletionCode );
+ }
+
+ const TDesC8& progress = aOperation->ProgressL();
+
+ if (aOperation->Mtm() != KUidMsvLocalServiceMtm )
+ {
+ MCELOGGER_WRITE_FORMAT("CMceUi::DoOperationCompletedL: calling mtm ui 0x%x DisplayProgressSummary", aOperation->Mtm().iUid );
+ CAknInputBlock::NewLC();
+ CMtmStore* mtmStore=CMtmStore::NewL(*iSession);
+ CleanupStack::PushL( mtmStore );
+
+ CBaseMtmUi& ui = mtmStore->GetMtmUiLC( aOperation->Mtm() );
+ if ( aOperation->Service() > KFirstFreeEntryId
+ && ( aOperation->Mtm() == KSenduiMtmImap4Uid
+ || aOperation->Mtm() == KSenduiMtmPop3Uid ) )
+ {
+ ui.BaseMtm().SwitchCurrentEntryL( aOperation->Service() );
+ }
+ ui.DisplayProgressSummary( progress );
+ CleanupStack::PopAndDestroy( 3 ); // CAknInputBlock, mtmStore, release mtmUi
+ MCELOGGER_WRITE("DisplayProgressSummary done");
+ return;
+ }
+
+ if (progress.Length() == 0)
+ {
+ return;
+ }
+
+ TMsvLocalOperationProgress localprogress =
+ McliUtils::GetLocalProgressL( *aOperation );
+
+ if ( ( aCompletionCode == KErrNone
+ || aCompletionCode == KErrCancel )
+ && ( localprogress.iError == KErrNone
+ || localprogress.iError == KErrCancel ) )
+ {
+ return;
+ }
+
+ MCELOGGER_WRITE_FORMAT("CMceUi::DoOperationCompletedL, localProgress.iType %d", localprogress.iType )
+ MCELOGGER_WRITE_FORMAT("error %d", localprogress.iError?localprogress.iError:aCompletionCode )
+
+ iMceErrorUi->ShowGlobalErrorNoteL( localprogress.iError?localprogress.iError:aCompletionCode );
+ }
+
+// ----------------------------------------------------
+// CMceUi::CreateNewFolderL
+// ----------------------------------------------------
+void CMceUi::CreateNewFolderL()
+ {
+ LeaveIfDiskSpaceUnderCriticalLevelL();
+
+ TMsvEntry newFolder;
+ const TMsvId parentId=iMceListView->ListContainer()->CurrentFolderId();
+ if ( parentId != KMceDocumentsEntryId )
+ {
+#if defined(_DEBUG)
+ Panic( EMceUiErrCannotCreateFolder );
+#endif
+ return;
+ }
+
+ _LIT(KMceFormatFolderName, "%S(%02d)");
+ TBuf<KMceMaxFolderLength> folderName;
+ TInt num = 0;
+ TBuf<KMceTextLength> defaultFolderName;
+ StringLoader::Load( defaultFolderName, R_MCE_DEFAULT_FOLDER_NAME, iEikonEnv );
+ folderName.Copy( defaultFolderName );
+ while( iMceListView->IsFolderNameUsedL( folderName ) )
+ {
+ num++;
+ folderName.Format( KMceFormatFolderName, &defaultFolderName, num );
+ AknTextUtils::DisplayTextLanguageSpecificNumberConversion( folderName );
+ }
+
+ if ( FolderNameQueryL( R_MCE_CREATE_FOLDER, folderName ) )
+ {
+ CAknInputBlock::NewLC();
+ CMsvSingleOpWatcher* singleOpWatcher=CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( singleOpWatcher );
+
+ iEntry->SetEntryL( parentId );
+ newFolder.iDate.HomeTime();
+ newFolder.iDetails.Set( folderName );
+ newFolder.iType = KUidMsvFolderEntry;
+ newFolder.iMtm = iEntry->Entry().iMtm;
+ newFolder.iServiceId= iEntry->OwningService();
+
+ CMsvOperation* op = iEntry->CreateL( newFolder, singleOpWatcher->iStatus );
+ CleanupStack::PushL( op );
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2 ); // singleOpWatcher, op
+ singleOpWatcher->SetOperation( op );
+ MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
+ CleanupStack::PopAndDestroy(); //CAknInputBlock
+ }
+ }
+
+// ----------------------------------------------------
+// CMceUi::RenameFolderL
+// ----------------------------------------------------
+void CMceUi::RenameFolderL()
+ {
+ const CMceMessageListContainerBase* container = iMceListView->ListContainer();
+ TMsvId currentId = container->CurrentItemId();
+
+ CMsvEntry* centry=iSession->GetEntryL( currentId );
+ CleanupStack::PushL( centry );
+ TMsvEntry entry = centry->Entry();
+
+ __ASSERT_DEBUG(entry.iType == KUidMsvFolderEntry,
+ Panic(EMceUiErrRenameNotFolder));
+ __ASSERT_DEBUG(entry.iMtm == KUidMsvLocalServiceMtm,
+ Panic(EMceUiErrRenameNotLocal));
+
+
+ TBuf<KMceMaxFolderLength> buf = entry.iDetails.Left( KMceMaxFolderLength );
+ if ( FolderNameQueryL( R_MCE_CREATE_FOLDER, buf, entry.Id() ) )
+ {
+ CAknInputBlock::NewLC();
+ CMsvSingleOpWatcher* singleOpWatcher=CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL(singleOpWatcher);
+ iEntry->SetEntryL( entry.Id() );
+ entry.iDetails.Set( buf );
+ CMsvOperation* op = iEntry->ChangeL( entry, singleOpWatcher->iStatus );
+ CleanupStack::PushL( op );
+ iOperations.AppendL(singleOpWatcher);
+ CleanupStack::Pop( 2 ); // singleOpWatcher, op
+ singleOpWatcher->SetOperation(op);
+ MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
+ CleanupStack::PopAndDestroy(); //CAknInputBlock
+ }
+ CleanupStack::PopAndDestroy( centry );
+ }
+
+// ----------------------------------------------------
+// CMceUi::FolderNameQueryL
+// ----------------------------------------------------
+TBool CMceUi::FolderNameQueryL(
+ const TInt aResourceId,
+ TDes& aFolderName,
+ const TMsvId aFolderId /*= KMsvNullIndexEntryId */ ) const
+ {
+ CAknTextQueryDialog* dlg = NULL;
+ TInt button = 0;
+ TBool okToStop = EFalse;
+ while ( !okToStop )
+ {
+ dlg = CAknTextQueryDialog::NewL( aFolderName );
+ dlg->SetMaxLength( KMceMaxFolderLength );
+ button = dlg->ExecuteLD( aResourceId );
+ if ( button )
+ {
+ MceUtils::ReplaceCharacters( aFolderName );
+ if ( iMceListView->IsFolderNameUsedL( aFolderName, aFolderId ) )
+ {
+ HBufC* errorText = StringLoader::LoadLC(
+ R_MCE_DUPLICATE_FOLDER_TEXT, aFolderName, iEikonEnv );
+ CAknInformationNote* note = new(ELeave)CAknInformationNote( ETrue );
+ note->ExecuteLD(*errorText);
+ CleanupStack::PopAndDestroy( errorText );
+ }
+ else
+ {
+ okToStop = ETrue;
+ }
+ }
+ else
+ {
+ okToStop = ETrue;
+ }
+ }
+ return button;
+ }
+
+// ----------------------------------------------------
+// CMceUi::CloseConnectionsBeforeExitL
+// ----------------------------------------------------
+void CMceUi::CloseConnectionsBeforeExitL()
+ {
+ CMsvEntrySelection* connectedAccounts = ConnectedServicesLC();
+ const TInt numberOfConnectedMailboxes = connectedAccounts->Count();
+ TInt mceConnected = numberOfConnectedMailboxes;
+
+ if ( iAlwaysOnline )
+ {
+ TMsvId account;
+ TMsvEntry entry;
+ TMsvId service;
+
+ for ( TInt cc = 0; cc < numberOfConnectedMailboxes; cc++ )
+ {
+ account = connectedAccounts->At( cc );
+ User::LeaveIfError( iSession->GetEntry(account,service,entry) );
+// Get the allways online mail settings
+ CImumInSettingsData* settings =
+ iEmailApi->MailboxServicesL().LoadMailboxSettingsL( account );
+ CleanupStack::PushL( settings );
+
+ if ( !ServiceIdFound( account ) &&
+ iMceMainView->ListContainer()->ListItems()->
+ AlwaysOnlineAccountL( account, *settings ) )
+ {
+ //this is a real always online account and not connected from mce
+ mceConnected--;
+ }
+
+ CleanupStack::PopAndDestroy( settings ); // extendedMailSettings
+ }
+ }
+
+ if ( mceConnected > 0 )
+ {
+ TBool disconnectMailboxes = ETrue;
+ if( iEmailClientIntegration && iSelectableEmail )
+ {
+ //no need to go through the disconnection logic since the FS is enabled
+ disconnectMailboxes = EFalse;
+ iMceUiFlags.SetMceFlag( EMceUiFlagsWantToExit );
+ }
+ else
+ if ( MceViewActive( EMceMainViewActive )
+ || ( MceViewActive( EMceMessageViewActive )
+ && iMceListView->IsMSKMailBox() ) )
+ {
+ CAknQueryDialog* confDialog = CAknQueryDialog::NewL();
+ confDialog->PrepareLC( R_MCE_CONFIRMATION );
+ HBufC* titleText = NULL;
+ if ( numberOfConnectedMailboxes == 1 )
+ {
+ titleText = StringLoader::LoadLC(
+ R_MCE_CONNECTION_ON_TEXT,
+ iEikonEnv );
+ }
+ else
+ {
+ titleText = StringLoader::LoadLC(
+ R_MCE_CONNECTION_ON_MANY_TEXT,
+ iEikonEnv );
+ }
+
+ confDialog->SetPromptL( *titleText );
+ CleanupStack::PopAndDestroy( titleText );
+
+ if ( !confDialog->RunLD() )
+ {
+ disconnectMailboxes = EFalse;
+ }
+ }
+ if ( disconnectMailboxes )
+ {
+ iMceUiFlags.SetMceFlag( EMceUiFlagsExitAfterDisconnect );
+ for ( TInt loop = 0; loop < numberOfConnectedMailboxes; loop++ )
+ {
+ GoOfflineSynchronouslyL( connectedAccounts->At( loop ) );
+ }
+ if (iMceUiFlags.MceFlag( EMceUiFlagsExitAfterDisconnect ) )
+ {
+ iMceUiFlags.SetMceFlag( EMceUiFlagsWantToExit );
+ }
+ }
+ }
+ else
+ {
+ iMceUiFlags.SetMceFlag( EMceUiFlagsWantToExit );
+ }
+ CleanupStack::PopAndDestroy(); // connectedAccounts
+ }
+
+// ----------------------------------------------------
+// CMceUi::ConnectedServicesLC
+// ----------------------------------------------------
+CMsvEntrySelection* CMceUi::ConnectedServicesLC()
+ {
+ MCELOGGER_ENTERFN("ConnectedServicesLC()");
+
+ CMsvEntrySelection* connectedAccounts = new(ELeave) CMsvEntrySelection();
+ CleanupStack::PushL(connectedAccounts);
+
+ CMsvEntrySelection* sel = MsvUiServiceUtilities::GetListOfAccountsL(
+ *iSession );
+ CleanupStack::PushL( sel );
+ const TUid connectCapability={KUidMsvMtmUiQueryConnectionOrientedServices};
+
+ CBaseMtmUiData* uiData=NULL;
+ TUid uid;
+ const TInt numAccounts=sel->Count();
+ for (TInt cc=0; cc<numAccounts; cc++)
+ {
+ uid.iUid=sel->At(cc);
+ const TMsvEntry& tentry=iRootEntry->ChildDataL(uid.iUid);
+
+ TRAPD(error, ( uiData=GetMtmUiDataL(tentry.iMtm) ) );
+ if (error==KErrNone && uiData)
+ {
+ TInt rid;
+ if (uiData->QueryCapability(connectCapability, rid)==KErrNone)
+ {
+ if (tentry.Connected())
+ {
+ connectedAccounts->AppendL( sel->At(cc) );
+ }
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( sel );
+ MCELOGGER_LEAVEFN("ConnectedServicesLC()");
+ return connectedAccounts;
+ }
+
+// ----------------------------------------------------
+// CMceUi::OpenFolderViewL
+// ----------------------------------------------------
+void CMceUi::OpenFolderViewL( TMsvId aFolderId )
+ {
+ iMceListView->SetFolderL( aFolderId );
+ ActivateLocalViewL( KMceMessageListViewId );
+ }
+
+// ----------------------------------------------------
+// CMceUi::OpenRemoteMailboxViewL
+// ----------------------------------------------------
+void CMceUi::OpenRemoteMailboxViewL( TMsvId aFolderId )
+ {
+ // NCN reset, if the mail folder contains unread messages
+ TBool unreadMessages = EFalse;
+#ifndef RD_MSG_NAVIPANE_IMPROVEMENT
+ TRAPD(err, ( unreadMessages = iBitmapResolver->HasUnreadMessagesL(aFolderId) ) );
+#else
+ TInt messageCount = 0;
+ TInt unreadCount = 0;
+ TRAPD(err, ( unreadMessages = iBitmapResolver->HasUnreadMessagesL(aFolderId, messageCount, unreadCount) ) );
+#endif // RD_MSG_NAVIPANE_IMPROVEMENT
+ if (err == KErrNone && unreadMessages )
+ {
+ HandleNotif(aFolderId);
+ }
+ OpenFolderViewL( aFolderId );
+ ShowTabsL( aFolderId );
+ }
+
+// ----------------------------------------------------
+// CMceUi::CancelMailboxTimer
+// ----------------------------------------------------
+void CMceUi::CancelMailboxTimer()
+ {
+ if ( iConnectMailboxTimer && iConnectMailboxTimer->IsActive() )
+ {
+ iConnectMailboxTimer->Cancel();
+ }
+ }
+
+// ----------------------------------------------------
+// CMceUi::EditMTMEntryL
+// ----------------------------------------------------
+void CMceUi::EditMTMEntryL( const TMsvEntry& aEntry /*, TBool aOpen*/)
+ {
+ // Define KPSUidMuiu property to be integer type
+ TInt r = RProperty::Define( KPSUidMuiu, KMuiuKeyCurrentMsg, RProperty::EInt );
+ if ( r != KErrAlreadyExists )
+ {
+ User::LeaveIfError( r );
+ }
+ // Set entry Id value to property
+ if ( aEntry.iType == KUidMsvMessageEntry )
+ {
+ r = RProperty::Set( KPSUidMuiu, KMuiuKeyCurrentMsg, aEntry.Id() );
+ }
+
+ TBool tabsToCleanupStack = EFalse;
+ delete iMessageIterator;
+ iMessageIterator = NULL;
+ if ( aEntry.iType == KUidMsvMessageEntry )
+ {
+ iMessageIterator = CMessageIterator::NewL( *iSession, aEntry );
+ }
+
+ CBaseMtmUi& mtmUi=iMtmStore->GetMtmUiAndSetContextLC( aEntry );
+ mtmUi.SetPreferences( mtmUi.Preferences() | EMtmUiFlagEditorPreferEmbedded );
+
+ CMsvOperation* op = NULL;
+ CAknInputBlock::NewLC();
+
+ CMsvSingleOpWatcher* singleOpWatcher=CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( singleOpWatcher );
+ if (aEntry.iType == KUidMsvMessageEntry )
+ {
+ MCELOGGER_WRITE_FORMAT("EditMTMEntryL: iEditorOperation set 0x%x", singleOpWatcher );
+ iEditorOperation = singleOpWatcher;
+ }
+ CleanupStack::PushL( TCleanupItem( ResetEditorOperation, this ) );
+
+
+ if ( aEntry.iType == KUidMsvServiceEntry )
+ {
+ if ( iMceUiFlags.MceFlag( EMceUiFlagsTabsActive ) )
+ {
+ // must remove tabs because if no mailboxes created then
+ // mailbox settings dialog is displayed and tabs should not be shown then.
+ RemoveTabs();
+ CleanupStack::PushL( TCleanupItem( ShowTabs, this ) );
+ tabsToCleanupStack = ETrue;
+ }
+ TAknUiZoom previous = ZoomLevelChangedL( EAknUiZoomAutomatic );
+ op=mtmUi.EditL( singleOpWatcher->iStatus );
+ ZoomLevelChangedL( previous );
+
+ if ( tabsToCleanupStack )
+ {
+ CleanupStack::PopAndDestroy(); // TCleanupItem - will show tabs again
+ }
+ }
+ else
+ {
+
+ ReleaseMtmUiData();
+
+ TRAPD( error, ( op=mtmUi.OpenL(singleOpWatcher->iStatus ) ) );
+ if ( error )
+ {
+ // the returned error ofCBaseMtmUi code is defined in e32err.h instead of DocumentHandler.h
+ // KMimeNotSupported(-12003) and KErrNotSupported(-5) has same meaning but different value
+ // Solution: add the corresponding error code from e32err.h : (KErrUnknown, KErrAccessDenied ?)
+ if ( error == KMimeNotSupported || error == KBadMimeType || error == KExecNotAllowed
+ || error == KErrNotSupported || error == KErrUnknown || error == KErrAccessDenied )
+ {
+ //cannot be opened, mark read
+ CMsvEntry* cEntry;
+ cEntry = &(mtmUi.BaseMtm().Entry());
+ TMsvEntry entry = cEntry->Entry();
+ entry.SetUnread( EFalse );
+ cEntry->ChangeL( entry );
+ }
+
+ // HandleOpenL is Trapped in MceOneRowListContainer to show error note we need to do it by ourselves
+ delete op; // op should be null if leave occurs but make sure it is not leaked.
+ HBufC* buf = 0;
+ HandleErrorL(error, &buf);
+ delete buf;
+ CleanupStack::PopAndDestroy( 4 );
+ if (error && iLocalScreenClearer )
+ {
+ delete iLocalScreenClearer;
+ iLocalScreenClearer = NULL;
+ }
+ return;
+
+ //User::Leave( error );
+ }
+
+ CMceMessageListContainerBase* listContainer = iMceListView->ListContainer();
+ if ( listContainer )
+ {
+ listContainer->UpdateIconArrayL();
+ }
+
+ // the check has been added for email mailbox, need not to clear the screen
+ if ( !iLocalScreenClearer &&
+ !CheckTechnologyTypeFromMtm( KMailTechnologyTypeUid, aEntry.iMtm ))
+ {
+ iLocalScreenClearer = CAknLocalScreenClearer::NewL( ETrue );
+ }
+ }
+
+ CleanupStack::PushL( op );
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 3 ); // singleOpWatcher, ResetEditorOperation op
+ singleOpWatcher->SetOperation( op );
+ MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
+ if ( aEntry.iType == KUidMsvMessageEntry &&
+ iUiRegistry &&
+ iUiRegistry->IsPresent( op->Mtm() ) )
+ {
+ iMtmStore->ClaimMtmUiL( aEntry.iMtm );
+ }
+ CleanupStack::PopAndDestroy( 2 ); // CAknInputBlock, release mtmUi
+ }
+
+// ----------------------------------------------------
+// CMceUi::CreateNewAccountL
+// ----------------------------------------------------
+TBool CMceUi::CreateNewAccountL(
+ TUid aMessageType,
+ TMsvId aOldServiceId /* = KMsvNullIndexEntryId */)
+ {
+ MCELOGGER_ENTERFN("CreateNewAccountL()");
+ if ( aMessageType == KSenduiMtmSyncMLEmailUid )
+ {
+ aMessageType = KSenduiMtmSmtpUid;
+ }
+
+ iRootEntry->SetEntryL(KMsvRootIndexEntryIdValue);
+
+ LeaveIfDiskSpaceUnderCriticalLevelL();
+
+ TMsvEntry nentry;
+ nentry.iMtm = aMessageType;
+ nentry.iType.iUid = KUidMsvServiceEntryValue;
+ nentry.iDate.HomeTime();
+ nentry.iServiceId = aOldServiceId;
+
+ // --- Get the MTM UI relevant to the message type ---
+ CBaseMtmUi& mtmUi = iMtmStore->GetMtmUiLC( nentry.iMtm );
+ CMsvEntry* centry = iSession->GetEntryL( KMsvRootIndexEntryId );
+ CleanupStack::PushL( centry );
+ CAknInputBlock::NewLC();
+
+ CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL(*this);
+ CleanupStack::PushL( singleOpWatcher );
+
+ // Mailbox creation is ongoing, syncronic operation
+ iMailboxCreationOn = ETrue;
+ CMsvOperation* op = mtmUi.CreateL(
+ nentry,
+ *centry,
+ singleOpWatcher->iStatus );
+ // Mailbox creation finalized
+ iMailboxCreationOn = EFalse;
+
+ CleanupStack::PushL( op );
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2 ); // singleOpWatcher, op
+ singleOpWatcher->SetOperation( op );
+
+ TBool accountCreated = (op->iStatus != KErrCancel);
+ // if not created, imum returns completed operation with KErrCancel
+ if ( accountCreated )
+ {
+ iMceMainView->ListContainer()->ListItems()->HandleSessionEventL( EMsvEntriesCreated, NULL, NULL, NULL );
+ }
+
+ CleanupStack::PopAndDestroy(); // CAknInputBlock
+ CleanupStack::PopAndDestroy( centry );
+ CleanupStack::PopAndDestroy(); // mtm ui release
+ MCELOGGER_LEAVEFN("CreateNewAccountL()");
+ return accountCreated;
+ }
+
+// ----------------------------------------------------
+// CMceUi::EditAccountL
+// ----------------------------------------------------
+void CMceUi::EditAccountL(TMsvId aId)
+ {
+
+ iRootEntry->SetEntryL(KMsvRootIndexEntryIdValue);
+
+ LeaveIfDiskSpaceUnderCriticalLevelL();
+
+ TMsvEntry entry;
+
+ CMsvEntrySelection* rootSel = iRootEntry->ChildrenL();
+ CleanupStack::PushL( rootSel );
+ const TInt index = rootSel->Find( aId );
+ if (index > KErrNotFound)
+ {
+ entry = (*iRootEntry)[index];
+ EditMTMEntryL( entry );
+ }
+ CleanupStack::PopAndDestroy( rootSel );
+ }
+
+// ----------------------------------------------------
+// CMceUi::MtmAccountsL
+// ----------------------------------------------------
+CUidNameArray* CMceUi::MtmAccountsL( TUid aType )
+ {
+
+ iRootEntry->SetEntryL(KMsvRootIndexEntryIdValue);
+
+ CUidNameArray* accounts = new (ELeave) CUidNameArray(
+ KMceArrayGranularity );
+ CleanupStack::PushL( accounts );
+
+ CMsvEntrySelection* sel = NULL;
+
+ if ( aType == KSenduiMtmSmtpUid )
+ {
+ sel = MsvUiServiceUtilities::GetListOfAccountsL(
+ *iSession,
+ ETrue );
+ }
+ else
+ {
+ sel = MsvUiServiceUtilities::GetListOfAccountsWithMTML(
+ *iSession,
+ aType,
+ ETrue );
+ }
+ CleanupStack::PushL( sel );
+
+ CMsvEntry* rootEntry = CMsvEntry::NewL(
+ *iSession,
+ KMsvRootIndexEntryId,
+ TMsvSelectionOrdering(KMsvNoGrouping, EMsvSortByNone, ETrue));
+ delete iRootEntry;
+ iRootEntry = rootEntry;
+
+ TUid uid;
+ TUid techType = iUiRegistry->TechnologyTypeUid( aType );
+ const TInt numAccounts = sel->Count();
+ for (TInt cc=0; cc<numAccounts; cc++)
+ {
+ uid.iUid = sel->At(cc);
+ TMsvEntry tentry;
+ TRAPD( err, ( tentry = iRootEntry->ChildDataL( uid.iUid ) ) );
+ if ( err == KErrNone &&
+ iUiRegistry->IsPresent( tentry.iMtm ) &&
+ iUiRegistry->TechnologyTypeUid( tentry.iMtm ) == techType )
+ {
+ const TInt count = accounts->Count();
+ TBool foundService = EFalse;
+ //check that related service is not already added to array
+ for ( TInt loop = 0; loop < count; loop ++ )
+ {
+ if ( tentry.iRelatedId == (*accounts)[loop].iUid.iUid )
+ {
+ foundService = ETrue;
+ break;
+ }
+ }
+ if ( !foundService )
+ {
+ TUidNameInfo info( uid, tentry.iDetails.Left( KHumanReadableNameLength ) );
+ MceUtils::ReplaceCharacters( info.iName );
+ accounts->AppendL( info );
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( sel );
+ CleanupStack::Pop( accounts );
+ return accounts;
+ }
+
+// ----------------------------------------------------
+// CMceUi::HandleDeleteL
+// ----------------------------------------------------
+void CMceUi::HandleDeleteL()
+ {
+ MCELOGGER_ENTERFN("HandleDeleteL()");
+
+ __ASSERT_DEBUG( MceViewActive( EMceMessageViewActive ),
+ Panic( EMceUiErrCannotDeleteFromMainView ) );
+ if ( MceViewActive( EMceMainViewActive ) )
+ {
+ return;
+ }
+
+ CMsvEntrySelection * selection = iMceListView->ListContainer()
+ ->CurrentItemSelectionL();
+ CleanupStack::PushL( selection );
+ __ASSERT_DEBUG( selection->Count() > 0,
+ Panic( EMceUiErrCannotDeleteFromMainView ) );
+
+ if ( selection->Count() <= 0 )
+ {
+ CleanupStack::PopAndDestroy( selection );
+ return;
+ }
+
+ iMceListView->ListContainer()->SetAnchorItemIdL(
+ CMceMessageListContainerBase::EMessageListOperationDelete );
+
+ const TMsvId id = selection->At(0);
+ iEntry->SetEntryL(id);
+ const TInt type = iEntry->Entry().iType.iUid;
+
+ if ( IsMessageSendingL( id ) )
+ {
+ CleanupStack::PopAndDestroy( selection );
+ return;
+ }
+
+ __ASSERT_DEBUG( type == KUidMsvMessageEntryValue || type == KUidMsvFolderEntryValue,
+ Panic(EMceUiErrCannotDeleteServiceFromMainView) );
+
+ TBool local = iEntry->OwningService() == KMsvLocalServiceIndexEntryIdValue;
+
+ if ( iMMSNotifications )
+ {
+ delete iMMSNotifications;
+ iMMSNotifications = NULL;
+ }
+
+ if ( local && ( ( iEntry->Entry().Parent() == KMsvGlobalInBoxIndexEntryId ) ||
+ ( iEntry->Entry().Parent() == KMsvGlobalOutBoxIndexEntryId ) ) )
+ {
+ CheckMMSNotificationsL( selection );
+ if ( selection->Count() <= 0 )
+ {
+ // delete mms notifications, if any
+ if ( iMMSNotifications->Count() > 0 )
+ {
+ //delete MMS notifications
+ TBuf8<1> params;
+ HandleMMSNotificationsDeleteL( params );
+ }
+ CleanupStack::PopAndDestroy( selection );
+ return;
+ }
+ }
+
+ if ( local )
+ {
+ CAknQueryDialog* confDialog = CAknQueryDialog::NewL();
+ confDialog->PrepareLC( R_MCE_CONFIRMATION );
+ // confDialog in CleanupStack now
+ HBufC* titleText;
+ if ( type == KUidMsvFolderEntryValue )
+ {
+ titleText = StringLoader::LoadLC( R_MCE_QUERY_COMMON_CONF_DELETE_FO,
+ iEntry->Entry().iDetails.Left( iBitmapResolver->DescriptionLength() ), iEikonEnv );
+ }
+ else
+ {
+ if ( selection->Count() == 1 )
+ {
+ titleText = StringLoader::LoadLC(
+ R_MCE_QUERY_COMMON_CONF_DELETE_ME, iEikonEnv );
+ }
+ else
+ {
+ titleText = StringLoader::LoadLC(
+ R_MCE_QUERY_COMMON_CONF_DELETE_MS,
+ selection->Count(), iEikonEnv );
+ }
+ }
+ confDialog->SetPromptL( *titleText );
+ CleanupStack::PopAndDestroy( titleText );
+ // RunLD removes confDialog from CleanupStack and deletes itself
+ if ( !confDialog->RunLD() )
+ {
+ CleanupStack::PopAndDestroy( selection ); // selection
+ return;
+ }
+ }
+ iEntry->SetEntryL( iEntry->Entry().Parent() );
+
+ CBaseMtmUi* ui = NULL;
+ TUid mtm=iEntry->Entry().iMtm;
+ if ( !local )
+ {
+ TRAPD(uiErr, (ui = &iMtmStore->ClaimMtmUiL( mtm )));
+ if ( uiErr == KErrNotFound || uiErr == KErrNotSupported )
+ {
+ // MTM not present, so delete as normal local entry
+ ui = NULL;
+ }
+ else
+ {
+ User::LeaveIfError(uiErr);
+ }
+ }
+ if (ui)
+ {
+ CMtmStoreMtmReleaser::CleanupReleaseMtmUiLC(*iMtmStore, mtm);
+ }
+
+ CMsvOperation* op;
+
+ if ( local )
+ {
+ __ASSERT_DEBUG( !iDeleteOperation,
+ Panic( EMceUiErrAlreadyDeleting ) );
+
+// Free disk space request for delete to be added
+ }
+
+ CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( singleOpWatcher );
+
+ TBool resetSelection = ETrue;
+
+ if (ui)
+ {
+ // reset ncn, if it is unread message
+ TMsvEntry entry;
+ TMsvId serviceId;
+ User::LeaveIfError( iSession->GetEntry(selection->At(0),serviceId,entry) );
+
+ if ( CheckTechnologyTypeFromMtm( KMailTechnologyTypeUid,
+ entry.iMtm )&& entry.Unread() )
+ {
+ HandleNotif(iMceListView->ListContainer()->FolderEntry().iServiceId);
+
+ }
+
+ ui->BaseMtm().SetCurrentEntryL(iSession->GetEntryL(
+ iEntry->Entry().Id()));
+
+ CAknInputBlock::NewLC();
+ op = ui->DeleteFromL(*selection, singleOpWatcher->iStatus);
+ SetViewUpdateSuppressionFlag( ETrue, op );
+ CleanupStack::PopAndDestroy(); // CAknInputBlock
+ CleanupStack::PushL( op );
+ // if cancel was pressed then completed operation is returned with
+ // local service and status KErrCancel
+ if ( op->Service() == KMsvLocalServiceIndexEntryId &&
+ op->iStatus == KErrCancel )
+ {
+ resetSelection = EFalse;
+ SetViewUpdateSuppressionFlag( EFalse, NULL );
+ }
+ }
+ else
+ {
+ if ( iEntry->EntryId() == KMsvGlobalOutBoxIndexEntryId )
+ {
+ CMsvProgressReporterOperation* progOp =
+ CMsvProgressReporterOperation::NewL(
+ *iSession, singleOpWatcher->iStatus, EMbmAvkonQgn_note_erased );
+ CleanupStack::PushL( progOp );
+
+ CMsvOperation* subOp = CMceCancelSendingOperation::NewL(
+ *iSession,
+ progOp->RequestStatus(),
+ selection->At(0),
+ CMceCancelSendingOperation::ECancelAndDelete,
+ *iMtmStore );
+
+ progOp->SetOperationL(subOp); // this takes ownership immediately, so no cleanupstack needed.
+
+ HBufC* text = StringLoader::LoadLC(
+ R_MUIU_LOCAL_PROGRESS_DELETING_1,
+ iEikonEnv );
+ progOp->SetTitleL( *text );
+ CleanupStack::PopAndDestroy( text );
+ op = progOp;
+ }
+ else
+ {
+ // SMS and MMS deletion
+ if ( selection->Count() > KMceProgressReporterThreshold ||
+ type == KUidMsvFolderEntryValue )
+ {
+ // Show the progress note
+
+ CMsvProgressReporterOperation* progOp =
+ CMsvProgressReporterOperation::NewL(
+ *iSession, singleOpWatcher->iStatus, EMbmAvkonQgn_note_erased );
+
+ CleanupStack::PushL( progOp );
+
+ // deleting folder
+ HBufC* text = NULL;
+ iEntry->SetEntryL(id);
+
+ if( type == KUidMsvFolderEntryValue )
+ {
+ text = StringLoader::LoadLC( R_MCE_WAIT_DELETE_FOLDER,
+ iEntry->Entry().iDetails.Left( iBitmapResolver->DescriptionLength() ),
+ iEikonEnv );
+ }
+ else // if message
+ {
+ text = StringLoader::LoadLC(
+ R_MUIU_LOCAL_PROGRESS_DELETING_1,
+ iEikonEnv );
+ }
+ progOp->SetTitleL( *text );
+ CleanupStack::PopAndDestroy( text );
+ iEntry->SetEntryL( iEntry->Entry().Parent() );
+
+ CMsvOperation* subOp=iEntry->DeleteL(
+ *selection, progOp->RequestStatus() );
+ progOp->SetOperationL(subOp); // this takes ownership immediately, so no cleanup stack needed.
+ op = progOp;
+ }
+ else
+ {
+ // Do not show the progress note
+ iEntry->SetEntryL(id);
+ iEntry->SetEntryL( iEntry->Entry().Parent() );
+ op = iEntry->DeleteL( *selection, singleOpWatcher->iStatus );
+ CleanupStack::PushL( op );
+ }
+ }
+ }
+
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2, singleOpWatcher ); // singleOpWatcher, op
+ singleOpWatcher->SetOperation( op );
+ MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
+
+ if ( ui )
+ {
+ CleanupStack::PopAndDestroy( );// release mtmUi
+ }
+ if ( local )
+ {
+ // if deleting from service, then it is mtm's responsibility to free disk...
+ iDeleteOperation = singleOpWatcher;
+ MCELOGGER_WRITE_FORMAT("free disk requested, iDeleteOperation set 0x%x", iDeleteOperation );
+
+// Cancel the free disk space request to be added
+ }
+ CleanupStack::PopAndDestroy( selection );
+ if ( resetSelection )
+ {
+ iMceListView->ListContainer()->ClearSelection();
+ }
+ iMsgDeletedStatus = ETrue;
+ MCELOGGER_LEAVEFN("HandleDeleteL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::HandleUndeleteL
+// ----------------------------------------------------
+void CMceUi::HandleUndeleteL()
+ {
+ MCELOGGER_ENTERFN("HandleUndeleteL()");
+
+ __ASSERT_DEBUG( MceViewActive( EMceMessageViewActive ),
+ Panic( EMceUiErrCannotUnDeleteFromMainView ) );
+ if ( MceViewActive( EMceMainViewActive ) )
+ {
+ return;
+ }
+
+ CMsvEntrySelection* selection = iMceListView->ListContainer()
+ ->CurrentItemSelectionRefreshL();
+ CleanupStack::PushL( selection );
+
+ const TInt count = selection->Count();
+ __ASSERT_DEBUG( count != 0, Panic( EMceErrNothingToUnDelete ) );
+ if ( count == 0 )
+ {
+ CleanupStack::PopAndDestroy( selection );
+ return;
+ }
+
+ const TMsvId id = selection->At( 0 );
+ TBool resetSelection = ETrue;
+
+ TMsvEntry tentry;
+ GetEntryL( id, tentry );
+ TMsvEntry parentEntry;
+ GetEntryL( tentry.Parent(), parentEntry );
+
+ CBaseMtmUi& ui = iMtmStore->GetMtmUiAndSetContextLC( parentEntry );
+
+ CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL(singleOpWatcher);
+
+ CAknInputBlock::NewLC();
+ CMsvOperation* op = ui.UnDeleteFromL(*selection, singleOpWatcher->iStatus);
+ CleanupStack::PopAndDestroy(); // CAknInputBlock::NewLC()
+ CleanupStack::PushL( op );
+ // if cancel was pressed then completed operation is returned with
+ // local service and status KErrCancel
+ if ( op->Service() == KMsvLocalServiceIndexEntryId &&
+ op->iStatus == KErrCancel )
+ {
+ resetSelection = EFalse;
+ }
+
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2 ); // singleOpWatcher, op
+ singleOpWatcher->SetOperation( op );
+ MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
+
+ CleanupStack::PopAndDestroy( 2 );// release mtmUi, selection
+ if ( resetSelection )
+ {
+ iMceListView->ListContainer()->ClearSelection();
+ }
+ MCELOGGER_LEAVEFN("HandleUndeleteL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::MoveOrCopyEntriesL
+// ----------------------------------------------------
+void CMceUi::MoveOrCopyEntriesL( TBool aCopy )
+ {
+ TInt count;
+ TMsvId id;
+ TMsvId service;
+ TMsvEntry tEntry;
+ TBool mailMessage = EFalse;
+ if ( aCopy )
+ {
+ LeaveIfDiskSpaceUnderCriticalLevelL( iDiskSpaceForMoveOrCopy );
+ }
+ else
+ {
+ LeaveIfDiskSpaceUnderCriticalLevelL();
+ }
+
+ __ASSERT_DEBUG( MceViewActive( EMceMessageViewActive ),
+ Panic( EMceUiErrCannotMoveFromMainView ) );
+ if ( MceViewActive( EMceMainViewActive ) )
+ {
+ return;
+ }
+
+ const TMsvId sourceId = iMceListView->ListContainer()->CurrentFolderId();
+
+ CMsvEntrySelection * selection = iMceListView->ListContainer()
+ ->CurrentItemSelectionL();
+ CleanupStack::PushL( selection );
+
+ if ( !aCopy )
+ {
+ count = selection->Count();
+ // MMS notifications cannot be moved
+ for ( TInt cc = count; --cc >= 0; )
+ {
+ id = selection->At( cc );
+ if ( iSession->GetEntry( id, service, tEntry ) == KErrNone )
+ {
+ if ( tEntry.iMtm == KUidMsgMMSNotification )
+ {
+ selection->Delete( cc );
+ }
+ }
+ }
+ if ( selection->Count() < count )
+ {
+ // MMS notifications have been deleted from selection
+ CAknQueryDialog* note = CAknQueryDialog::NewL();
+ HBufC* text = NULL;
+ text = StringLoader::LoadLC( R_MMS_INFO_CANNOT_MOVE_NOTIF, CCoeEnv::Static() );
+ note->SetPromptL( *text );
+ CleanupStack::PopAndDestroy( text );
+ note->ExecuteLD( R_MCE_MEMC_NOTE );
+ }
+ }
+
+ // Email messages cannot be moved
+ iMoveOrCopyMailOperation = -1;
+ mailMessage = RemoveEmailMessagesFromSelection( selection );
+
+ if ( selection->Count() <= 0 )
+ {
+ CleanupStack::PopAndDestroy( selection );
+ if ( mailMessage )
+ {
+ InformationNoteCannotMoveCopyEMailL();
+ }
+ return;
+ }
+// Find an iAnchorId (=itemId) that should be focused after moving some items from the list
+ iMceListView->ListContainer()->SetAnchorItemIdL(
+ CMceMessageListContainerBase::EMessageListOperationGeneral );
+
+ TMsvId destinationId = sourceId;
+ const TInt titleResourceId = aCopy ?
+ R_MCE_COPY_MESSAGES :
+ R_MCE_MOVE_MESSAGES;
+ HBufC* text = StringLoader::LoadLC( titleResourceId, iEikonEnv );
+
+ const TInt iconId = aCopy ?
+ EMbmAvkonQgn_note_move :
+ EMbmAvkonQgn_note_copy;
+
+ if ( CMsgFolderSelectionDialog::SelectFolderL( destinationId, *text ) )
+ {
+ // Trap: NCNList cannot seperate New and Unread that comes to Inbox
+ // So when movning Unread msgs to Inbox, we need to change them to
+ // read, and then change them back after moving is completed
+ if ( destinationId == KMsvGlobalInBoxIndexEntryId )
+ {
+ HandleNewMsgToInboxL( ETrue, selection );
+ }
+
+ TMsvEntry srcEntry;
+ const TBool sourceIsRemote = KMsvLocalServiceIndexEntryId != GetEntryL( sourceId, srcEntry);
+
+ CMsvOperation* op=NULL;
+
+ CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( singleOpWatcher );
+
+ CAknInputBlock::NewLC();
+
+ TMsvId service = KMsvLocalServiceIndexEntryId;
+ TMsvEntry sourceServiceEntry;
+ User::LeaveIfError( iSession->GetEntry( srcEntry.iServiceId, service, sourceServiceEntry ) );
+
+ if ( ( sourceIsRemote && !( sourceServiceEntry.Connected() ) ) ||
+ ( sourceServiceEntry.iMtm == KSenduiMtmSyncMLEmailUid ) )
+ {
+ CBaseMtmUi& ui=iMtmStore->GetMtmUiAndSetContextLC( srcEntry );
+ op=ui.CopyFromL( *selection, destinationId, singleOpWatcher->iStatus);
+ CleanupStack::PopAndDestroy(); // release ui
+ }
+ else
+ {
+ CMsvProgressReporterOperation* progOp =
+ CMsvProgressReporterOperation::NewL( *iSession, singleOpWatcher->iStatus, iconId );
+ CleanupStack::PushL(progOp);
+ CMsvOperation* subOp = NULL;
+ iEntry->SetEntryL( sourceId );
+
+ if ( aCopy )
+ {
+ subOp = iEntry->CopyL( *selection, destinationId, progOp->RequestStatus());
+ }
+ else
+ {
+ subOp = iEntry->MoveL( *selection, destinationId, progOp->RequestStatus());
+ }
+
+ progOp->SetOperationL( subOp ); // this takes ownership immediately, so no cleanupstack needed.
+ op = progOp;
+ CleanupStack::Pop( progOp );
+ }
+
+ CleanupStack::PopAndDestroy(); // CAknInputBlock
+ CleanupStack::PushL( op );
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2 ); // singleOpWatcher, op
+ singleOpWatcher->SetOperation( op );
+ MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
+
+ if ( mailMessage )
+ {
+ // Mail messages cannot be copied or moved, save the command ID
+ iMoveOrCopyMailOperation = op->Id();
+ }
+
+ iMceListView->ListContainer()->ClearSelection();
+
+ } // end if
+ CleanupStack::PopAndDestroy( 2 ); // text, selection
+ }
+
+// ----------------------------------------------------
+// CMceUi::ActivateLocalViewL
+// ----------------------------------------------------
+void CMceUi::ActivateLocalViewL(TUid aViewId)
+ {
+ if ( aViewId == KMceMainViewListViewId )
+ {
+ iEditorOperation = NULL;
+ CAknTitlePane* title=TitlePaneL();
+ HBufC* text = StringLoader::LoadLC( R_MCE_MAIN_VIEW_TITLE, iEikonEnv );
+ title->SetTextL( *text );
+ CleanupStack::PopAndDestroy(); // text
+ }
+ CAknViewAppUi::ActivateLocalViewL( aViewId );
+ }
+
+// ----------------------------------------------------
+// CMceUi::CreateTabsL
+// ----------------------------------------------------
+void CMceUi::CreateTabsL()
+ {
+ MCELOGGER_ENTERFN("CreateTabsL()");
+ __ASSERT_DEBUG( !iTabsArray, Panic( EMceUiErrTabsArrayAlreadyExists ) );
+
+ delete iDecoratedTabGroup;
+ iDecoratedTabGroup = NULL;
+ iDecoratedTabGroup = iNaviPane->CreateTabGroupL( this );
+ iDecoratedTabGroup->SetControlType( CAknNavigationDecorator::ETabGroup );
+
+ CAknTabGroup* tabGroup = ( CAknTabGroup* ) iDecoratedTabGroup->DecoratedControl();
+
+ CMceMainViewListItemArray* array = iMceMainView->ListContainer()->ListItems();
+ TInt count = array->Count();
+ CMsvEntrySelection* tabsArray = new( ELeave ) CMsvEntrySelection();
+ CleanupStack::PushL( tabsArray );
+ TInt loop = 0;
+ for ( loop = 0; loop < count; loop++ )
+ {
+ const TMceListItem& listItem = (*array)[loop];
+ if ( !listItem.iExtraItem || listItem.iMsvId == KMceDeliveryReportsListIdValue )
+ {
+ if (( iEmailClientIntegration )&&(!iEmailFramework))
+ {
+ TMsvId service;
+ TMsvEntry entry;
+
+
+ CRepository* repository = NULL;
+ TInt mtmPluginID = 0;
+ TRAPD( ret, repository = CRepository::NewL(
+ KCRUidSelectableDefaultEmailSettings ) );
+
+ if ( ret == KErrNone )
+ {
+ // Get Email application mtm plugin ID
+ repository->Get( KIntegratedEmailAppMtmPluginId, mtmPluginID );
+ }
+ delete repository;
+ if ( iSession->GetEntry(listItem.iMsvId, service, entry) == KErrNone
+ && entry.iMtm.iUid != mtmPluginID)
+ {
+ tabsArray->AppendL( listItem.iMsvId );
+ }
+ else if(listItem.iMsvId == KMceDeliveryReportsListIdValue)
+ {
+ tabsArray->AppendL( listItem.iMsvId );
+ }
+ }
+ else
+ {
+ tabsArray->AppendL( listItem.iMsvId );
+ }
+
+ }
+ }
+ CleanupStack::Pop( tabsArray );
+ iTabsArray = tabsArray;
+
+ CFbsBitmap* bitmap;
+ CFbsBitmap* bitmapMask;
+
+ TAknsItemID id;
+ id.iMajor = 0;
+ id.iMinor = 0;
+
+ MAknsSkinInstance* skins = AknsUtils::SkinInstance();
+
+ count = iTabsArray->Count();
+ TInt bitmapIndex = EMbmMuiuQgn_prop_mce_inbox_tab4;
+ for ( loop = 0; loop < count; loop++ )
+ {
+ switch ( (*iTabsArray)[loop] )
+ {
+ case KMsvGlobalInBoxIndexEntryId:
+ bitmapIndex = EMbmMuiuQgn_prop_mce_inbox_tab4;
+ id = KAknsIIDQgnPropMceInboxTab4;
+ break;
+ case KMceDocumentsEntryId:
+ bitmapIndex = EMbmMuiuQgn_prop_mce_doc_tab4;
+ id = KAknsIIDQgnPropMceDocTab4;
+ break;
+ case KMsvDraftEntryId:
+ bitmapIndex = EMbmMuiuQgn_prop_mce_drafts_tab4;
+ id = KAknsIIDQgnPropMceDraftsTab4;
+ break;
+ case KMsvSentEntryId:
+ bitmapIndex = EMbmMuiuQgn_prop_mce_sent_tab4;
+ id = KAknsIIDQgnPropMceSentTab4;
+ break;
+ case KMsvGlobalOutBoxIndexEntryId:
+ bitmapIndex = EMbmMuiuQgn_prop_mce_outbox_tab4;
+ id = KAknsIIDQgnPropMceOutboxTab4;
+ break;
+ case KMceDeliveryReportsListIdValue:
+ bitmapIndex = EMbmMuiuQgn_prop_mce_dr_tab4;
+ id = KAknsIIDQgnPropMceDrTab4;
+ break;
+ default:
+ {
+ TMsvId service;
+ TMsvEntry entry;
+ if ( iSession->GetEntry( (*iTabsArray)[loop], service, entry) == KErrNone
+ && ( entry.iMtm == KSenduiMtmImap4Uid || entry.iMtm == KSenduiMtmPop3Uid )
+ && entry.Connected() )
+ {
+ bitmapIndex = EMbmMuiuQgn_prop_mce_remote_on_tab4;
+ id = KAknsIIDQgnPropMceRemoteOnTab4;
+ }
+ else
+ {
+ bitmapIndex = EMbmMuiuQgn_prop_mce_remote_tab4;
+ id = KAknsIIDQgnPropMceRemoteTab4;
+ }
+ }
+ break;
+ }
+
+ AknsUtils::CreateIconL( skins, id, bitmap,
+ bitmapMask, iFilename, bitmapIndex,
+ bitmapIndex + 1 );
+
+ tabGroup->AddTabL(
+ loop, bitmap, bitmapMask );
+ }
+
+ tabGroup->SetTabFixedWidthL(KTabWidthWithFourTabs);
+
+ MCELOGGER_LEAVEFN("CreateTabsL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::CheckRemoteMailboxTabIconsL
+// ----------------------------------------------------
+void CMceUi::CheckRemoteMailboxTabIconsL()
+ {
+ MCELOGGER_ENTERFN("CheckRemoteMailboxTabIconsL()");
+ __ASSERT_DEBUG( iMceUiFlags.MceFlag( EMceUiFlagsTabsActive ),
+ Panic( EMceUiErrTabsNotActivated ) );
+ __ASSERT_DEBUG( iTabsArray, Panic( EMceUiErrTabsArrayDoesNotAlreadyExist ) );
+ CAknTabGroup* tabGroup = ( CAknTabGroup* ) iDecoratedTabGroup->DecoratedControl();
+ const TInt count = iTabsArray->Count();
+ for ( TInt loop = 0; loop < count; loop++ )
+ {
+ TMsvId service;
+ TMsvEntry entry;
+ if ( iSession->GetEntry( (*iTabsArray)[loop], service, entry) == KErrNone )
+ {
+ TInt bitmapIndex = KErrNotFound;
+ TAknsItemID id;
+ id.iMajor = 0;
+ id.iMinor = 0;
+ if ( ( entry.iMtm == KSenduiMtmImap4Uid
+ || entry.iMtm == KSenduiMtmPop3Uid ) )
+ {
+ bitmapIndex = entry.Connected() ?
+ EMbmMuiuQgn_prop_mce_remote_on_tab4 : EMbmMuiuQgn_prop_mce_remote_tab4;
+ id = entry.Connected() ?
+ KAknsIIDQgnPropMceRemoteOnTab4 : KAknsIIDQgnPropMceRemoteTab4;
+ }
+ else if ( entry.iMtm == KSenduiMtmSyncMLEmailUid )
+ {
+ bitmapIndex = EMbmMuiuQgn_prop_sml_remote_tab4;
+ id = KAknsIIDQgnPropSmlRemoteTab4;
+ }
+
+ if ( bitmapIndex > KErrNotFound )
+ {
+ MAknsSkinInstance* skins = AknsUtils::SkinInstance();
+ CFbsBitmap* bitmap;
+ CFbsBitmap* bitmapMask;
+
+ AknsUtils::CreateIconL( skins, id, bitmap,
+ bitmapMask, iFilename, bitmapIndex, bitmapIndex + 1 );
+
+ tabGroup->ReplaceTabL(
+ loop, bitmap, bitmapMask );
+ }
+ }
+ }
+
+ MCELOGGER_LEAVEFN("CheckRemoteMailboxTabIconsL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::ShowTabsL
+// ----------------------------------------------------
+void CMceUi::ShowTabsL( TMsvId aOpenedId, TBool aOpeningDeliveryReports /* = EFalse */ )
+ {
+ MCELOGGER_ENTERFN("ShowTabsL()");
+
+ if ( !iDecoratedTabGroup )
+ {
+ CreateTabsL();
+ }
+
+ TInt selectedIndex;
+ if ( aOpeningDeliveryReports )
+ {
+ selectedIndex = iTabsArray->Find( KMceDeliveryReportsListIdValue );
+ }
+ else
+ {
+ selectedIndex = iTabsArray->Find( aOpenedId );
+ }
+
+ CAknTabGroup* tabGroup = ( CAknTabGroup* ) iDecoratedTabGroup->DecoratedControl();
+ tabGroup->SetActiveTabByIndex( selectedIndex );
+ iNaviPane->PushL(*iDecoratedTabGroup);
+ iMceUiFlags.SetMceFlag( EMceUiFlagsTabsActive );
+ CheckRemoteMailboxTabIconsL();
+ MCELOGGER_LEAVEFN("ShowTabsL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::RemoveTabs
+// ----------------------------------------------------
+void CMceUi::RemoveTabs()
+ {
+ MCELOGGER_ENTERFN("RemoveTabs()");
+ if ( iMceUiFlags.MceFlag( EMceUiFlagsTabsActive ) )
+ {
+ iNaviPane->Pop();
+ iMceUiFlags.ClearMceFlag( EMceUiFlagsTabsActive );
+ }
+ MCELOGGER_LEAVEFN("RemoveTabs()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::RemoveTabsAndUpdateArray
+// ----------------------------------------------------
+void CMceUi::RemoveTabsAndUpdateArray()
+ {
+ MCELOGGER_ENTERFN("RemoveTabsAndUpdateArray()");
+ TBool tabsActive = iMceUiFlags.MceFlag( EMceUiFlagsTabsActive );
+ RemoveTabs();
+ delete iDecoratedTabGroup;
+ iDecoratedTabGroup = NULL;
+ delete iTabsArray;
+ iTabsArray = NULL;
+
+ if ( tabsActive && MceViewActive( EMceMessageViewActive ) && iMceListView )
+ {
+ TRAP_IGNORE( ShowTabsL( iMceListView->ListContainer()->CurrentFolderId() ) );
+ }
+ MCELOGGER_LEAVEFN("RemoveTabsAndUpdateArray()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::CheckIAUpdate
+// ----------------------------------------------------
+void CMceUi::CheckIAUpdate()
+ {
+ iMceIAUpdate->StartL( TUid::Uid( KMceApplicationUidValue ) );
+ }
+
+// ----------------------------------------------------
+// CMceUi::GoOnlineWithQueryL
+// ----------------------------------------------------
+void CMceUi::GoOnlineWithQueryL( TMsvId aAccount )
+ {
+ if ( AlwaysOnlineLastConnectionL( aAccount ) )
+ {
+ CAknQueryDialog* confDialog = CAknQueryDialog::NewL();
+ if ( confDialog->ExecuteLD( R_MCE_GO_ONLINE_CONFIRMATION ) )
+ {
+ ChangeServiceConnectionStateL( aAccount, ETrue);
+ }
+ }
+ }
+
+// ----------------------------------------------------
+// CMceUi::GoOnlineL
+// ----------------------------------------------------
+void CMceUi::GoOnlineL( TMsvId aAccount )
+ {
+ MCELOGGER_ENTERFN("GoOnlineL()");
+ ChangeServiceConnectionStateL( aAccount, ETrue);
+ MCELOGGER_LEAVEFN("GoOnlineL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::CloseConnectionWithListQueryL
+// ----------------------------------------------------
+void CMceUi::CloseConnectionWithListQueryL()
+ {
+ CMsvEntrySelection* connectedAccounts = ConnectedServicesLC();
+ const TInt numberOfConnectedMailboxes = connectedAccounts->Count();
+ TInt closeConnection = KErrNotFound;
+
+ if ( numberOfConnectedMailboxes > 0 )
+ {
+ if ( numberOfConnectedMailboxes == 1 )
+ {
+ closeConnection = 0;
+ }
+ else
+ {
+ CDesCArrayFlat* items = new(ELeave)CDesCArrayFlat( KMceArrayGranularity );
+ CleanupStack::PushL( items );
+ for (TInt loop = 0; loop < numberOfConnectedMailboxes; loop++)
+ {
+ const TMsvEntry& tentry=iRootEntry->ChildDataL( connectedAccounts->At( loop ) );
+ items->AppendL( tentry.iDetails.Left( iBitmapResolver->DescriptionLength() ) );
+ }
+
+ CAknListQueryDialog* dlg = new (ELeave) CAknListQueryDialog(&closeConnection);
+ dlg->PrepareLC( R_MCE_LIST_QUERY );
+ dlg->SetItemTextArray( items );
+ dlg->SetOwnershipType( ELbmDoesNotOwnItemArray );
+ if( !dlg->RunLD() )
+ {
+ closeConnection = KErrNotFound;
+ }
+ CleanupStack::PopAndDestroy( items );
+ }
+
+ if ( closeConnection != KErrNotFound )
+ {
+ GoOfflineL( connectedAccounts->At( closeConnection ) );
+ }
+ }
+ CleanupStack::PopAndDestroy(); // connectedAccounts
+
+ }
+
+// ----------------------------------------------------
+// CMceUi::GoOfflineL
+// ----------------------------------------------------
+void CMceUi::GoOfflineL( TMsvId aAccount )
+ {
+ MCELOGGER_ENTERFN("GoOfflineL()");
+ TMsvEntry tentry;
+ GetEntryL( aAccount, tentry );
+ if ( tentry.Connected() )
+ {
+ ChangeServiceConnectionStateL( aAccount, EFalse );
+ }
+ MCELOGGER_LEAVEFN("GoOfflineL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::ChangeServiceConnectionStateL
+// ----------------------------------------------------
+void CMceUi::ChangeServiceConnectionStateL(TMsvId aServiceId, TBool aConnect)
+ {
+ MCELOGGER_ENTERFN("ChangeServiceConnectionStateL()");
+
+ if ( aConnect )
+ {
+ LeaveIfDiskSpaceUnderCriticalLevelL();
+ }
+
+ TMsvEntry tentry;
+ (void)GetEntryL(aServiceId, tentry);
+ CBaseMtmUi& ui = iMtmStore->GetMtmUiAndSetContextLC(tentry);
+ CMsvOperation* op;
+ CAknInputBlock::NewLC();
+
+ CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( singleOpWatcher );
+
+ if ( aConnect )
+ {
+ op = ui.OpenL( singleOpWatcher->iStatus );
+ if ( tentry.iMtm != KSenduiMtmImap4Uid )
+ {
+ SetViewUpdateSuppressionFlag( ETrue, op );
+ }
+ if ( iAlwaysOnline && op )
+ {
+ AddOperationIdL( op->Id(), aServiceId );
+ }
+ }
+ else
+ {
+ op = ui.CloseL( singleOpWatcher->iStatus );
+ if ( iAlwaysOnline && op )
+ {
+ RemoveOperationId( op->Id(), aServiceId );
+ }
+ }
+
+ CleanupStack::PushL( op );
+
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2 ); // singleOpWatcher, op
+ singleOpWatcher->SetOperation( op );
+ MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
+
+ CleanupStack::PopAndDestroy( 2 ); // CAknInputBlock, release mtmUi
+ if ( iMceListView->ListContainer() &&
+ ( MceViewActive(EMceMessageViewActive ) ) )
+ {
+ if ( aConnect )
+ {
+ iMceListView->ListContainer()->SetAnchorItemIdL(
+ CMceMessageListContainerBase::EMessageListOperationConnect );
+ }
+ else
+ {
+ iMceListView->ListContainer()->SetAnchorItemIdL(
+ CMceMessageListContainerBase::EMessageListOperationGeneral );
+ }
+ }
+
+ MCELOGGER_LEAVEFN("ChangeServiceConnectionStateL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::GetEntryL
+// ----------------------------------------------------
+TMsvId CMceUi::GetEntryL(TMsvId aId, TMsvEntry& aEntry) const
+ {
+ TMsvId service;
+ User::LeaveIfError(iSession->GetEntry(aId, service, aEntry));
+ return service;
+ }
+
+// ----------------------------------------------------
+// CMceUi::SendSelectionL
+// ----------------------------------------------------
+void CMceUi::SendSelectionL(CMsvEntrySelection* aSel)
+ {
+ CleanupStack::PushL(aSel);
+ CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::Pop( aSel );
+ CleanupStack::PushL( singleOpWatcher ); // guaranteed not to leave because of previous pop
+
+ CMsvOperation* op = CMceSendOperation::NewL(
+ *iSession, singleOpWatcher->iStatus, *iMtmStore, aSel );
+ // aSel will be deleted!
+
+ CleanupStack::PushL( op );
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2 ); // singleOpWatcher, op
+ singleOpWatcher->SetOperation( op );
+ MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
+ }
+
+// ----------------------------------------------------
+// CMceUi::SendNowL
+// ----------------------------------------------------
+void CMceUi::SendNowL()
+ {
+
+ CMsvEntrySelection * selection = iMceListView->ListContainer()
+ ->CurrentItemSelectionL();
+ if ( selection->Count() == 0 )
+ {
+ delete selection;
+ return;
+ }
+
+ CleanupStack::PushL( selection );
+
+ // if we are sending email just ignore offline checks
+ iEntry->SetEntryL( (*selection)[0] );
+ const TMsvEntry& entry = iEntry->Entry();
+
+ if ( entry.iMtm != KSenduiMtmSmtpUid &&
+ FeatureManager::FeatureSupported( KFeatureIdOfflineMode ))
+ {
+ // check if offline mode has been set
+ TInt offline = 1;
+
+ CRepository* repository = NULL;
+ TRAPD( ret, repository = CRepository::NewL(KCRUidCoreApplicationUIs) );
+ CleanupStack::PushL( repository );
+
+ if ( ret == KErrNone )
+ {
+ if ( repository->Get(KCoreAppUIsNetworkConnectionAllowed,offline) != KErrNone )
+ {
+ offline = 1;
+ }
+ }
+
+ CleanupStack::Pop( repository );
+ delete repository;
+
+ if ( !offline )
+ {
+ // offline mode has been set
+ HBufC* text = StringLoader::LoadLC( R_MCE_OFFLINE_NOT_POSSIBLE, CCoeEnv::Static() );
+ CAknInformationNote* note = new (ELeave) CAknInformationNote();
+ note->ExecuteLD(*text);
+ CleanupStack::PopAndDestroy(2); //text, selection
+ return;
+ }
+
+ }
+
+ CleanupStack::Pop( selection ); // this is because SendSelectionL pushes selection immediately
+ SendSelectionL( selection );
+ }
+
+// ----------------------------------------------------
+// CMceUi::CancelSendingL
+// ----------------------------------------------------
+void CMceUi::CancelSendingL()
+ {
+ CMsvEntrySelection * selection = iMceListView->ListContainer()
+ ->CurrentItemSelectionL();
+ CleanupStack::PushL( selection );
+
+ if ( selection->Count() == 0 ||
+ IsMessageSendingL( selection->At(0) ) )
+ {
+ CleanupStack::PopAndDestroy( selection );
+ return;
+ }
+
+ CMsvSingleOpWatcher* singleOpWatcher=CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( singleOpWatcher );
+
+ CMsvOperation* op = CMceCancelSendingOperation::NewL(
+ *iSession,
+ singleOpWatcher->iStatus,
+ selection->At( 0 ),
+ CMceCancelSendingOperation::ECancelOnly,
+ *iMtmStore );
+
+ CleanupStack::PushL( op );
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2 ); // singleOpWatcher, op
+ singleOpWatcher->SetOperation( op );
+ MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
+
+ CleanupStack::PopAndDestroy( selection );
+ }
+
+// ----------------------------------------------------
+// CMceUi::FetchNewL
+// ----------------------------------------------------
+void CMceUi::FetchNewL()
+ {
+ DoAsyncFunctionOnCurrentContextL( KMtmUiFunctionFetchNew );
+ iMceListView->ListContainer()->SetAnchorItemIdL(
+ CMceMessageListContainerBase::EMessageListOperationFetchNew );
+ }
+
+// ----------------------------------------------------
+// CMceUi::FetchSelectedL
+// ----------------------------------------------------
+void CMceUi::FetchSelectedL()
+ {
+ __ASSERT_DEBUG( MceViewActive( EMceMessageViewActive ),
+ Panic( EMceUiErrCannotFetchFromMainView ) );
+ if ( MceViewActive( EMceMainViewActive ) )
+ {
+ return;
+ }
+
+ CMsvEntrySelection* sel = iMceListView->ListContainer()
+ ->CurrentItemSelectionL();
+
+ if ( sel->Count() == 0 )
+ {
+ delete sel;
+ return;
+ }
+
+ CleanupStack::PushL( sel );
+
+ iMceListView->ListContainer()->SetAnchorItemIdL(
+ CMceMessageListContainerBase::EMessageListOperationFetchSelected );
+ DoAsyncFunctionOnCurrentContextL(KMtmUiFunctionFetchSelected, *sel);
+ CleanupStack::PopAndDestroy( sel );
+ }
+
+// ----------------------------------------------------
+// CMceUi::FetchAllL
+// ----------------------------------------------------
+void CMceUi::FetchAllL()
+ {
+ DoAsyncFunctionOnCurrentContextL(KMtmUiFunctionFetchAll);
+ iMceListView->ListContainer()->SetAnchorItemIdL(
+ CMceMessageListContainerBase::EMessageListOperationFetchSelected );
+ }
+
+// ----------------------------------------------------
+// CMceUi::DoAsyncFunctionOnCurrentContextL
+// ----------------------------------------------------
+void CMceUi::DoAsyncFunctionOnCurrentContextL(TInt aFunctionId)
+ {
+ CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection();
+ CleanupStack::PushL( sel );
+
+ DoAsyncFunctionOnCurrentContextL(aFunctionId, *sel);
+
+ CleanupStack::PopAndDestroy( sel );
+ }
+
+// ----------------------------------------------------
+// CMceUi::DoAsyncFunctionOnCurrentContextL
+// ----------------------------------------------------
+void CMceUi::DoAsyncFunctionOnCurrentContextL(TInt aFunctionId, CMsvEntrySelection& aSelection)
+ {
+ DoAsyncFunctionL(aFunctionId, aSelection, iMceListView->ListContainer()->FolderEntry());
+ }
+
+// ----------------------------------------------------
+// CMceUi::DoAsyncFunctionL
+// ----------------------------------------------------
+void CMceUi::DoAsyncFunctionL(TInt aFunctionId, const TMsvEntry& aContext)
+ {
+ CMsvEntrySelection* sel= new (ELeave) CMsvEntrySelection();
+ CleanupStack::PushL( sel );
+ DoAsyncFunctionL(aFunctionId, *sel, aContext);
+ CleanupStack::PopAndDestroy( sel );
+ }
+
+// ----------------------------------------------------
+// CMceUi::DoAsyncFunctionL
+// ----------------------------------------------------
+void CMceUi::DoAsyncFunctionL( TInt aFunctionId, CMsvEntrySelection& aSelection,
+ const TMsvEntry& aContext)
+ {
+ LeaveIfDiskSpaceUnderCriticalLevelL();
+
+ CBaseMtmUi& mtmUi = iMtmStore->GetMtmUiAndSetContextLC( aContext );
+
+ TBuf8<1> blankParams;
+ CMsvSingleOpWatcher* singleOpWatcher=CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( singleOpWatcher );
+
+ CMsvOperation* op = mtmUi.InvokeAsyncFunctionL( aFunctionId, aSelection,
+ singleOpWatcher->iStatus, blankParams );
+
+ if ( CheckTechnologyTypeFromMtm( KMailTechnologyTypeUid, aContext.iMtm ) &&
+ (aFunctionId == KMtmUiFunctionFetchNew ||
+ aFunctionId == KMtmUiFunctionFetchAll
+ ))
+ {
+ SetViewUpdateSuppressionFlag( ETrue, op );
+ }
+
+ if ( iAlwaysOnline && op )
+ {
+ TMsvEntry tEntry;
+ TMsvId serviceId;
+ User::LeaveIfError( iSession->GetEntry( aContext.iServiceId, serviceId, tEntry ) );
+ if ( !tEntry.Connected() )
+ {
+ AddOperationIdL( op->Id(), serviceId );
+ }
+ }
+
+ CleanupStack::PushL( op );
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2 ); // singleOpWatcher, op
+ singleOpWatcher->SetOperation( op );
+
+ if ( aFunctionId == KMtmUiFunctionFetchNew )
+ {
+ iFetchNewOperation = singleOpWatcher;
+ }
+
+ MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
+
+ CleanupStack::PopAndDestroy(); // release mtmUI
+ iMceListView->ListContainer()->ClearSelection();
+ }
+
+// ----------------------------------------------------
+// CMceUi::AddMTMFunctionsL
+// ----------------------------------------------------
+void CMceUi::AddMTMFunctionsL(CEikMenuPane& aMenuPane, TInt aMenuCommandId)
+ {
+ MCELOGGER_ENTERFN("AddMTMFunctionsL()");
+ TMsvEntry selectedEntry;
+ TBool foundSelectedEntry = GetCurrentEntryL( selectedEntry );
+ TMsvEntry openedEntry;
+ TBool foundOpenedEntry = GetCurrentEntryL( openedEntry, ETrue );
+
+ CEikMenuPaneItem::SData data;
+ data.iCascadeId=0;
+ data.iFlags=0;
+ TInt cc;
+ TInt sendCmd = EMceCmdFirstMTMFunction;
+ const TInt count = iMTMFunctionsArray->Count();
+ for ( cc = 0; cc < count; cc++ )
+ {
+ TMsgFunctionInfo& functionInfo = iMTMFunctionsArray->At(cc);
+ data.iText = functionInfo.iCaption;
+ data.iCommandId = sendCmd;
+ if ( functionInfo.iFlags & EMtudContextSpecific )
+ {
+ if ( ( foundSelectedEntry && !CheckCommandAvailableL( sendCmd, selectedEntry ) ) ||
+ ( foundOpenedEntry && !CheckCommandAvailableL( sendCmd, openedEntry ) )
+ )
+ {
+ if ( functionInfo.iFuncId == KMtmUiFunctionMessageInfo )
+ {
+ sendCmd++;
+ continue;
+ }
+
+ else if ( functionInfo.iFuncId == KMtmUiFunctionDeliveryStatus )
+ {
+ aMenuPane.AddMenuItemL( data, EMceCmdUndelete );
+ }
+
+ else if ( functionInfo.iFuncId == KMtmUiFunctionFetchMMS ) //MMS notification
+ {
+ aMenuPane.AddMenuItemL( data, EAknCmdOpen );
+ }
+
+ else if ( functionInfo.iFuncId == KMtmUiFunctionFetchSyncML ) //SyncML Retrieve
+ {
+ if ( selectedEntry.iMtm == KSenduiMtmSyncMLEmailUid )
+ {
+ aMenuPane.AddMenuItemL( data, EAknCmdOpen );
+ }
+ else
+ {
+ // nothing is added
+ }
+ }
+
+ else if ( functionInfo.iFuncId == KMtmUiFunctionMMBox )
+ {
+ aMenuPane.AddMenuItemL( data, EAknCmdOpen );
+ }
+
+ else
+ {
+ // Following comparison added to hide MCE's Mark as read/Unread
+ // as duplicate copy of same options was provided by Visto MTM
+ CCoeEnv* ownEikonEnvmak = CEikonEnv::Static();
+ HBufC* markasRead = ownEikonEnvmak->AllocReadResourceLC( R_QTN_MCE_MARKAS_READ );
+ TBufC<30> bufread(markasRead->Des());
+ HBufC* markasUnRead = ownEikonEnvmak->AllocReadResourceLC( R_QTN_MCE_MARKAS_UNREAD );
+ TBufC<30> bufUnread(markasUnRead->Des());
+ CleanupStack::PopAndDestroy(2); //markasUnRead, markasRead
+ if(functionInfo.iFuncId == KMtmUiFunctionMarkAsRead)
+ {
+ iMceListView->SetMarkReadUnread( ETrue );
+ }
+ aMenuPane.AddMenuItemL( data, aMenuCommandId );
+ }
+ }
+ }
+ else
+ {
+ if ( MceViewActive( EMceMainViewActive ) && !CheckMTMFunctionL( functionInfo, selectedEntry ) )
+ {
+ aMenuPane.AddMenuItemL( data, aMenuCommandId );
+ }
+ }
+ sendCmd++;
+ }
+ MCELOGGER_LEAVEFN("AddMTMFunctionsL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::CheckMTMFunctionL
+// ----------------------------------------------------
+TInt CMceUi::CheckMTMFunctionL( const TMsgFunctionInfo& aFunction, TMsvEntry& aEntryToCheck )
+ {
+ TInt functionAvailable = KErrNotFound;
+
+ CBaseMtmUiData* uiData = NULL;
+
+ if ( MceViewActive( EMceMainViewActive ) )
+ {
+ if ( !( aFunction.iFlags & EMtudContextSpecific ) )
+ {
+ uiData = GetMtmUiDataL( aFunction.iMtmUid );
+ if ( uiData )
+ {
+ functionAvailable = uiData->OperationSupportedL(aFunction.iFuncId, aEntryToCheck);
+ }
+ }
+ }
+ else
+ {
+ if ( aFunction.iMtmUid == aEntryToCheck.iMtm )
+ {
+ uiData = GetMtmUiDataL( aFunction.iMtmUid );
+ }
+
+ if ( aFunction.iFlags & EMtudContextSpecific )
+ {
+ if ( uiData )
+ {
+ functionAvailable =
+ uiData->OperationSupportedL(aFunction.iFuncId, aEntryToCheck);
+ }
+ }
+ else if ( aFunction.iFlags & EMtudRemoteOnly )
+ {
+ if ( uiData &&
+ aEntryToCheck.iMtm != KUidMsvLocalServiceMtm )
+ {
+ functionAvailable =
+ uiData->OperationSupportedL(aFunction.iFuncId, aEntryToCheck);
+ }
+ }
+ }
+
+ return functionAvailable;
+ }
+
+// ----------------------------------------------------
+// CMceUi::GetCurrentEntryL
+// ----------------------------------------------------
+TBool CMceUi::GetCurrentEntryL(TMsvEntry& aEntry, TBool aOpenedFolder /*= EFalse*/) const
+ {
+ MCELOGGER_ENTERFN("GetCurrentEntryL()");
+
+ TMsvId cursorId = KErrNotFound;
+
+ if ( MceViewActive( EMceMainViewActive ) )
+ {
+ cursorId = iMceMainView->ListContainer()->CurrentItemId();
+ }
+ else
+ {
+ if ( aOpenedFolder )
+ {
+ cursorId = iMceListView->ListContainer()->CurrentFolderId();
+ }
+ else
+ {
+ if ( iMceListView->ListContainer()->CurrentItemSelectionCount() == 1 )
+ {
+ CMsvEntrySelection* selection =
+ iMceListView->ListContainer()->CurrentItemSelectionL();
+ cursorId = selection->At(0);
+ delete selection;
+ }
+ else
+ {
+ cursorId = KErrNotFound;
+ }
+ }
+ }
+
+ if ( cursorId == KErrNotFound )
+ {
+ MCELOGGER_LEAVEFN("GetCurrentEntryL() selected entry not found");
+ return EFalse;
+ }
+
+ TMsvId service;
+ const TInt err = iSession->GetEntry(cursorId, service, aEntry);
+
+ if ( err != KErrNone && err != KErrNotFound )
+ {
+ User::Leave( err );
+ }
+
+ MCELOGGER_LEAVEFN("GetCurrentEntryL()");
+ return ( err == KErrNone );
+ }
+
+// ----------------------------------------------------
+// CMceUi::CheckCommandAvailableL
+// ----------------------------------------------------
+TInt CMceUi::CheckCommandAvailableL( TInt aCommand, TMsvEntry& aEntryToCheck )
+ {
+ TInt rid = 0; // command is available
+
+ const TBool remoteContext =
+ aEntryToCheck.iServiceId != KMsvLocalServiceIndexEntryId;
+
+ switch ( aCommand )
+ {
+ case EMceCmdUndelete:
+ if ( remoteContext )
+ {
+ CBaseMtmUiData* uiData = GetMtmUiDataL( aEntryToCheck.iMtm );
+ if ( !uiData || !uiData->CanUnDeleteFromEntryL(aEntryToCheck, rid) && !rid )
+ {
+ rid = KErrNotSupported;
+ }
+ }
+ break;
+
+ case EMceCmdReply:
+ {
+ CBaseMtmUiData* uiData = GetMtmUiDataL( aEntryToCheck.iMtm );
+ if ( !uiData || !uiData->CanReplyToEntryL(aEntryToCheck, rid) )
+ {
+ rid = KErrNotSupported;
+ }
+ else
+ {
+ if ( aEntryToCheck.iMtm == KSenduiMtmSmsUid || aEntryToCheck.iMtm == KSenduiMtmBioUid
+ || aEntryToCheck.iMtm == KSenduiMtmMmsUid || aEntryToCheck.iMtm == KSenduiMMSNotificationUid )
+ {
+ if ( !MceUtils::ValidPhoneNumberL( aEntryToCheck.Id(), *iSession ) )
+ {
+ rid = KErrNotSupported;
+ }
+ }
+
+ }
+ }
+ break;
+
+ case EMceCmdForward:
+ {
+ CBaseMtmUiData* uiData = GetMtmUiDataL( aEntryToCheck.iMtm );
+ if ( !uiData || !uiData->CanForwardEntryL( aEntryToCheck, rid ) )
+ {
+ rid = KErrNotSupported;
+ }
+ }
+ break;
+
+ default:
+ if (aCommand >= EMceCmdFirstMTMFunction)
+ {
+ rid = CheckMTMFunctionL(
+ iMTMFunctionsArray->At( aCommand-EMceCmdFirstMTMFunction ), aEntryToCheck );
+ }
+ else
+ {
+ rid = KErrNotSupported;
+ }
+ break;
+ };
+
+ return rid;
+ }
+
+// ----------------------------------------------------
+// CMceUi::CheckCommandAvailableL
+// ----------------------------------------------------
+TInt CMceUi::CheckCommandAvailableL( TInt aCommand, CMsvEntrySelection* aEntriesToCheck )
+ {
+ __ASSERT_DEBUG( aEntriesToCheck, Panic( EMceUiErrArrayEmpty ) );
+ TInt rid = 0; // command is available
+ if ( !aEntriesToCheck || aEntriesToCheck->Count() == 0 )
+ {
+#if defined(_DEBUG)
+ Panic(EMceUiErrArrayEmpty);
+#endif
+ return KErrNotSupported;
+ }
+
+ TMsvEntry entry;
+ TMsvId serviceId;
+ TMsvId id = (*aEntriesToCheck)[0];
+
+ if ( iSession->GetEntry( id, serviceId, entry ) != KErrNone )
+ {
+ return KErrNotSupported;
+ }
+
+ if (aCommand >= EMceCmdFirstMTMFunction)
+ {
+ rid = KErrNotSupported;
+ }
+ else if ( aCommand == EMceCmdUndelete )
+ {
+ if ( entry.iServiceId != KMsvLocalServiceIndexEntryId )
+ {
+ CBaseMtmUiData* uiData = GetMtmUiDataL( entry.iMtm );
+ TBool canUndelete = EFalse;
+ if ( uiData )
+ {
+ const TInt count = aEntriesToCheck->Count();
+ for ( TInt loop = 0; loop < count && !canUndelete; loop++ )
+ {
+ id = (*aEntriesToCheck)[loop];
+ if ( iSession->GetEntry( id, serviceId, entry ) == KErrNone &&
+ uiData->CanUnDeleteFromEntryL(entry, rid) )
+ {
+ canUndelete = ETrue;
+ }
+ }
+ }
+ rid = canUndelete;
+ }
+ else
+ {
+ rid = KErrNotSupported;
+ }
+ }
+
+ return rid;
+ }
+
+
+// ----------------------------------------------------
+// CMceUi::HandleMTMFunctionL
+// ----------------------------------------------------
+void CMceUi::HandleMTMFunctionL(const TMsgFunctionInfo& aFunction)
+ {
+ MCELOGGER_ENTERFN("HandleMTMFunctionL()");
+
+ CMsvEntrySelection* sel = NULL;
+ if ( MceViewActive( EMceMainViewActive ) )
+ {
+ sel = new ( ELeave ) CMsvEntrySelection();
+ CleanupStack::PushL( sel );
+ sel->AppendL( iMceMainView->ListContainer()->CurrentItemId() );
+ }
+ else
+ {
+ sel = iMceListView->ListContainer()->CurrentItemSelectionRefreshL();
+ CleanupStack::PushL( sel );
+ }
+
+
+ TMsvId contextId = KMsvNullIndexEntryId;
+ if ( aFunction.iFlags&EMtudContextSpecific )
+ {
+ if ( sel->Count() != 0 )
+ {
+ contextId = (*sel)[0];
+ TMsvId service;
+ TMsvEntry entry;
+ if ( iSession->GetEntry( contextId, service, entry) != KErrNone ||
+ entry.iMtm != aFunction.iMtmUid )
+ {
+ contextId = KMsvNullIndexEntryId;
+ }
+ }
+ if ( contextId == KMsvNullIndexEntryId )
+ {
+ CleanupStack::PopAndDestroy( sel );
+ return;
+ }
+ }
+
+ CAknInputBlock::NewLC();
+
+ CBaseMtmUi& mtmUi=iMtmStore->GetMtmUiLC(aFunction.iMtmUid);
+ CBaseMtm& mtm=mtmUi.BaseMtm();
+ if (aFunction.iFlags&EMtudContextSpecific)
+ {
+ if (mtm.HasContext())
+ {
+ mtm.SwitchCurrentEntryL(contextId);
+ }
+ else
+ {
+ CMsvEntry* centry=iSession->GetEntryL(contextId);
+ mtm.SetCurrentEntryL(centry);
+ }
+ }
+
+ TBool tabsToCleanupStack = EFalse;
+
+ if ( iMceUiFlags.MceFlag( EMceUiFlagsTabsActive )
+ && aFunction.iFuncId != KMtmUiFunctionMessageInfo )
+ {
+ // must remove tabs because if no mailboxes created then
+ // mailbox settings dialog is displayed and tabs should not be shown then.
+ RemoveTabs();
+ CleanupStack::PushL( TCleanupItem( ShowTabs, this ) );
+ tabsToCleanupStack = ETrue;
+ }
+
+ TBuf8<1> buf;
+ if (!(aFunction.iFlags&EMtudAsynchronous))
+ {
+ mtmUi.InvokeSyncFunctionL(aFunction.iFuncId, *sel, buf);
+ }
+ else
+ {
+ CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( singleOpWatcher );
+
+ CMsvOperation* op=mtmUi.InvokeAsyncFunctionL( aFunction.iFuncId, *sel,
+ singleOpWatcher->iStatus, buf );
+
+ if ( op )
+ {
+ CleanupStack::PushL( op );
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2 ); // singleOpWatcher, op
+ singleOpWatcher->SetOperation( op );
+ MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy( singleOpWatcher );
+ }
+ }
+
+ if ( tabsToCleanupStack )
+ {
+ CleanupStack::PopAndDestroy(); // TCleanupItem - will show tabs again
+ }
+
+ CleanupStack::PopAndDestroy(3, sel);// sel, CAknInputBlock, release mtmUi
+
+ MCELOGGER_LEAVEFN("HandleMTMFunctionL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::SetMceViewActive
+// ----------------------------------------------------
+void CMceUi::SetMceViewActive( TUint aActiveView )
+ {
+ iMceActiveView = aActiveView;
+ if ( aActiveView & EMceDeliveryReportsViewActive )
+ {
+ iMceMainView->SetDeliveryReportsSelected();
+ }
+ }
+
+// ----------------------------------------------------
+// CMceUi::MceViewActive
+// ----------------------------------------------------
+TBool CMceUi::MceViewActive( TInt aActiveView ) const
+ {
+ return iMceActiveView & aActiveView;
+ }
+
+// ----------------------------------------------------
+// CMceUi::MoveFromOutboxToDraftsL
+// ----------------------------------------------------
+void CMceUi::MoveFromOutboxToDraftsL()
+ {
+ MCELOGGER_ENTERFN("MoveFromOutboxToDraftsL()");
+ __ASSERT_DEBUG( MceViewActive( EMceMessageViewActive ),
+ Panic( EMceUiErrCannotMoveFromMainView ) );
+
+ LeaveIfDiskSpaceUnderCriticalLevelL();
+
+ CMsvEntrySelection* selection = iMceListView->ListContainer()
+ ->CurrentItemSelectionL();
+ CleanupStack::PushL( selection );
+
+
+ if ( selection->Count() == 0 ||
+ IsMessageSendingL( selection->At(0) ) )
+ {
+ CleanupStack::PopAndDestroy( selection );
+ MCELOGGER_LEAVEFN("MoveFromOutboxToDraftsL1()");
+ return;
+ }
+
+ CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( singleOpWatcher );
+ CAknInputBlock::NewLC();
+
+ CMsvProgressReporterOperation* op =
+ CMsvProgressReporterOperation::NewL(
+ *iSession, singleOpWatcher->iStatus, EMbmAvkonQgn_note_move );
+ CleanupStack::PushL( op );
+
+ CMsvOperation* subOp = CMceCancelSendingOperation::NewL(
+ *iSession,
+ op->RequestStatus(),
+ selection->At(0),
+ CMceCancelSendingOperation::ECancelAndMoveToDrafts,
+ *iMtmStore );
+
+ op->SetOperationL(subOp); // this takes ownership immediately, so no cleanupstack needed.
+
+ HBufC* text = StringLoader::LoadLC(
+ R_MUIU_LOCAL_PROGRESS_MOVING_1,
+ iEikonEnv );
+ op->SetTitleL( *text );
+ CleanupStack::PopAndDestroy( text );
+ CleanupStack::Pop( op );
+ singleOpWatcher->SetOperation( op );
+ CleanupStack::PopAndDestroy(); // CAknInputBlock
+ CleanupStack::PushL( op );
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop(2, singleOpWatcher); // singleOpWatcher, op
+
+
+ MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
+ iMceListView->ListContainer()->ClearSelection();
+ CleanupStack::PopAndDestroy( selection );
+ MCELOGGER_LEAVEFN("MoveFromOutboxToDraftsL2()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::ForceMtmLoaderFinish
+// ----------------------------------------------------
+void CMceUi::ForceMtmLoaderFinish()
+ {
+ MCELOGGER_ENTERFN("ForceMtmLoaderFinish()");
+ if ( iMtmLoader )
+ {
+ TRAP_IGNORE(iMtmLoader->FinishL(iAudioMsgEnabled, iPostcardEnabled)); // CR : 401-1806
+ delete iMtmLoader;
+ iMtmLoader = NULL;
+ }
+ MCELOGGER_LEAVEFN("ForceMtmLoaderFinish()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::GoOfflineSynchronouslyL
+// ----------------------------------------------------
+void CMceUi::GoOfflineSynchronouslyL( TMsvId aAccount )
+ {
+ MCELOGGER_ENTERFN("GoOfflineSynchronouslyL()");
+ TMsvEntry tentry;
+ (void)GetEntryL(aAccount, tentry);
+
+ if ( iAlwaysOnline && ( tentry.iMtm == KSenduiMtmImap4Uid
+ || tentry.iMtm == KSenduiMtmPop3Uid ) )
+ {
+ if ( !ServiceIdFound( tentry.Id()) )
+ {
+ // do not close always online connection
+ return;
+ }
+ }
+
+ CBaseMtmUi& ui=iMtmStore->GetMtmUiAndSetContextLC(tentry);
+ CAknInputBlock::NewLC();
+
+ CMuiuOperationWait* wait =
+ CMuiuOperationWait::NewLC(EActivePriorityWsEvents+10);
+ CMsvOperation* op=ui.CloseL(wait->iStatus);
+ wait->Start();
+ CleanupStack::PopAndDestroy( wait );
+ delete op;
+ CleanupStack::PopAndDestroy( 2 ); // CAknInputBlock, release mtmui
+ MCELOGGER_LEAVEFN("GoOfflineSynchronouslyL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::IsEditorOpen
+// ----------------------------------------------------
+TBool CMceUi::IsEditorOpen( ) const
+ {
+ return ( iEditorOperation ? ETrue : EFalse );
+ }
+
+// ----------------------------------------------------
+// CMceUi::LeaveIfDiskSpaceUnderCriticalLevelL
+// Static function.
+// Used in CreateNewMessageL as TCleanupItem.
+// ----------------------------------------------------
+void CMceUi::LeaveIfDiskSpaceUnderCriticalLevelL( TInt aBytesToWrite )
+ {
+ MCELOGGER_WRITE_FORMAT("LeaveIfDiskSpaceUnderCriticalLevelL: %d", aBytesToWrite );
+
+
+ if ( iMceUiFlags.MceFlag( EMceUiFlagsMediaUnavailable ) )
+ {
+ MCELOGGER_WRITE("LeaveIfDiskSpaceUnderCriticalLevelL: media unavailable, leave");
+ User::Leave( KMsvIndexBackup );
+ }
+
+ if ( MsvUiServiceUtilities::DiskSpaceBelowCriticalLevelL(*iSession, aBytesToWrite) )
+ {
+ User::Leave( KErrDiskFull );
+ }
+ MCELOGGER_WRITE("LeaveIfDiskSpaceUnderCriticalLevelL: OK to proceed");
+ }
+
+// ----------------------------------------------------
+// CMceUi::CancelFreeDiskSpaceRequest
+// Static function.
+// Used in CreateNewMessageL as TCleanupItem.
+// ----------------------------------------------------
+void CMceUi::CancelFreeDiskSpaceRequest(TAny* /*aAny*/)
+ {
+ MCELOGGER_ENTERFN("CancelFreeDiskSpaceRequest()");
+
+// Cancel the free disk space request to be added
+
+ MCELOGGER_LEAVEFN("CancelFreeDiskSpaceRequest()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::TitlePaneL
+// Returns mce ui's title pane
+// ----------------------------------------------------
+CAknTitlePane* CMceUi::TitlePaneL() const
+ {
+ return (CAknTitlePane *)(iEikonEnv->AppUiFactory(*this))->StatusPane()->ControlL(
+ TUid::Uid(EEikStatusPaneUidTitle));
+ }
+
+// ----------------------------------------------------
+// CMceUi::IsMessageSendingL
+//
+// ----------------------------------------------------
+TBool CMceUi::IsMessageSendingL( TMsvId aEntryId ) const
+ {
+ MCELOGGER_ENTERFN("IsMessageSendingL()");
+ MCELOGGER_WRITE_FORMAT( "Check entry 0x%x", aEntryId );
+
+ TBool sending = EFalse;
+ iEntry->SetEntryL( aEntryId );
+ const TMsvEntry& entry = iEntry->Entry();
+ if ( entry.Parent() == KMsvGlobalOutBoxIndexEntryId &&
+ entry.SendingState() == KMsvSendStateSending &&
+ ( entry.iMtm == KSenduiMtmSmsUid ||
+ entry.iMtm == KSenduiMtmMmsUid )
+ )
+ {
+ sending = ETrue;
+ }
+ MCELOGGER_WRITE_FORMAT( "Entry sending: %d", sending);
+ MCELOGGER_LEAVEFN("IsMessageSendingL()");
+ return sending;
+ }
+
+// ----------------------------------------------------
+// CMceUi::ActivateConnectionQueryTimerL
+//
+// ----------------------------------------------------
+void CMceUi::ActivateConnectionQueryTimerL( TMsvId aEntryId )
+ {
+ MCELOGGER_ENTERFN("ActivateConnectionQueryTimerL()");
+ if ( !iConnectMailboxTimer )
+ {
+ iConnectMailboxTimer = CMceConnectMailboxTimer::NewL( *this );
+ }
+
+ TMsvEntry tentry;
+ TMsvId serviceId = GetEntryL( aEntryId, tentry );
+ if ( tentry.iMtm != KSenduiMtmImap4Uid &&
+ tentry.iMtm != KSenduiMtmPop3Uid )
+ {
+ // not mailbox, do nothing.
+ return;
+ }
+
+ if ( serviceId != aEntryId )
+ {
+ // lets find out that service...
+ GetEntryL( serviceId, tentry );
+ }
+ if ( !tentry.Connected() )
+ {
+ // this cancels possible old timer
+ iConnectMailboxTimer->SetTimer( serviceId );
+ }
+ MCELOGGER_LEAVEFN("ActivateConnectionQueryTimerL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::ReplyL
+//
+// ----------------------------------------------------
+void CMceUi::ReplyL(TInt /*aReplyCommand*/)
+ {
+ MCELOGGER_ENTERFN("ReplyL()");
+ LeaveIfDiskSpaceUnderCriticalLevelL( iDiskSpaceForMoveOrCopy );
+
+ if ( MceViewActive( EMceMainViewActive ) )
+ {
+ return;
+ }
+
+ CMsvEntrySelection * selection = iMceListView->ListContainer()->CurrentItemSelectionL();
+ CleanupStack::PushL( selection );
+ if ( selection->Count() <= 0)
+ {
+ CleanupStack::PopAndDestroy( selection );
+ return;
+ }
+
+ TMsvEntry entry;
+ TMsvId serviceId;
+ User::LeaveIfError( iSession->GetEntry(selection->At(0),serviceId,entry) ); // original message?
+
+ // NCN reset, received mail has been replied before opening it
+ if ( ((entry.iMtm == KSenduiMtmImap4Uid)
+ || (entry.iMtm == KSenduiMtmPop3Uid)
+ || (entry.iMtm == KSenduiMtmSyncMLEmailUid)
+ || CheckTechnologyTypeFromMtm( KMailTechnologyTypeUid, entry.iMtm ))
+ && entry.Unread() )
+ {
+
+ HandleNotif(iMceListView->ListContainer()->FolderEntry().iServiceId);
+
+ }
+
+ CleanupStack::PopAndDestroy( selection );
+
+ TMsvPartList parts=KMsvMessagePartBody|KMsvMessagePartOriginator|KMsvMessagePartDescription;
+
+ // Mark local entry as read before replying, remote entries should be handled by mtm ui
+ if ( entry.Unread() && entry.iServiceId == KMsvLocalServiceIndexEntryId )
+ {
+ iEntry->SetEntryL( entry.Id() );
+ TMsvEntry entry = iEntry->Entry();
+ entry.SetUnread( EFalse );
+ iEntry->ChangeL( entry );
+ }
+
+ if ( entry.iBioType == KMsgBioUidPictureMsg.iUid)
+ {
+ //picture message
+ TMsvId origMsgId = entry.Id();
+
+ // Change the MTM type of msg temporarily
+
+ CMsvEntry* cEntry = iSession->GetEntryL( origMsgId );
+ CleanupStack::PushL( cEntry );
+ TMsvEntry tentry( cEntry->Entry() );
+ const TUid origMtmUid = tentry.iMtm;
+ tentry.iMtm = KSenduiMtmSmsUid;
+
+ // Create registry instances
+ CClientMtmRegistry* mtmReg = CClientMtmRegistry::NewL( *iSession );
+ CleanupStack::PushL(mtmReg);
+ CMtmUiRegistry* mtmUiReg = CMtmUiRegistry::NewL( *iSession );
+ CleanupStack::PushL(mtmUiReg);
+
+ // Create the SMS MTM
+ CBaseMtm* mtm = mtmReg->NewMtmL( KSenduiMtmSmsUid );
+ CleanupStack::PushL(mtm);
+ CBaseMtmUi* mtmUi = mtmUiReg->NewMtmUiL( *mtm );
+ CleanupStack::PushL(mtmUi);
+
+ // Trap errors, so we can try to restore the original MTM Uid
+
+ TRAPD(err,
+ {
+
+ cEntry->ChangeL( tentry );
+
+ // Set its context
+ mtm->SwitchCurrentEntryL( origMsgId );
+
+ mtmUi->SetPreferences( mtmUi->Preferences() | EMtmUiFlagEditorPreferEmbedded );
+ CAknInputBlock::NewLC();
+
+ CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( singleOpWatcher );
+
+ CMsvOperation* oper = mtmUi->ReplyL(
+ KMsvDraftEntryIdValue, parts, singleOpWatcher->iStatus );
+
+ CleanupStack::PushL( oper );
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2, singleOpWatcher ); // oper
+ singleOpWatcher->SetOperation( oper );
+ CleanupStack::PopAndDestroy( ); // CAknInputBlock
+
+ });
+
+ // Restore original Mtm Uid
+ tentry = cEntry->Entry();
+ tentry.iMtm = origMtmUid;
+ cEntry->ChangeL(tentry);
+ mtm->SwitchCurrentEntryL( origMsgId );
+
+ User::LeaveIfError(err);
+ CleanupStack::PopAndDestroy( 5 ); // mtmUi, mtmReg, mtmUiReg, mtm, cEntry
+ }
+
+ else
+ {
+ CBaseMtmUi& ui = iMtmStore->GetMtmUiAndSetContextLC( entry );
+ ui.SetPreferences( ui.Preferences() | EMtmUiFlagEditorPreferEmbedded );
+ CAknInputBlock::NewLC();
+ CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( singleOpWatcher );
+
+ CMsvOperation* oper = ui.ReplyL(
+ KMsvDraftEntryIdValue, parts, singleOpWatcher->iStatus );
+
+ CleanupStack::PushL( oper );
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2, singleOpWatcher ); // oper
+ singleOpWatcher->SetOperation( oper );
+ MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", oper->Id() );
+ CleanupStack::PopAndDestroy( 2 ); // CAknInputBlock, ui
+ }
+ MCELOGGER_LEAVEFN("ReplyL()");
+
+ }
+
+// ----------------------------------------------------
+// CMceUi::MarkAsReadL
+// ----------------------------------------------------
+void CMceUi::MarkAsReadL( TBool aRead )
+ {
+ MCELOGGER_ENTERFN("MarkAsReadL()");
+ CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL(singleOpWatcher);
+
+ CMsvEntrySelection* sel = iMceListView->ListContainer()
+ ->CurrentItemSelectionL();
+ CleanupStack::PushL( sel );
+
+ if ( sel->Count() <= 0 )
+ {
+ CleanupStack::PopAndDestroy( 2 ); // singleOpWatcher, sel
+ return;
+ }
+
+ TMsvId serviceId;
+ TMsvEntry entry;
+ User::LeaveIfError( iSession->GetEntry( sel->At(0), serviceId, entry ) );
+ CBaseMtmUi& mtmUi = iMtmStore->GetMtmUiLC( entry.iMtm );
+ mtmUi.SetPreferences( mtmUi.Preferences() | EMtmUiFlagEditorPreferEmbedded );
+ CleanupStack::PopAndDestroy( ); // mtmUi
+
+ CMsvProgressReporterOperation* op =
+ CMsvProgressReporterOperation::NewL(
+ *iSession, singleOpWatcher->iStatus );
+ CleanupStack::PushL( op );
+ HBufC* text = StringLoader::LoadLC( R_MCE_MARK_AS_READ_PROGRESS, iEikonEnv );
+ op->SetTitleL( *text );
+ CleanupStack::PopAndDestroy( text );
+
+ // Determine the action for unread flag
+ TInt type =
+ aRead ? CMceRemoveNewFlag::EMceRemoveEntryFlagUnread :
+ CMceRemoveNewFlag::EMceRemoveEntryFlagNew;
+ CMceRemoveNewFlag* subOp = CMceRemoveNewFlag::NewL(
+ type, *iSession, op->RequestStatus(), sel );
+
+ op->SetOperationL( subOp ); // this takes ownership immediately, so no cleanupstack needed.
+ op->SetProgressDecoder( *subOp );
+ CleanupStack::Pop( op );
+
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2, singleOpWatcher ); // singleOpWatcher, sel
+ singleOpWatcher->SetOperation( op );
+ iMceListView->ListContainer()->ClearSelection();
+ if ( CheckTechnologyTypeFromMtm( KMailTechnologyTypeUid, entry.iMtm )&& aRead )
+ {
+ HandleNotif(iMceListView->ListContainer()->FolderEntry().iServiceId);
+ }
+ MCELOGGER_WRITE_FORMAT( "iOperations.AppendL(%d)", op->Id() );
+ MCELOGGER_LEAVEFN("MarkAsReadL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::TabChangedL
+//
+// ----------------------------------------------------
+void CMceUi::TabChangedL(TInt aIndex)
+ {
+ TBool bOBoxOrMBox = EFalse ;
+ if ( !MceViewActive( EMceMessageViewActive )
+ && !MceViewActive( EMceDeliveryReportsViewActive ) )
+ {
+ return;
+ }
+ TInt count = iTabsArray->Count();
+ TMsvId newId = KMsvGlobalInBoxIndexEntryId;
+ if ( aIndex < count )
+ {
+ newId = (*iTabsArray)[aIndex];
+ }
+
+ CancelMailboxTimer();
+
+ if ( MceViewActive( EMceDeliveryReportsViewActive ) )
+ {
+ OpenFolderViewL( newId );
+ }
+ else if ( !MceViewActive( EMceDeliveryReportsViewActive )
+ && newId == KMceDeliveryReportsListIdValue )
+ {
+ // activate delivery reports view
+ ActivateLocalViewL( KMceDeliveryReportViewId );
+ }
+ else
+ {
+ TBool bIsFromMailbox = EFalse ;
+ TBool bIsToMailbox = EFalse ;
+ TUid mtm = iMceListView->ListContainer()->FolderEntry().iMtm ;
+ bIsFromMailbox = CheckTechnologyTypeFromMtm( KMailTechnologyTypeUid, mtm );
+
+ TMsvEntry currentEntry;
+ TMsvId serviceId; // not used here but needed by GetEntry function
+ if ( iSession->GetEntry( newId, serviceId, currentEntry )
+ == KErrNone )
+ {
+ bIsToMailbox = CheckTechnologyTypeFromMtm( KMailTechnologyTypeUid, currentEntry.iMtm );
+ }
+
+ TMsvId oldId = iMceListView->ListContainer()->FolderEntry().Id();
+ if (oldId == KMsvGlobalOutBoxIndexEntryId || newId == KMsvGlobalOutBoxIndexEntryId
+ || bIsFromMailbox || bIsToMailbox)
+ {
+ if (bIsFromMailbox || bIsToMailbox ||
+ oldId == KMsvGlobalOutBoxIndexEntryId || iMceListView->ListContainer()->MceListId() != EMceListTypeTwoRow)
+ {
+ bOBoxOrMBox = ETrue ;
+ iLocalScreenClearer = CAknLocalScreenClearer::NewL( EFalse );
+ }
+ }
+ iMceListView->ChangeFolderAndRefreshListboxL( newId );
+ }
+
+ if (bOBoxOrMBox)
+ {
+ delete iLocalScreenClearer;
+ iLocalScreenClearer = NULL;
+ }
+ }
+
+// ----------------------------------------------------
+// CMceUi::IsPresent
+// ----------------------------------------------------
+TBool CMceUi::IsPresent( TUid aMtm ) const
+ {
+ return iUiRegistry->IsPresent( aMtm );
+ }
+
+// ----------------------------------------------------
+// CMceUi::ClearExitAfterDisconnectFlag
+//
+// ----------------------------------------------------
+void CMceUi::ClearExitAfterDisconnectFlag( )
+ {
+ iMceUiFlags.ClearMceFlag( EMceUiFlagsExitAfterDisconnect );
+ }
+
+// ----------------------------------------------------
+// CMceUi::SetDontExitOnNextOperationComplete
+//
+// ----------------------------------------------------
+void CMceUi::SetDontExitOnNextOperationComplete( )
+ {
+ MCELOGGER_WRITE("CMceUi::SetDontExitOnNextOperationComplete");
+ iMceUiFlags.SetMceFlag( EMceUiFlagsDoNotExitAfterNextOperationComplete );
+ if ( iCancelExitFlagOperation && !( iCancelExitFlagOperation->IsActive() ) )
+ {
+ iCancelExitFlagOperation->Start(
+ TCallBack( ClearDontExitOnNextOperationComplete, this ) );
+ }
+ }
+
+// ----------------------------------------------------
+// CMceUi::ClearDontExitOnNextOperationComplete
+//
+// ----------------------------------------------------
+void CMceUi::ClearDontExitOnNextOperationComplete( )
+ {
+ MCELOGGER_WRITE("CMceUi::ClearDontExitOnNextOperationComplete");
+ iMceUiFlags.ClearMceFlag( EMceUiFlagsDoNotExitAfterNextOperationComplete );
+ }
+
+// ----------------------------------------------------
+// CMceUi::ClearDontExitOnNextOperationComplete
+//
+// ----------------------------------------------------
+TInt CMceUi::ClearDontExitOnNextOperationComplete( TAny* aSelf )
+ {
+ reinterpret_cast<CMceUi*>(aSelf)->ClearDontExitOnNextOperationComplete();
+ return KErrNone;
+ }
+
+// ----------------------------------------------------
+// CMceUi::SyncMlNewMessageItemL
+// ----------------------------------------------------
+void CMceUi::SyncMlNewMessageItemL( const CMsvEntrySelection* aSelection, TInt aEvent )
+ {
+ TMsvId serviceId;
+ TMsvEntry entry;
+ if ( aEvent == EMsvEntriesCreated )
+ {
+ if ( iSession->GetEntry( aSelection->At(0), serviceId, entry ) == KErrNone )
+ {
+ if ( entry.iMtm == KSenduiMtmSyncMLEmailUid )
+ {
+ HandleMTMChangeL();
+ }
+ }
+ }
+ else
+ {
+ if ( aEvent == EMsvEntriesDeleted )
+ {
+ CMsvEntrySelection* sel=iRootEntry->ChildrenWithTypeL( KUidMsvServiceEntry );
+ CleanupStack::PushL( sel );
+ const TMsvEntry* tentry=NULL;
+ TInt syncMl = 0;
+ for ( TInt cc=sel->Count(); --cc>=0 && !syncMl; )
+ {
+ tentry=&(iRootEntry->ChildDataL((*sel)[cc]));
+ if ( tentry->iMtm == KSenduiMtmSyncMLEmailUid )
+ {
+ syncMl++;
+ }
+ }
+ if ( !syncMl )
+ {
+ HandleMTMChangeL();
+ }
+
+ CleanupStack::PopAndDestroy( sel );
+ }
+ }
+ }
+
+// ----------------------------------------------------
+// CMceUi::SyncMlMoveFromOutboxToDraftsL
+// ----------------------------------------------------
+void CMceUi::SyncMlMoveFromOutboxToDraftsL( )
+ {
+ LeaveIfDiskSpaceUnderCriticalLevelL( iDiskSpaceForMoveOrCopy );
+
+ __ASSERT_DEBUG( MceViewActive( EMceMessageViewActive ),
+ Panic( EMceUiErrCannotMoveFromMainView ) );
+ if ( MceViewActive( EMceMainViewActive ) )
+ {
+ return;
+ }
+
+ const TMsvId sourceId = iMceListView->ListContainer()->CurrentFolderId();
+ TMsvEntry srcEntry;
+ GetEntryL( sourceId, srcEntry );
+
+ CMsvEntrySelection * selection = iMceListView->ListContainer()
+ ->CurrentItemSelectionL();
+ CleanupStack::PushL( selection );
+
+ if ( selection->Count() <= 0 )
+ {
+ CleanupStack::PopAndDestroy( selection );
+ return;
+ }
+
+ CMsvOperation* op=NULL;
+
+ CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( singleOpWatcher );
+
+ CAknInputBlock::NewLC();
+
+ CBaseMtmUi& ui=iMtmStore->GetMtmUiAndSetContextLC( srcEntry );
+ op=ui.MoveFromL( *selection, KMsvDraftEntryId, singleOpWatcher->iStatus );
+ CleanupStack::PopAndDestroy(); // release ui
+
+ CleanupStack::PopAndDestroy(); // CAknInputBlock::NewLC()
+ CleanupStack::PushL(op);
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2 ); // singleOpWatcher, op
+ singleOpWatcher->SetOperation( op );
+
+ iMceListView->ListContainer()->ClearSelection();
+ CleanupStack::PopAndDestroy( selection );
+ }
+
+// ----------------------------------------------------
+// CMceUi::MtmName
+//
+// ----------------------------------------------------
+THumanReadableName CMceUi::MtmName( TUid aMtm ) const
+ {
+ THumanReadableName data;
+ const TInt count = iMsgTypesSettings.Count();
+ for ( TInt cc = 0; cc < count; cc++ )
+ {
+ TUidNameInfo info = iMsgTypesSettings.At(cc);
+ if ( info.iUid == aMtm )
+ {
+ data = info.iName;
+ }
+ }
+ return data;
+ }
+
+// ----------------------------------------------------
+// CMceUi::SetChangeMessageStore
+//
+// ----------------------------------------------------
+void CMceUi::SetChangeMessageStore( TBool aChangeEnded )
+ {
+ if ( aChangeEnded )
+ {
+ iMceUiFlags.SetMceFlag( EMceUiFlagsExitOnMsvMediaAvailableEvent );
+ }
+ else
+ {
+ iMceUiFlags.ClearMceFlag( EMceUiFlagsExitOnMsvMediaAvailableEvent );
+ }
+ }
+
+
+// ----------------------------------------------------
+// CMceUi::IsSyncronizingL
+//
+// ----------------------------------------------------
+TBool CMceUi::IsSyncronizingL( const TMsvEntry& entry )
+ {
+ TBool isSyncronizing = EFalse;
+
+ if ( IsPresent( KSenduiMtmSyncMLEmailUid ) &&
+ entry.iMtm == KSenduiMtmSyncMLEmailUid )
+ {
+ CBaseMtmUiData* uiData= GetMtmUiDataL( KSenduiMtmSyncMLEmailUid );
+ if ( uiData )
+ {
+ TInt reason = 0;
+ TBool syncronizing = uiData->CanOpenEntryL( entry, reason );
+ if ( !syncronizing )
+ {
+ //cannot open during syncronizing
+ HBufC* text = StringLoader::LoadLC( reason, iEikonEnv );
+ CAknInformationNote* note = new (ELeave) CAknInformationNote();
+ note->ExecuteLD(*text);
+ CleanupStack::PopAndDestroy(); //text
+ isSyncronizing = ETrue;
+ }
+ }
+ }
+
+ return isSyncronizing;
+ }
+
+// ----------------------------------------------------
+// CMceUi::AlwaysOnlineLastConnectionL
+//
+// ----------------------------------------------------
+TBool CMceUi::AlwaysOnlineLastConnectionL( const TMsvId aAccount )
+ {
+ TBool connectionMade = ETrue;
+
+ CImumInSettingsData* settings =
+ iEmailApi->MailboxServicesL().LoadMailboxSettingsL( aAccount );
+ CleanupStack::PushL( settings );
+
+ if ( iMceMainView->ListContainer()->ListItems()->
+ AlwaysOnlineAccountL( aAccount, *settings ) )
+ {
+ TInt lastUpdateFailed = 0;
+ settings->GetAttr(
+ TImumInSettings::EKeyInfoLastUpdateFailed, lastUpdateFailed );
+ if ( lastUpdateFailed )
+ {
+ TInt64 lastTime = 0;
+ settings->GetAttr(
+ TImumInSettings::EKeyInfoLastSuccessfulUpdate, lastTime );
+ TTime settingsTime( lastTime );
+ TBuf<KMceMaxDateString> time;
+ TBuf<KMceMaxDateString> dateTime;
+
+ HBufC* timeFormat = iCoeEnv->
+ AllocReadResourceLC( R_QTN_TIME_USUAL_WITH_ZERO );
+ HBufC* dateFormat = iCoeEnv->
+ AllocReadResourceLC( R_QTN_DATE_USUAL_WITH_ZERO );
+
+ TTime currentTime;
+ currentTime.HomeTime();
+ TDateTime currentDate( currentTime.DateTime() ); //current date
+ TDateTime currentDateSettings( settingsTime.DateTime() ); //settings date
+
+ TBool connBeforeToday = EFalse;
+ if ( currentDate.Year() > currentDateSettings.Year() )
+ {
+ connBeforeToday = ETrue;
+ }
+ else
+ if ( currentDate.Month() > currentDateSettings.Month() )
+ {
+ connBeforeToday = ETrue;
+ }
+ else
+ if ( currentDate.Day() > currentDateSettings.Day() )
+ {
+ connBeforeToday = ETrue;
+ }
+
+ settingsTime.FormatL( time, *timeFormat );
+ AknTextUtils::LanguageSpecificNumberConversion( time );
+
+ settingsTime.FormatL( dateTime, *dateFormat );
+ AknTextUtils::LanguageSpecificNumberConversion( dateTime );
+ CleanupStack::PopAndDestroy( 2, timeFormat ); // timeFormat, dateFormat
+
+ CAknQueryDialog* confDialog = CAknQueryDialog::NewL();
+ HBufC* text = NULL;
+ if ( connBeforeToday ) //last connection failed before today
+ {
+ CDesCArrayFlat* string=new(ELeave)CDesCArrayFlat( KMceArrayGranularity );
+ CleanupStack::PushL( string );
+ string->AppendL( dateTime );
+ string->AppendL( time );
+ text = StringLoader::LoadLC(
+ R_MCE_SETTINGS_ALWAYS_LASTTIME2, *string, iEikonEnv );
+ }
+ else
+ {
+ text = StringLoader::LoadLC(
+ R_MCE_SETTINGS_ALWAYS_LASTTIME, time, iEikonEnv );
+ }
+
+ confDialog->SetPromptL( *text );
+ CleanupStack::PopAndDestroy( text );
+ if ( connBeforeToday ) //last connection failed before today
+ {
+ CleanupStack::PopAndDestroy();
+ }
+
+ connectionMade = EFalse;
+
+ if ( confDialog->ExecuteLD( R_MCE_CONFIRMATION ) )
+ {
+ GoOnlineL( aAccount );
+ }
+
+ }
+ }
+
+ CleanupStack::PopAndDestroy( 1 ); // extendedMailSettings
+ return connectionMade;
+ }
+
+// ----------------------------------------------------
+// CMceUi::AddOperationIdL
+//
+// ----------------------------------------------------
+void CMceUi::AddOperationIdL( const TMsvOp& aOp, const TMsvId& aServiceId )
+ {
+ if ( !iMailAccountItemArray )
+ {
+ return;
+ }
+
+ TInt count = iMailAccountItemArray->Count();
+ TInt found = EFalse;
+ for ( TInt cc = 0; cc < count && !found; cc++ )
+ {
+ const TMceMailAccountItem& item = ((*iMailAccountItemArray)[cc]);
+ if ( item.iServiceId == aServiceId )
+ {
+ ((*iMailAccountItemArray)[cc]).iMceConnection = ETrue;
+ ((*iMailAccountItemArray)[cc]).iOp = aOp;
+ found = ETrue;
+ }
+ }
+ if ( !found )
+ {
+ TMceMailAccountItem item;
+ item.iServiceId = aServiceId;
+ item.iMceConnection = ETrue;
+ item.iOp = aOp;
+ iMailAccountItemArray->AppendL( item );
+ }
+ }
+
+// ----------------------------------------------------
+// CMceUi::RemoveOperationId
+//
+// ----------------------------------------------------
+void CMceUi::RemoveOperationId( const TMsvId& /*aOpId*/, const TMsvId& aServiceId )
+ {
+ if ( !iMailAccountItemArray )
+ {
+ return;
+ }
+
+ TInt count = iMailAccountItemArray->Count();
+
+ for ( TInt loop=count-1; loop>=0; loop-- )
+ {
+ TMceMailAccountItem item = ((*iMailAccountItemArray)[loop]);
+ if ( item.iServiceId == aServiceId )
+ {
+ iMailAccountItemArray->Delete( loop );
+ break;
+ }
+ }
+ }
+
+// ----------------------------------------------------
+// CMceUi::ServiceIdFound
+//
+// ----------------------------------------------------
+TBool CMceUi::ServiceIdFound( const TMsvId& aServiceId )
+ {
+ TInt found = EFalse;
+
+ TInt count = iMailAccountItemArray->Count();
+
+ for ( TInt cc = 0; cc < count && !found; cc++ )
+ {
+ TMceMailAccountItem item = ((*iMailAccountItemArray)[cc]);
+ if ( item.iServiceId == aServiceId && item.iMceConnection )
+ {
+ found = ETrue;
+ }
+ }
+ return found;
+ }
+
+// ----------------------------------------------------
+// CMceUi::AlwaysOnline
+//
+// ----------------------------------------------------
+TBool CMceUi::AlwaysOnline( )
+ {
+ return iAlwaysOnline;
+ }
+
+// ----------------------------------------------------
+// CMceUi::IsMessageSetToBeDeletedFromServer
+//
+// ----------------------------------------------------
+TBool CMceUi::IsMailSetToBeDeletedFromServerL( TMsvId aItemId )
+ {
+ TInt rid = 0;
+ TBool ret = EFalse;
+ TMsvId serviceId;
+ TMsvEntry currentEntry;
+
+ iSession->GetEntry( aItemId, serviceId, currentEntry );
+
+ CBaseMtmUiData* mtmUiData = GetMtmUiDataL( currentEntry.iMtm );
+
+ if ( mtmUiData && mtmUiData->CanUnDeleteFromEntryL( currentEntry, rid ) )
+ {
+ ret = ETrue;
+ }
+
+ return ret;
+ }
+
+// ----------------------------------------------------
+// CMceUi::AnchoredItem
+//
+// ----------------------------------------------------
+//
+void CMceUi::DefineAnchorIdL( const CMsvEntrySelection* /*aSelection*/ )
+ {
+#if 0
+ if ( IsMailSetToBeDeletedFromServerL() )
+ {
+ SetAnchorId( iMceListView->ListContainer()->CurrentItemId() );
+ return;
+ }
+ // TODO
+ TInt currentItem = iMceListView->ListContainer()->CurrentItemIndex();
+ CMceMessageListItemArray* items = iMceListView->ListContainer()->ListItems();
+ iAnchorId = NULL;
+
+// Do not change the focus if mailbox is offline and currently selected item is set to be deleted from server
+ if ( IsMailSetToBeDeletedFromServerL() )
+ {
+ SetAnchorId( iMceListView->ListContainer()->CurrentItemId() );
+ return;
+ }
+
+ for ( TInt i = currentItem; i < items->MdcaCount(); i++ ) // Find forwards
+ {
+ if ( aSelection->Find( items->ItemId( i ) ) == KErrNotFound )
+ {
+ SetAnchorId( items->ItemId( i ) );
+ break;
+ }
+ }
+
+ if ( !iAnchorId ) // If not found in forward search, find backwards
+ {
+ for ( TInt i = currentItem; i >= 0; i-- )
+ {
+ if ( aSelection->Find( items->ItemId( i ) ) == KErrNotFound )
+ {
+ SetAnchorId( items->ItemId( i ) );
+ break;
+ }
+ }
+ }
+#endif
+ }
+
+// ----------------------------------------------------
+// CMceUi::AnchoredItem
+//
+// ----------------------------------------------------
+TMsvId CMceUi::AnchoredItem()
+ {
+ return iAnchorId;
+ }
+
+// ----------------------------------------------------
+// CMceUi::SetAnchorId
+//
+// ----------------------------------------------------
+void CMceUi::SetAnchorId( TMsvId aAnchorId )
+ {
+ iAnchorId = aAnchorId;
+ }
+
+// ----------------------------------------------------
+// CMceUi::EventL
+//
+// ----------------------------------------------------
+void CMceUi::EventL( const CConnMonEventBase &aConnMonEvent )
+ {
+ switch ( aConnMonEvent.EventType() )
+ {
+ case EConnMonNetworkRegistrationChange:
+ {
+ CConnMonNetworkRegistrationChange* event =
+ ( CConnMonNetworkRegistrationChange* ) &aConnMonEvent;
+
+ if ( iMceMainView->ListContainer() ) // Cannot set roaming if ListContainer is empty
+ {
+ // Set roaming status
+ iMceMainView->ListContainer()->ListItems()->SetRoaming(
+ event->RegistrationStatus() == ENetworkRegistrationRoaming );
+
+ if ( MceViewActive( EMceMainViewActive ) )
+ {
+ //update icon only if main view is open
+ iMceMainView->ListContainer()->DrawDeferred();
+ }
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+// ----------------------------------------------------
+// CMceUi::HandleGainingForeground
+//
+// ----------------------------------------------------
+void CMceUi::HandleGainingForeground() // CR : 401-1806
+ {
+ if ( !iFeatureMgrEnabled )
+ {
+ TRAP_IGNORE( FeatureManager::InitializeLibL() );
+ iFeatureMgrEnabled = ETrue ;
+ }
+ TBool newPostcardVal = EFalse;
+ TBool newAudioMsgVal = EFalse;
+ newAudioMsgVal = FeatureManager::FeatureSupported( KFeatureIdAudioMessaging );
+ newPostcardVal = FeatureManager::FeatureSupported( KFeatureIdMmsPostcard );
+ if ( newAudioMsgVal != iAudioMsgEnabled || newPostcardVal != iPostcardEnabled )
+ {
+ TRAP_IGNORE( HandleMTMChangeL() );
+ }
+ if ( MceViewActive( EMceMainViewActive ) )
+ {
+ CheckIAUpdate();
+ }
+ }
+
+// ----------------------------------------------------
+// CMceUi::HandleLosingForeground
+//
+// ----------------------------------------------------
+void CMceUi::HandleLosingForeground() // CR : 401-1806
+ {
+ iAudioMsgEnabled = FeatureManager::FeatureSupported( KFeatureIdAudioMessaging );
+ iPostcardEnabled = FeatureManager::FeatureSupported( KFeatureIdMmsPostcard ) ;
+ if ( iFeatureMgrEnabled )
+ {
+ FeatureManager::UnInitializeLib() ;
+ iFeatureMgrEnabled = EFalse ;
+ }
+ }
+
+// ----------------------------------------------------
+// CMceUi::ToPhoneMemoryQueryL
+//
+// ----------------------------------------------------
+void CMceUi::ToPhoneMemoryQueryL( TBool aShowQuery )
+ {
+
+ if ( iPhoneMemoryQuery )
+ {
+ // If the dialog for whitching the message store is allready visible,
+ // dismiss it
+ delete iPhoneMemoryQuery;
+ iPhoneMemoryQuery = NULL;
+ return;
+ }
+
+ //this method is run when message centre is started
+ if ( iMemoryInUse && !iMessageStoreExist && aShowQuery )
+ {
+ // check, if message store was in MMC but message server has
+ // automatically changed message store to phone memory
+ RFs& fs=iEikonEnv->FsSession();
+ iMessageStoreExist = ETrue;
+ TInt currentDrive = EDriveC;
+ currentDrive = TInt(iSession->CurrentDriveL());
+
+ TInt i = EDriveC;
+
+ CRepository* repository = NULL;
+ TRAPD( ret, repository = CRepository::NewL(KCRUidMuiuSettings) );
+
+ if ( ret == KErrNone )
+ {
+ CleanupStack::PushL( repository );
+ if ( repository->Get(KMuiuMemoryInUse,i) != KErrNone )
+ {
+ i = EDriveC;
+ }
+ if ( i != EDriveC && currentDrive == EDriveC )
+ {
+ // message server has changed the store automatically
+ iMessageStoreExist = EFalse;
+ }
+ }
+
+ if ( !iMessageStoreExist )
+ {
+ // message store was in MMC, but now there is no MMC
+ iPhoneMemoryQuery = CAknQueryDialog::NewL();
+ iPhoneMemoryQuery->ExecuteLD( R_MCE_MEMC_NOTE );
+ iPhoneMemoryQuery = NULL; // ExecuteLD deletes the object
+ }
+ iMessageStoreExist = ETrue;
+
+ if ( ret == KErrNone )
+ {
+ ret = repository->Set( KMuiuMemoryInUse, currentDrive );
+ __ASSERT_DEBUG( !ret, User::Panic(KPanicText,KCRepositorySettingFailure) );
+ CleanupStack::PopAndDestroy( repository );
+ }
+
+ }
+ }
+
+// ----------------------------------------------------
+// CMceUi::SetMainViewActivatedFlag
+//
+// ----------------------------------------------------
+void CMceUi::SetMainViewActivatedFlag( )
+ {
+ iMceUiFlags.SetMceFlag( EMceUiFlagsMainViewActivated );
+ }
+
+// ---------------------------------------------------------
+// CMceUi::AlwaysOnlineL
+// This is static function
+// Returns ETrue if always online is supported
+// ---------------------------------------------------------
+TBool CMceUi::AlwaysOnlineL( )
+ {
+ TBool alwaysOnline = EFalse;
+ if ( FeatureManager::FeatureSupported( KFeatureIdAlwaysOnLine )
+ && FeatureManager::FeatureSupported( KFeatureIdAlwaysOnLineEmail ) )
+ {
+ TInt featureBitmask = 0;
+
+ CRepository* repository = NULL;
+ TRAPD( ret, repository = CRepository::NewL(KCRUidMuiuVariation) );
+ CleanupStack::PushL( repository );
+
+ if ( ret == KErrNone )
+ {
+ if ( repository->Get(KMuiuEmailConfigFlags,featureBitmask) != KErrNone )
+ {
+ alwaysOnline = EFalse;
+ }
+ else
+ {
+ alwaysOnline = featureBitmask & KEmailFeatureIdAlwaysOnline;
+ }
+ }
+
+ CleanupStack::Pop( repository );
+ delete repository;
+
+ }
+
+ return alwaysOnline;
+ }
+
+// ----------------------------------------------------
+// CMceUi::RemoveFolderTabs
+// ----------------------------------------------------
+void CMceUi::RemoveFolderTabs()
+ {
+ MCELOGGER_ENTERFN("RemoveFolderTabs()");
+
+ iNaviPane->Pop( iFolderIndicator );
+
+ MCELOGGER_LEAVEFN("RemoveFolderTabs()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::ShowFolderTabsL
+// ----------------------------------------------------
+void CMceUi::ShowFolderTabsL( const TInt aDepth )
+ {
+ MCELOGGER_ENTERFN("ShowFolderTabsL()");
+
+ CMceNaviPaneFolderIndicator* findicator =
+ static_cast<CMceNaviPaneFolderIndicator*>( iFolderIndicator->DecoratedControl() );
+
+ findicator->SetFolderDepth( aDepth );
+ iNaviPane->PushL( *iFolderIndicator );
+
+ MCELOGGER_LEAVEFN("ShowFolderTabsL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::HandleMMSNotificationsDeleteL
+//
+// ----------------------------------------------------
+void CMceUi::HandleMMSNotificationsDeleteL( TDes8& aParameter )
+ {
+ CBaseMtmUiData* uiData = NULL;
+ uiData = GetMtmUiDataL( KUidMsgMMSNotification );
+
+ TMsvId selId = iMMSNotifications->At(0);
+ TMsvId mmsService;
+ TMsvEntry mmsEntry;
+ if ( uiData && iSession->GetEntry( selId, mmsService, mmsEntry ) == KErrNone )
+ {
+ CBaseMtmUi& mtmUi=iMtmStore->GetMtmUiAndSetContextLC( mmsEntry );
+ CMsvSingleOpWatcher* tempSingleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( tempSingleOpWatcher );
+
+ CMsvOperation* tempOp=mtmUi.InvokeAsyncFunctionL( KMtmUiFunctionDeleteMessage, *iMMSNotifications,
+ tempSingleOpWatcher->iStatus, aParameter );
+
+ if ( tempOp )
+ {
+ CleanupStack::PushL( tempOp );
+ iOperations.AppendL( tempSingleOpWatcher );
+ CleanupStack::Pop(2); // tempSingleOpWatcher, tempOp
+ tempSingleOpWatcher->SetOperation( tempOp );
+ }
+ else
+ {
+ // User answered 'No' to the confirmation query and
+ // NULL operation was returned
+ CleanupStack::PopAndDestroy( tempSingleOpWatcher );
+ if( iMMSNotifications )
+ {
+ delete iMMSNotifications;
+ iMMSNotifications = NULL;
+ }
+ }
+ CleanupStack::PopAndDestroy( ); // mtmUi
+ }
+
+ }
+
+// ----------------------------------------------------
+// CMceUi::CheckMMSNotificationsL
+//
+// ----------------------------------------------------
+void CMceUi::CheckMMSNotificationsL( CMsvEntrySelection* aSelection )
+ {
+ TMsvId id;
+ TMsvId service;
+ TMsvEntry tEntry;
+ CBaseMtmUiData* uiData = NULL;
+ uiData = GetMtmUiDataL( KUidMsgMMSNotification );
+
+ if ( iMMSNotifications )
+ {
+ delete iMMSNotifications;
+ iMMSNotifications = NULL;
+ }
+ iMMSNotifications = new( ELeave ) CMsvEntrySelection();
+
+ for ( TInt cc=aSelection->Count(); --cc>=0; )
+ {
+ id = aSelection->At(cc);
+ if ( iSession->GetEntry( id, service, tEntry ) == KErrNone )
+ {
+ if ( tEntry.iMtm == KUidMsgMMSNotification )
+ {
+ if ( uiData && !uiData->OperationSupportedL( KMtmUiFunctionDeleteMessage, tEntry ) )
+ {
+ iMMSNotifications->AppendL( tEntry.Id() );
+ aSelection->Delete( cc );
+ }
+ else
+ {
+ aSelection->Delete( cc );
+ }
+ }
+ }
+ }
+
+ }
+
+// ----------------------------------------------------
+// CMceUi::OpenMailboxSettingsL
+// ----------------------------------------------------
+void CMceUi::OpenMailboxSettingsL()
+ {
+ MCELOGGER_ENTERFN("OpenMailboxSettingsL()");
+
+ if ( MceViewActive( EMceMainViewActive ) )
+ {
+ return;
+ }
+
+ // Is settings opened from General Settings
+ CMuiuLock* repositoryLock = CMuiuLock::NewL( KMuiuLockSettings );
+ CleanupStack::PushL(repositoryLock);
+ TInt err = repositoryLock->Reserve();
+ // Check that settings are not opened from General Settings
+ if ( !err )
+ {
+ iMceListView->OpenMailboxSettingsL();
+ }
+ else
+ {
+ // Show information note: General Settings has opened settings
+ CAknNoteDialog* dlg = new (ELeave) CAknNoteDialog(
+ CAknNoteDialog::ENoTone, CAknNoteDialog::ELongTimeout);
+ dlg->ExecuteLD(R_MCE_NOTE_SETTINGS_OPEN_GS);
+ }
+ repositoryLock->Release();
+ CleanupStack::PopAndDestroy( repositoryLock );
+
+ MCELOGGER_LEAVEFN("OpenMailboxSettingsL");
+ }
+
+// ----------------------------------------------------
+// CMceUi::SyncMlMarkAsReadL
+// ----------------------------------------------------
+void CMceUi::SyncMlMarkAsReadL( )
+ {
+ if ( MceViewActive( EMceMainViewActive ) )
+ {
+ return;
+ }
+
+ CMsvEntrySelection * selection = iMceListView->ListContainer()
+ ->CurrentItemSelectionL();
+ CleanupStack::PushL( selection );
+
+ if ( selection->Count() <= 0 )
+ {
+ CleanupStack::PopAndDestroy( selection );
+ return;
+ }
+
+ CBaseMtmUi& mtmUi = iMtmStore->GetMtmUiLC( KSenduiMtmSyncMLEmailUid );
+
+ CMsvSingleOpWatcher* tempSingleOpWatcher=CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( tempSingleOpWatcher );
+ TBuf8<1> blankParams;
+
+ CMsvOperation* tempOp = mtmUi.InvokeAsyncFunctionL( KMtmUiFunctionMarkAsRead, *selection,
+ tempSingleOpWatcher->iStatus, blankParams );
+
+ CleanupStack::PushL( tempOp );
+ iOperations.AppendL( tempSingleOpWatcher );
+ CleanupStack::Pop( 2 ); // tempSingleOpWatcher, tempOp
+ tempSingleOpWatcher->SetOperation( tempOp );
+ CleanupStack::PopAndDestroy( 2 ); // mtmUi, selection
+ }
+
+// ----------------------------------------------------
+// CMceUi::CheckMMSNotifDelFailedL
+// ----------------------------------------------------
+void CMceUi::CheckMMSNotifDelFailedL()
+ {
+ MCELOGGER_ENTERFN("CheckMMSNotifDelFailedL()");
+
+ CBaseMtmUiData* data = GetMtmUiDataL( KUidMsgMMSNotification );
+ if ( data )
+ {
+ TInt count = iMMSNotifications->Count();
+ TInt failed = 0;
+ TMsvId serviceId;
+ for(TInt loop = 0; loop < count; loop++)
+ {
+ TMsvEntry entry;
+ if ( iSession->GetEntry(iMMSNotifications->At(loop),serviceId,entry) == KErrNone )
+ {
+ if ( !( entry.iMtmData2 & KMmsNewOperationForbidden ) &&
+ !( entry.iMtmData2 & KMmsOperationOngoing ) &&
+ ( entry.iMtmData2 & KMmsOperationFinished ) &&
+ ( entry.iMtmData2 & KMmsOperationResult ) )
+ {
+ failed++;
+ }
+ }
+ } // end loop
+
+
+ if ( failed > 0 )
+ {
+ CAknQueryDialog* note = CAknQueryDialog::NewL();
+ HBufC* text = NULL;
+ if ( failed == KMceOneMMSNotificationFailed )
+ {
+ text = StringLoader::LoadLC(
+ R_MMS_INFO_REMOTE_DEL_FAILED, iEikonEnv );
+ note->SetPromptL( *text );
+ note->ExecuteLD( R_MCE_MEMC_NOTE );
+ CleanupStack::PopAndDestroy( ); // text
+ }
+ else
+ {
+ CArrayFix<TInt>* indexArray =
+ new( ELeave ) CArrayFixFlat<TInt>( KMceArrayGranularity );
+ CleanupStack::PushL( indexArray );
+ indexArray->AppendL( failed );
+ indexArray->AppendL( count );
+ text = StringLoader::LoadLC(
+ R_MMS_INFO_REMOTE_DEL_FAILED_MANY, *indexArray, iEikonEnv );
+
+ note->SetPromptL( *text );
+ note->ExecuteLD( R_MCE_MEMC_NOTE );
+ CleanupStack::PopAndDestroy( 2 ); // text, indexArray
+ }
+ }
+
+ delete iMMSNotifications;
+ iMMSNotifications = NULL;
+ }
+
+ MCELOGGER_LEAVEFN("CheckMMSNotifDelFailedL");
+ }
+
+// ----------------------------------------------------
+// CMceUi::AddMultiselectionMTMFunctionsL
+// ----------------------------------------------------
+void CMceUi::AddMultiselectionMTMFunctionsL(CEikMenuPane& aMenuPane, TInt /*aMenuCommandId*/)
+ {
+ MCELOGGER_ENTERFN("AddMultiselectionMTMFunctionsL()");
+
+ CEikMenuPaneItem::SData data;
+ data.iCascadeId = 0;
+ data.iFlags = 0;
+ TInt cc;
+ TInt sendCmd = EMceCmdFirstMTMFunction;
+ const TInt count = iMTMFunctionsArray->Count();
+
+ for ( cc = 0; cc < count; cc++ )
+ {
+ TMsgFunctionInfo& functionInfo = iMTMFunctionsArray->At(cc);
+ data.iText = functionInfo.iCaption;
+ data.iCommandId = sendCmd;
+
+ if ( ( functionInfo.iFuncId == KMtmUiFunctionMMBox ) &&
+ ( MceViewActive( EMceMessageViewActive ) &&
+ iMceListView->ListContainer()->CurrentFolderId()
+ == KMsvGlobalInBoxIndexEntryId ) ) //MMS notification
+ {
+ TInt pos;
+ if ( !aMenuPane.MenuItemExists ( sendCmd, pos ) )
+ {
+ aMenuPane.AddMenuItemL( data, EAknCmdOpen );
+ }
+ }
+
+ sendCmd++;
+ }
+ MCELOGGER_LEAVEFN("AddMultiselectionMTMFunctionsL()");
+ }
+
+// ----------------------------------------------------
+// CMceUi::CheckCspBitL
+// ----------------------------------------------------
+TBool CMceUi::CheckCspBitL( ) const
+ {
+ MCELOGGER_ENTERFN("CheckCspBitL()");
+ RCustomerServiceProfileCache csp;
+ TInt error = csp.Open();
+ if ( error )
+ {
+ return ETrue;
+ }
+
+ RMobilePhone::TCspTeleservices params;
+ TInt retVal = csp.CspTeleServices( params );
+ csp.Close();
+
+ if ( retVal == KErrNone )
+ {
+ if ( ( params&RMobilePhone::KCspSMCB ) != 0 )
+ {
+ MCELOGGER_LEAVEFN("CheckCspBitL()");
+ // Cell Broadcast CSP bit is on
+ return ETrue;
+ }
+ else
+ {
+ MCELOGGER_LEAVEFN("CheckCspBitL()");
+ // Cell Broadcast CSP bit is off
+ return EFalse;
+ }
+ }
+ else
+ {
+ MCELOGGER_LEAVEFN("CheckCspBitL()");
+ // Error: By default show the CBS service
+ return ETrue;
+ }
+ }
+
+// ---------------------------------------------------------
+// CMceUi::CspBitsL
+// Returns ETrue if csp bits is supported
+// ---------------------------------------------------------
+//
+TBool CMceUi::CspBitsL( )
+ {
+ TBool csp = EFalse;
+ TInt featureBitmask = 0;
+
+ CRepository* repository = NULL;
+ TRAPD( ret, repository = CRepository::NewL(KCRUidMuiuVariation) );
+ CleanupStack::PushL( repository );
+
+ if ( ret == KErrNone )
+ {
+ if ( repository->Get(KMuiuMceFeatures,featureBitmask) != KErrNone )
+ {
+ csp = EFalse;
+ }
+ else
+ {
+ csp = featureBitmask & KMceFeatureIdCSPSupport;
+ }
+ }
+
+ CleanupStack::Pop( repository );
+ delete repository;
+
+ return csp;
+ }
+
+// ---------------------------------------------------------
+// CMmsViewerAppUi::DoUploadL
+// ---------------------------------------------------------
+void CMceUi::DoUploadL( TInt aIndex )
+ {
+ TInt i = aIndex;
+ CSendingServiceInfo* info = iUploadServices[ i ];
+ TMsgUploadParameters uploadParams;
+ uploadParams.iDirect = ( info->ServiceProviderId() == KMmsDirectUpload );
+ uploadParams.iRealAddress = info->ServiceAddress();
+ uploadParams.iAlias = info->ServiceName();
+
+ // Pack upload parameters
+ TPckgBuf<TMsgUploadParameters> param( uploadParams );
+
+ // Current selection
+ CMsvEntrySelection* selection = iMceListView->ListContainer()->CurrentItemSelectionL();
+ CleanupStack::PushL( selection );
+
+ CAknInputBlock::NewLC();
+ CMuiuOperationWait* wait =
+ CMuiuOperationWait::NewLC( EActivePriorityWsEvents + 10 );
+
+// Get a handle of the MMS MTM
+ CBaseMtmUi& mtmUi = iMtmStore->GetMtmUiLC( KSenduiMtmMmsUid );
+
+ CMsvOperation* oper = mtmUi.InvokeAsyncFunctionL(
+ KMtmUiFunctionUpload,
+ *selection,
+ wait->iStatus,
+ param );
+ CleanupStack::PushL( oper );
+
+ wait->Start();
+
+ CleanupStack::PopAndDestroy( 5, selection ); // selection, CAknInputBlock, wait, oper
+ }
+
+// ---------------------------------------------------------
+// CMceUi::ShowUploadQueryL
+// ---------------------------------------------------------
+void CMceUi::ShowUploadQueryL()
+ {
+ TInt count = iUploadServices.Count();
+
+ TInt selectedIndex = 0;
+ CAknListQueryDialog* dlg = new ( ELeave )
+ CAknListQueryDialog( &selectedIndex );
+ dlg->PrepareLC( R_MCE_UPLOAD_LIST_QUERY );
+
+ // Populate list query array
+ CDesCArrayFlat* array = new ( ELeave ) CDesCArrayFlat( 4 );
+ CleanupStack::PushL( array );
+ for ( TInt i = 0; i < count; i++ )
+ {
+ array->AppendL( iUploadServices[ i ]->ServiceMenuName() );
+ }
+ dlg->SetItemTextArray( array );
+ CleanupStack::Pop( array );
+
+ if ( dlg->RunLD() )
+ {
+ DoUploadL( selectedIndex );
+ }
+
+ }
+
+// MMS.Content.Upload
+// ---------------------------------------------------------
+// CMceUi::NumUploadServices
+// ---------------------------------------------------------
+TInt CMceUi::NumUploadServices()
+ {
+ return iUploadServices.Count();
+ }
+
+// ---------------------------------------------------------
+// CMceUi::HandleNotifL
+// ---------------------------------------------------------
+void CMceUi::HandleNotif()
+ {
+ if ( !iEmailNotifHandler )
+ {
+ // Handling of NCN reset
+ TRAPD( err, iEmailNotifHandler = CMceEmailNotifHandler::NewL() );
+ MCELOGGER_WRITE_FORMAT("ConstructL iEmailNotifHandler err %d", err);
+ if ( err )
+ {
+ iEmailNotifHandler = NULL;
+ }
+ }
+ if (iEmailNotifHandler)
+ iEmailNotifHandler->HandleNotif();
+ }
+
+// ---------------------------------------------------------
+// CMceUi::HandleNotifL
+// ---------------------------------------------------------
+void CMceUi::HandleNotif(const TMsvId& aMailbox)
+ {
+ if ( !iEmailNotifHandler )
+ {
+ // Handling of NCN reset
+ TRAPD( err, iEmailNotifHandler = CMceEmailNotifHandler::NewL() );
+ if ( err )
+ {
+ iEmailNotifHandler = NULL;
+ }
+ }
+ if ( iEmailNotifHandler )
+ {
+ iEmailNotifHandler->HandleNotif(aMailbox);
+ }
+ }
+
+// ---------------------------------------------------------
+// CMceUi::CheckSIMAccessProfileL
+// ---------------------------------------------------------
+void CMceUi::CheckSIMAccessProfileL()
+ {
+ // P&S key of the SIM access profile
+ RProperty property;
+ TInt sapState( 0 );
+ User::LeaveIfError( property.Attach( KPSUidBluetoothSapConnectionState, KBTSapConnectionState ) );
+ CleanupClosePushL( property );
+
+ property.Get( sapState );
+
+ if ( (sapState==EBTSapConnecting) || (sapState==EBTSapConnected) )
+ {
+ // SIM access profile is connecting/connected, MCE is not started
+ HBufC* text = StringLoader::LoadLC( R_QTN_OFFLINE_NOT_POSSIBLE_SAP, iEikonEnv );
+ // ETrue waiting/non-waiting dialoog
+ CAknInformationNote* note = new(ELeave) CAknInformationNote( ETrue );
+ note->SetTimeout( CAknNoteDialog::ELongTimeout ); // ELongTimeout
+ note->ExecuteLD( *text );
+ CleanupStack::PopAndDestroy( text );
+ // Exit the application
+ CleanupStack::PopAndDestroy( &property );
+ Exit();
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy( &property );
+ }
+ }
+
+// ---------------------------------------------------------
+// CMceUi::SetViewUpdateSuppressionFlag
+// ---------------------------------------------------------
+void CMceUi::SetViewUpdateSuppressionFlag( TBool aValue, CMsvOperation* aOp )
+ {
+ if ( aValue )
+ {
+ iMceUiFlags.SetMceFlag( EMceUiFlagsSupressViewUpdate );
+ iBlockingOperation = aOp;
+ }
+ else
+ {
+ iMceUiFlags.ClearMceFlag( EMceUiFlagsSupressViewUpdate );
+ iBlockingOperation = NULL;
+ }
+
+ }
+
+// ---------------------------------------------------------
+// CMceUi::ViewUpdateSuppressionFlag
+// ---------------------------------------------------------
+TBool CMceUi::ViewUpdateSuppressionFlag()
+ {
+ return iMceUiFlags.MceFlag( EMceUiFlagsSupressViewUpdate );
+ }
+
+// ---------------------------------------------------------
+// CMceUi::ReleaseMtmUiData
+// ---------------------------------------------------------
+void CMceUi::ReleaseMtmUiData()
+ {
+ MCELOGGER_ENTERFN("ReleaseMtmUiData()");
+ const TInt count = iUiRegistry->NumRegisteredMtmDlls();
+ MCELOGGER_WRITE_FORMAT("Mtm cound %d", count);
+
+ for ( TInt i = 0; i < count; i++ )
+ {
+ TUid uid = iUiRegistry->MtmTypeUid(i);
+ if ( !MceUtils::IsMtmBuiltIn(uid) )
+ {
+ iMtmStore->ReleaseMtmUiData( uid );
+ }
+ }
+ MCELOGGER_LEAVEFN("ReleaseMtmUiData()");
+ }
+
+// ---------------------------------------------------------
+// CMceUi::InformationNoteCannotMoveCopyEMailL
+// ---------------------------------------------------------
+void CMceUi::InformationNoteCannotMoveCopyEMailL()
+ {
+ HBufC* errorText = StringLoader::LoadL( R_MCE_INFO_CANNOT_MOVE, iEikonEnv );
+ CleanupStack::PushL( errorText );
+ CAknInformationNote* note = new(ELeave)CAknInformationNote( ETrue );
+ note->ExecuteLD(*errorText);
+ CleanupStack::PopAndDestroy( errorText );
+ }
+
+// ---------------------------------------------------------
+// CMceUi::RemoveEmailMessagesFromSelection
+// ---------------------------------------------------------
+TBool CMceUi::RemoveEmailMessagesFromSelection( CMsvEntrySelection *aSelection )
+ {
+ TBool mailMessage = EFalse;
+ TInt count = aSelection->Count();
+ TMsvId service;
+ TMsvEntry tEntry;
+
+ for ( TInt cc=count; --cc>=0; )
+ {
+ TMsvId id = aSelection->At(cc);
+ if ( iSession->GetEntry( id, service, tEntry ) == KErrNone )
+ {
+ if ( tEntry.iMtm==KSenduiMtmImap4Uid || tEntry.iMtm==KSenduiMtmPop3Uid ||
+ tEntry.iMtm==KSenduiMtmSmtpUid )
+ {
+ aSelection->Delete( cc );
+ mailMessage = ETrue;
+ }
+ }
+ }
+
+ return mailMessage;
+ }
+
+// ---------------------------------------------------------
+// CMceUi::MailboxCreationOn
+// ---------------------------------------------------------
+TBool CMceUi::MailboxCreationOn()
+ {
+ return iMailboxCreationOn;
+ }
+
+// ---------------------------------------------------------
+// CMceUi::ZoomLevelChangedL
+// ---------------------------------------------------------
+TAknUiZoom CMceUi::ZoomLevelChangedL( TAknUiZoom aZoomLevel )
+ {
+ TAknUiZoom previous = LocalUiZoom();
+ if ( aZoomLevel != previous &&
+ !iMceUiFlags.MceFlag( EMceUiFlagsSettingsDialogOpen ) )
+ {
+ SetLocalUiZoom( aZoomLevel );
+ ApplyLayoutChangeL( ETrue );
+ }
+ return previous;
+ }
+
+// ---------------------------------------------------------
+// CMceUi::ReadZoomLevelL
+// ---------------------------------------------------------
+TAknUiZoom CMceUi::ReadZoomLevelL()
+ {
+ TInt zoomValue = EAknUiZoomAutomatic;
+ CRepository* repository = NULL;
+ TRAPD( ret, repository = CRepository::NewL(KCRUidMuiuSettings) );
+ if ( ret == KErrNone )
+ {
+ CleanupStack::PushL( repository );
+ if ( repository->Get(KMuiuZoomValue, zoomValue) != KErrNone )
+ {
+ zoomValue = EAknUiZoomAutomatic;
+ }
+ CleanupStack::PopAndDestroy( repository );
+ }
+ return (TAknUiZoom) zoomValue;
+ }
+
+// ---------------------------------------------------------
+// CMceUi::WriteZoomLevelL
+// ---------------------------------------------------------
+void CMceUi::WriteZoomLevelL( TAknUiZoom aZoomLevel )
+ {
+ CRepository* repository = NULL;
+ TRAPD( ret, repository = CRepository::NewL(KCRUidMuiuSettings) );
+ if ( ret == KErrNone )
+ {
+ CleanupStack::PushL( repository );
+ if ( repository->Set(KMuiuZoomValue, aZoomLevel) != KErrNone )
+ {
+ // hmm, just ignore?
+ }
+ CleanupStack::PopAndDestroy( repository );
+ }
+ }
+
+// ---------------------------------------------------------
+// CMceUi::HandleZoomLevelChangeL
+// ---------------------------------------------------------
+void CMceUi::HandleZoomLevelChangeL( TInt aCommand )
+ {
+ TAknUiZoom uiZoom;
+ switch ( aCommand )
+ {
+ default:
+ case EMceCmdZoomValueAutomatic:
+ uiZoom = EAknUiZoomAutomatic;
+ break;
+ case EMceCmdZoomValueLarge:
+ uiZoom = EAknUiZoomLarge;
+ break;
+ case EMceCmdZoomValueMedium:
+ uiZoom = EAknUiZoomNormal;
+ break;
+ case EMceCmdZoomValueSmall:
+ uiZoom = EAknUiZoomSmall;
+ break;
+ }
+
+ TAknUiZoom previousZoom = ZoomLevelChangedL( uiZoom );
+ if ( previousZoom != uiZoom )
+ {
+ WriteZoomLevelL( uiZoom );
+ }
+ }
+
+// ---------------------------------------------------------
+// CMceUi::HandleZoomSubMenu
+// ---------------------------------------------------------
+void CMceUi::HandleZoomSubMenu( CEikMenuPane* aMenuPane )
+ {
+ TAknUiZoom currentLevel = LocalUiZoom();
+ TInt buttonId = EMceCmdZoomValueAutomatic;
+ switch ( currentLevel )
+ {
+ default:
+ case EAknUiZoomAutomatic:
+ buttonId = EMceCmdZoomValueAutomatic;
+ break;
+ case EAknUiZoomLarge:
+ buttonId = EMceCmdZoomValueLarge;
+ break;
+ case EAknUiZoomNormal:
+ buttonId = EMceCmdZoomValueMedium;
+ break;
+ case EAknUiZoomSmall:
+ buttonId = EMceCmdZoomValueSmall;
+ break;
+ }
+ aMenuPane->SetItemButtonState( buttonId, EEikMenuItemSymbolOn );
+ }
+
+// ----------------------------------------------------
+// CMceUi::ForwardL
+//
+// ----------------------------------------------------
+void CMceUi::ForwardL(TInt /*aForwardCommand*/)
+ {
+ MCELOGGER_ENTERFN( "MceUi::ForwardL()----Start>>>>" );
+
+ LeaveIfDiskSpaceUnderCriticalLevelL( iDiskSpaceForMoveOrCopy );
+
+ if ( MceViewActive( EMceMainViewActive ) )
+ {
+ return;
+ }
+
+ CMsvEntrySelection * selection = iMceListView->ListContainer()->CurrentItemSelectionL();
+ CleanupStack::PushL( selection );
+ if ( selection->Count() <= 0)
+ {
+ CleanupStack::PopAndDestroy( selection );
+ return;
+ }
+
+ TMsvEntry entry;
+ TMsvId serviceId;
+ User::LeaveIfError( iSession->GetEntry(selection->At(0),serviceId,entry) );
+ CleanupStack::PopAndDestroy( selection );
+
+ TMsvPartList parts = KMsvMessagePartBody | KMsvMessagePartOriginator | KMsvMessagePartDescription | KMsvMessagePartAttachments;
+
+ CBaseMtmUi& ui=iMtmStore->GetMtmUiAndSetContextLC( entry );
+ ui.SetPreferences( ui.Preferences() | EMtmUiFlagEditorPreferEmbedded );
+ CAknInputBlock::NewLC();
+ CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( singleOpWatcher );
+
+ CMsvOperation* oper = ui.ForwardL(
+ KMsvDraftEntryIdValue, parts, singleOpWatcher->iStatus );
+
+ CleanupStack::PushL( oper );
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( 2, singleOpWatcher ); // oper
+ singleOpWatcher->SetOperation( oper );
+ MCELOGGER_WRITE_FORMAT( "iOperations.AppendL(%d)", oper->Id() );
+ CleanupStack::PopAndDestroy( 2 ); // CAknInputBlock, ui
+
+ MCELOGGER_LEAVEFN( "MceUi::ForwardL()----End<<<<" );
+
+ }
+
+// ----------------------------------------------------
+// CMceUi::HandleNewMsgToInboxL
+// Remove New Flag from selected message(s) if there is any
+// From 5.0
+// ----------------------------------------------------
+void CMceUi::HandleNewMsgToInboxL( TBool removeNewFlag, CMsvEntrySelection* aSelection )
+ {
+ TMsvEntry aEntry;
+
+ if ( !removeNewFlag && ( !iIdArray ) )
+ {
+ return;
+ }
+ else if( removeNewFlag )
+ {
+ if ( iIdArray )
+ {
+ delete iIdArray;
+ iIdArray = NULL;
+ }
+ iIdArray = new ( ELeave ) CMsvEntrySelection;
+ for (TInt i = 0; i < aSelection->Count(); ++i )
+ {
+ TMsvId selectedId = aSelection->At(i);
+ iEntry->SetEntryL( selectedId );
+ aEntry = iEntry->Entry();
+ if ( aEntry.Unread() )
+ {
+ iIdArray->AppendL( selectedId );
+ aEntry.SetUnread( EFalse );
+ iEntry->ChangeL( aEntry );
+ }
+ }
+ if ( iIdArray->Count() )
+ {
+ iHandleNewMsgToInbox = ETrue;
+ }
+ }
+ else
+ {
+ for ( TInt i = 0; i < iIdArray->Count(); ++i )
+ {
+ iEntry->SetEntryL( iIdArray->At(i) );
+ aEntry = iEntry->Entry();
+ aEntry.SetUnread( ETrue );
+ iEntry->ChangeL( aEntry );
+ }
+ delete iIdArray;
+ iIdArray = NULL;
+ iHandleNewMsgToInbox = EFalse;
+ }
+ }
+
+
+// ----------------------------------------------------
+// TBool CMceUi::HasNewEmailL
+// Check if there is new email the the folder
+// public
+// ----------------------------------------------------
+TBool CMceUi::HasNewEmailL( TMsvId aFolderId )
+ {
+ CMsvEntry* entry = iSession->GetEntryL( aFolderId );
+ CleanupStack::PushL( entry );
+
+ TBool newEmail = EFalse;
+ const TInt count = entry->Count();
+ for ( TInt loop = 0; loop < count ; loop++ )
+ {
+ if ( (*entry)[loop].iType.iUid != KUidMsvFolderEntryValue )
+ {
+ if ( (*entry)[loop].New() )
+ {
+ newEmail = ETrue;
+ break;
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( entry );
+ return newEmail;
+ }
+
+// ----------------------------------------------------
+// void CMceUi::SetDiskSpaceForMoveOrCopyL
+// Reads critical and warning levels from cenrep
+// ----------------------------------------------------
+void CMceUi::SetDiskSpaceForMoveOrCopyL( )
+ {
+ // If can't open cenrep use default value
+ iDiskSpaceForMoveOrCopy = KMceDiskSpaceForMoveOrCopy;
+ TInt diskWarningThreshold = 0;
+ TInt diskCriticalThreshold = 0;
+
+ CRepository* repository = NULL;
+ TRAPD( ret, repository = CRepository::NewL( KCRUidUiklaf ) );
+
+ if ( ret == KErrNone )
+ {
+ CleanupStack::PushL( repository );
+ if ( repository->Get( KUikOODDiskWarningThreshold,
+ diskWarningThreshold ) == KErrNone &&
+ repository->Get( KUikOODDiskCriticalThreshold,
+ diskCriticalThreshold ) == KErrNone )
+ {
+ iDiskSpaceForMoveOrCopy = diskWarningThreshold
+ - diskCriticalThreshold;
+ }
+ CleanupStack::PopAndDestroy( repository );
+ }
+
+ }
+// ----------------------------------------------------
+// CMceUi::LaunchUniEditorL
+// ----------------------------------------------------
+//
+void CMceUi::LaunchUniEditorL()
+ {
+ //KUidUniMtm 0x102072D6
+ CreateNewMessageL( KSenduiMtmUniMessageUidValue );
+ }
+
+// ----------------------------------------------------
+// CMceUi::GetToBeCreatedEmailType
+// ----------------------------------------------------
+//
+ TInt CMceUi::GetToBeCreatedEmailType ()
+ {
+ // not sure if it's save
+ TInt messageType = KErrNone;
+ if ( MceViewActive( EMceMessageViewActive ) && iMceListView )
+ {
+ const TMsvEntry& entry = iMceListView->ListContainer()->FolderEntry();
+ if ( entry.iMtm == KSenduiMtmImap4Uid
+ || entry.iMtm == KSenduiMtmPop3Uid )
+ {
+ messageType = KSenduiMtmSmtpUidValue;
+ }
+ else
+ {
+ messageType = entry.iMtm.iUid;
+ }
+ }
+ return messageType;
+ }
+
+// ----------------------------------------------------
+// CMceUi::HideOrExit
+// ----------------------------------------------------
+void CMceUi::HideOrExit()
+ {
+ SetDontExitOnNextOperationComplete();
+ iMceUiFlags.ClearMceFlag( EMceUiFlagsWantToExit );
+ if (ExitHidesInBackground())
+ {
+ // Always use exit effect even if this is actually application switch
+ // Note: Not allowed to call GfxTransEffect::EndFullScreen() as AVKON takes care of that when
+ // EApplicationExit context is used!
+ // Set effect begin point
+ GfxTransEffect::BeginFullScreen( AknTransEffect::EApplicationExit, TRect(),
+ AknTransEffect::EParameterType, AknTransEffect::GfxTransParam(TUid::Uid( KMceApplicationUidValue )) );
+
+ ResetAndHide();
+ }
+ else
+ {
+ CAknEnv::RunAppShutter();
+ }
+ }
+
+// ----------------------------------------------------
+// CMceUi::ResetAndHide
+// ----------------------------------------------------
+void CMceUi::ResetAndHide()
+ {
+ SetCustomControl(1); // Disable bring-to-foreground on view activation
+ TRAP_IGNORE( CAknViewAppUi::CreateActivateViewEventL( \
+ KMessagingCentreMainViewUid, \
+ TUid::Uid(KMceHideInBackground), \
+ KNullDesC8 ) ) ;
+ HideInBackground();
+ }
+void CMceUi::OpenMtmMailboxViewL( const TMsvEntry& aEntry )
+ {
+ CBaseMtmUi& mtmUi=iMtmStore->GetMtmUiAndSetContextLC( aEntry );
+
+ CMsvSingleOpWatcher* singleOpWatcher=CMsvSingleOpWatcher::NewL( *this );
+ CleanupStack::PushL( singleOpWatcher );
+
+ CMsvOperation* op = NULL;
+ TRAPD( error, ( op=mtmUi.OpenL(singleOpWatcher->iStatus ) ) );
+
+ CleanupStack::PushL( op );
+ iOperations.AppendL( singleOpWatcher );
+ CleanupStack::Pop( op );
+ CleanupStack::Pop( singleOpWatcher );
+
+ singleOpWatcher->SetOperation( op );
+
+ // Destroys mtmUi object insted of PopAndDestroy
+ iMtmStore->ReleaseMtmUi( mtmUi.Type() );
+ }
+
+// ----------------------------------------------------
+// CMceUi::FindMtmInVisibleListL
+// ----------------------------------------------------
+TBool CMceUi::FindMtmInVisibleListL( TUid aMtm, CArrayFix<TUid>& aListItemUids )
+ {
+ for ( TInt i = 0 ; i < aListItemUids.Count() ; i++)
+ {
+ if( aMtm == aListItemUids[i] )
+ {
+ return ETrue;
+ }
+ }
+ return EFalse;
+ }
+// ----------------------------------------------------
+// CMceUi::GetMsgDeletedStatus
+// ----------------------------------------------------
+TInt CMceUi::GetMsgDeletedStatus()
+ {
+ return iMsgDeletedStatus;
+ }
+// ----------------------------------------------------
+// CMceUi::SetMsgDeletedStatus
+// ----------------------------------------------------
+void CMceUi::SetMsgDeletedStatus(TBool aStatus)
+ {
+ iMsgDeletedStatus = aStatus;
+ }
+
+// ----------------------------------------------------
+// CMceUi::GetFsIntegratedEmailAppMtmPluginId
+// ----------------------------------------------------
+TUid CMceUi::GetFsIntegratedEmailAppMtmPluginId()
+ {
+ TUid uidMsgValTypeEmailMtmVal = TUid::Uid(0);
+ if ( (iEmailClientIntegration )&& (!iEmailFramework))
+ {
+ CRepository* repository = NULL;
+ TInt mtmPluginID = 0;
+ TRAPD( ret, repository = CRepository::NewL(
+ KCRUidSelectableDefaultEmailSettings ) );
+
+ if ( ret == KErrNone )
+ {
+ // Get Email application mtm plugin ID
+ repository->Get( KIntegratedEmailAppMtmPluginId, mtmPluginID );
+ }
+ delete repository;
+ uidMsgValTypeEmailMtmVal = TUid::Uid( mtmPluginID );
+ }
+ return uidMsgValTypeEmailMtmVal;
+ }
+//CR:422-271
+// ----------------------------------------------------
+// CMceUi::PopulateMMSTemplates
+// ----------------------------------------------------
+TInt CMceUi::PopulateMMSTemplates()
+ {
+
+ TInt error = KErrNone;
+ TInt numErrors = 0;
+ TInt errorIncrement = 0;
+
+ //first try if the directory of mms dump exists or not
+ _LIT(KTopDir,"C:\\Private\\1000484b\\");
+
+ _LIT( KWild, "mmsvar" );
+
+ TFindFile finder( iFs );
+ error = finder.FindByDir(KWild,KTopDir);
+
+ if ( error !=KErrNone )
+ {
+ return;
+ }
+ // Reset inactivity timer to keep viewServer from crashing
+ User::ResetInactivityTime();
+
+ TFileName CurrentPath;
+ CurrentPath.Copy( KMmsMessageDumpDirectory );
+
+ TRAP( error, errorIncrement = DecodeAllMMSFromDirectoryL( CurrentPath,KMsvGlobalInBoxIndexEntryId) );
+ numErrors += errorIncrement;
+ if ( error != KErrNone )
+ {
+ //"left with error "
+ numErrors++;
+ error = KErrNone;
+ }
+ if ( errorIncrement > 0 )
+ {
+ //("- returned errors")
+ }
+ User::ResetInactivityTime();
+ return numErrors;
+}
+// ----------------------------------------------------
+// CMceUi::DecodeAllMMSFromDirectoryL
+// ----------------------------------------------------
+TInt CMceUi::DecodeAllMMSFromDirectoryL( TFileName& aFilePath, TMsvId aBoxid /*= KMsvGlobalInBoxIndexEntryId*/ )
+ {
+ TInt numErrors = 0;
+ TInt error = KErrNone;
+ _LIT( KWild, "*" );
+
+ CDir* fileList = NULL;
+ TInt i = 0; // general counter
+ TFileName Filename;
+ TFileName CurrentPath = aFilePath;
+ if ( CurrentPath[CurrentPath.Length()-1] != '\\' )
+ CurrentPath.Append( '\\' );
+ iFs.SetSessionPath( CurrentPath );
+
+ TFindFile finder( iFs );
+ error = finder.FindWildByPath( KWild, NULL, fileList );
+ CleanupStack::PushL( fileList );
+ TInt fileCounter = 0;
+
+ if ( error == KErrNone )
+ {
+ fileCounter = fileList->Count();
+ }
+ TEntry entry;
+
+ if ( error == KErrNone )
+ {
+ for ( i = 0; i < fileCounter; i++ )
+ {
+ // Reset inactivity timer to keep viewServer from crashing
+ User::ResetInactivityTime();
+ entry = (*fileList)[i]; // name is entry.iName
+ Filename.Copy( entry.iName );
+ if (!entry.IsDir())
+ {
+ TRAP( error, DecodeMMSFromFileL( Filename, aBoxid ));
+ if ( error != KErrNone )
+ {
+ //There are errors in decoding the files
+ }
+ iFs.Delete(entry.iName);
+ }
+
+ }
+
+ }
+
+ CleanupStack::PopAndDestroy(); // fileList
+ fileList = NULL;
+
+ return numErrors;
+ }
+// ----------------------------------------------------
+// CMceUi::DecodeFromFileL
+// ----------------------------------------------------
+TInt CMceUi::DecodeMMSFromFileL( TFileName& aFilePath, TMsvId aBoxId /* KMsvGlobalInBoxIndexEntryId*/, TUint32 aFlags /*= 0*/ )
+ {
+ TInt numErrors = 0;
+ TInt error = KErrNone;
+ TMsvId id;
+
+ FillBufferFromFileL( aFilePath, iFs, iEncodeBuffer );
+
+ CMmsCodecClient* codecClient = CMmsCodecClient::NewL( *iSession );
+ CleanupStack::PushL( codecClient );
+
+ TBool unread = EFalse;
+
+ TRAP( error, codecClient->InitializeChunkedAddingL( aBoxId, id, aFlags, unread ) );
+ if ( error != KErrNone )
+ {
+ numErrors++;
+ }
+
+ if ( error == KErrNone )
+ {
+ error = FeedDataInChunks( codecClient );
+ }
+
+ if ( error != KErrNone )
+ {
+ numErrors++;
+ }
+
+ // Not needed can be cleaned up
+ CMsvEntry* cEntry = iSession->GetEntryL( id );
+ TMsvEntry entry = cEntry->Entry();
+
+ entry.SetReadOnly(ETrue);
+ entry.iServiceId = KMsvLocalServiceIndexEntryId;
+ entry.iMtmData1 = KMmsMessageMRetrieveConf | KMmsMessageMobileTerminated;
+ entry.SetUnread(EFalse);
+
+
+ cEntry->ChangeL(entry);
+ CleanupStack::PopAndDestroy( codecClient );
+
+ return numErrors;
+ }
+// ----------------------------------------------------
+// CMceUi::FeedDataInChunks
+// ----------------------------------------------------
+TInt CMceUi::FeedDataInChunks( CMmsCodecClient* aCodecClient )
+ {
+
+ TInt error = KErrNone;
+ TInt chunkSize = KMmsCodecClientChunkSize;
+ TInt size = iEncodeBuffer->Size();
+
+ // Number of full chunks
+ TInt chunkNumber = size / chunkSize;
+ TInt remainder = size % chunkSize;
+
+ TInt pos = 0;
+ TPtrC8 messagePtr( iEncodeBuffer->Ptr( 0 ) );
+
+ TBool lastChunk = EFalse;
+ TInt i = 0;
+ for ( i = 0; i < chunkNumber && error == KErrNone; i++ )
+ {
+ pos = i * chunkSize;
+ TPtrC8 ptr( iEncodeBuffer->Ptr( 0 ).Mid( pos, chunkSize ) );
+ error = aCodecClient->NextDataPart( ptr, lastChunk );
+ }
+
+ // last chunk
+ if ( remainder > 0 && error == KErrNone )
+ {
+ TPtrC8 ptr2( iEncodeBuffer->Ptr( size - remainder ) );
+ if ( ptr2.Length() > 0 )
+ {
+ error = aCodecClient->NextDataPart( ptr2, lastChunk );
+ }
+ }
+
+ lastChunk = ETrue;
+ TPtrC8 ptr3;
+ if ( error == KErrNone )
+ {
+ aCodecClient->NextDataPart( ptr3, lastChunk );
+ }
+ return error;
+
+ }
+// ----------------------------------------------------
+// CMceUi::FillBufferFromFileL
+// ----------------------------------------------------
+void CMceUi::FillBufferFromFileL(
+ const TDesC& aFilePath,
+ RFs& aFs,
+ CBufFlat* aEncodeBuffer )
+ {
+ TInt error = KErrNone;
+ TEntry orgEntry;
+ error = aFs.Entry( aFilePath, orgEntry );
+ TInt size = orgEntry.iSize;
+ RFile inFile;
+ if ( aEncodeBuffer == NULL )
+ {
+ aEncodeBuffer = CBufFlat::NewL( size );
+ }
+ else
+ {
+ aEncodeBuffer->ResizeL( 0 );
+ aEncodeBuffer->ResizeL( size );
+ }
+
+ error = inFile.Open( aFs, aFilePath, EFileShareReadersOnly );
+
+ TPtr8 ptr = aEncodeBuffer->Ptr( 0 );
+ if ( error == KErrNone )
+ {
+ error = inFile.Read( ptr, size );
+ inFile.Close();
+ }
+ else
+ {
+ //"*** - can't read file"
+ }
+ User::LeaveIfError( error );
+
+ }
+//CR:422-271
+// end of file
+
+// end of file