diff -r ebe688cedc25 -r 7fdbb852d323 mobilemessaging/mmsui/notmtmsrc/NotMtmUi.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mobilemessaging/mmsui/notmtmsrc/NotMtmUi.cpp Wed Sep 01 12:31:54 2010 +0100 @@ -0,0 +1,1582 @@ +/* +* Copyright (c) 2004 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: +* Provides Notification MTM UI methods. +* +*/ + + + +// INCLUDE FILES + +//Features +#include +#include +#include // CMsvProgressReporterOperation +#include // MTM UI data registry +#include // MTM UI data base + +#include "NotMtmUi.h" + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include //CErrorUI + +#include // CAknInformationNote +#include +#include +#include +#include +#include +#include +#include // link against CommonEngine.lib +#include +#include +#include + +#include // CAknInputBlock +#include +#include + +#include // link against centralrepository.lib +#include // for Central Repository keys +#include + +#include //CApUtils, CCommsDatabase, EDatabaseTypeIAP + +#include +#include + +#include "NotMtmUiPanic.h" +#include +#include // EMmsDeleteSchedule + +#include +#include +#include +#include // MMS Engine settings + +#include "MmsMtmConst.h" +#include "MMBoxDialog.h" +#include "NotMtmUiData.h" + +// CONSTANTS + +_LIT( KAddressSeparator,", " ); +_LIT( KCharLeftAddressIterator, "<" ); +_LIT( KCharRightAddressIterator, ">" ); +_LIT( KMmsCharCommaAndSpace, ", " ); +_LIT( KMmsCharSpace, " " ); + +const TInt KMessageSize = 20; +const TInt KZero = 0; //constant for memory check +const TInt KMmsAdditionalCharsStringLength = 7; +const TUint KMmsLRMarker = 0x200E; +const TUid KUidUniEditor = {0x102072D8}; + +#define IS_PHONE_OFF_LINEL() MsvUiServiceUtilitiesInternal::IsPhoneOfflineL() + +// MACROS +#define iMmsClient ( static_cast( iBaseMtm ) ) + +// LOCAL CONSTANTS AND MACROS + +// MODULE DATA STRUCTURES + +// LOCAL FUNCTION PROTOTYPES + +// ==================== LOCAL FUNCTIONS ==================== + +// --------------------------------------------------------- +// NewNotMtmUiL +// Factory function +// --------------------------------------------------------- +// +EXPORT_C CBaseMtmUi* NewNotMtmUiL( CBaseMtm& aMtm, CRegisteredMtmDll& aRegisteredDll ) + { + return CNotMtmUi::NewL( aMtm, aRegisteredDll ); + } + + +// ================= MEMBER FUNCTIONS ======================= + +// --------------------------------------------------------- +// CNotMtmUi::CNotMtmUi +// C++ default constructor can NOT contain any code, that +// might leave. +// --------------------------------------------------------- +// +CNotMtmUi::CNotMtmUi( CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll ) + : CBaseMtmUi( aBaseMtm, aRegisteredMtmDll ) + { + } + +// --------------------------------------------------------- +// CNotMtmUi::ConstructL +// Symbian OS default constructor can leave. +// --------------------------------------------------------- +// +void CNotMtmUi::ConstructL() + { + LOGTEXT(_L8("NotMtmUi: Construct start")); + CBaseMtmUi::ConstructL(); + iSettingsHandler = CMmsSettingsHandler::NewL( iMmsClient ); + + TInt featureBitmask = 0; + + CRepository* repository = CRepository::NewL( KCRUidMuiuVariation ); + repository->Get( KMuiuMmsFeatures, featureBitmask ); + delete repository; + repository = NULL; + + if ( featureBitmask & KMmsFeatureIdDeleteOptions ) + { + iNotUiFlags |= EDeleteOptionsSupported; + } + featureBitmask = 0; + + FeatureManager::InitializeLibL(); + if ( FeatureManager::FeatureSupported( KFeatureIdOfflineMode ) ) + { + iNotUiFlags |= EOffline; + } + FeatureManager::UnInitializeLib(); + LOGTEXT(_L8("NotMtmUi: Construct end")); + } + +// --------------------------------------------------------- +// CNotMtmUi::NewL +// Two-phased constructor. +// --------------------------------------------------------- +// +CNotMtmUi* CNotMtmUi::NewL( CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll ) + { + LOGTEXT( _L8( "NotMtmUi::NewL" ) ); + CNotMtmUi* self = new ( ELeave ) CNotMtmUi( aBaseMtm, aRegisteredMtmDll ); + + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop(); + + return self; + } + + +// --------------------------------------------------------- +// CNotMtmUi::~CNotMtmUi +// Destructor +// --------------------------------------------------------- +// +CNotMtmUi::~CNotMtmUi() + { + delete iSettingsHandler; + delete iWaitDialog; + } + + +// --------------------------------------------------------- +// CNotMtmUi::QueryCapability +// Capability check for UI mtm specific functionality. These should +// be minimal, as the default capability checking places are UI data MTM +// (UI) and client MTM (engine). +// --------------------------------------------------------- +TInt CNotMtmUi::QueryCapability( TUid aCapability, TInt& aResponse ) + { + switch ( aCapability.iUid ) + { + case KUidMsvMtmUiQueryMessagingInitialisation: // flow through + case KUidMsvMtmQueryFactorySettings: + case KUidMsvMtmQuerySupportValidateService: + + aResponse = ETrue; + return KErrNone; + default: + // Actually this routes to client MTM capability check. + return CBaseMtmUi::QueryCapability( aCapability, aResponse ); + } + } + +// --------------------------------------------------------- +// CNotMtmUi::CreateL +// Not supported. +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::CreateL( const TMsvEntry& /*aEntry*/, + CMsvEntry& /*aParent*/, + TRequestStatus& /*aStatus*/ ) + { + User::Leave( KErrNotSupported ); + return NULL; + } + +// --------------------------------------------------------- +// CNotMtmUi::CheckSettingsL() const +// Check MMS service settings +// --------------------------------------------------------- +// +EXPORT_C TBool CNotMtmUi::CheckSettingsL( CMmsSettingsDialog::TMmsExitCode& aExitCode ) const + { + // First reload the settings + iSettingsHandler->RefreshSettingsL( ); + return iSettingsHandler->CheckSettingsL( aExitCode ); + } + +// --------------------------------------------------------- +// CNotMtmUi::DeleteServiceL +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::DeleteServiceL( const TMsvEntry& /*aService*/, + TRequestStatus& /*aStatus*/ ) + { + User::Leave( KErrNotSupported ); + return NULL; + } + +// --------------------------------------------------------- +// CNotMtmUi::DeleteFromL +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::DeleteFromL( const CMsvEntrySelection& /*aSelection*/, + TRequestStatus& /*aStatus*/ ) + { + User::Leave( KErrNotSupported ); + return NULL; + } + +// --------------------------------------------------------- +// CMmsMtmUi::CopyToL +// Copy local outbox entry to remote server = called when sending the entry from MCE outbox +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::CopyToL( const CMsvEntrySelection& aSelection, + TRequestStatus& aStatus ) + { + return CopyMoveToL( aSelection, aStatus, ETrue ); + } + +// --------------------------------------------------------- +// CNotMtmUi::MoveToL +// Move local outbox entry to remote server. +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::MoveToL( const CMsvEntrySelection& aSelection, + TRequestStatus& aStatus ) + { + return CopyMoveToL( aSelection, aStatus, EFalse ); + } + +// --------------------------------------------------------- +// CNotMtmUi::CopyMoveToL +// Performs either CopyToL or MoveToL operation. +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::CopyMoveToL( const CMsvEntrySelection& aSelection, + TRequestStatus& aStatus, TBool aCopyOnly ) + { + __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm==Type(), Panic( EMmsWrongMtm ) ); + __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iType==KUidMsvServiceEntry, Panic( EMmsNotAService ) ); + + // --- Carry out the operation --- + TMsvEntry mmsService ( BaseMtm().Entry().Entry() ); + // Get CMsvEntry of parent of messages to be sent + CMsvEntry* parentEntry = Session().GetEntryL( aSelection[0] ); + + CleanupStack::PushL( parentEntry ); + parentEntry->SetEntryL( parentEntry->Entry().Parent() ); + + // Do the copy/move + CMsvOperation* op = aCopyOnly ? + parentEntry->CopyL( aSelection, mmsService.Id(), aStatus ) : + parentEntry->MoveL( aSelection, mmsService.Id(), aStatus ); + + CleanupStack::PopAndDestroy(); //parentEntry + return op; + } + +// --------------------------------------------------------- +// CNotMtmUi::CopyFromL +// Could be used in fetching messages manually, but client MTM API has simple FetchL() +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::CopyFromL(const CMsvEntrySelection& /*aSelection*/, + TMsvId /*aTargetId*/, + TRequestStatus& /*aStatus*/) + { + User::Leave( KErrNotSupported ); + return NULL; + } + +// --------------------------------------------------------- +// CNotMtmUi::MoveFromL +// Could be used in fetching messages manually, but client MTM API has simple FetchL() +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::MoveFromL(const CMsvEntrySelection& /*aSelection*/, + TMsvId /*aTargetId*/, + TRequestStatus& /*aStatus*/) + { + User::Leave( KErrNotSupported ); + return NULL; + } + +// --------------------------------------------------------- +// CNotMtmUi::OpenL +// Handles request to open existing message server entry (message/service) +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::OpenL( TRequestStatus& aStatus ) + { + LOGTEXT(_L8("NotMtmUi: OpenL start")); + __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm==Type(), Panic( EMmsWrongMtm ) ); + + const TMsvEntry& entry = BaseMtm().Entry().Entry(); + if ( entry.ReadOnly() ) + { + return ViewL( aStatus ); + } + else + { + return EditL( aStatus ); + } + } + +// --------------------------------------------------------- +// CNotMtmUi::OpenL +// Opens the first entry in a selection +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::OpenL( TRequestStatus& aStatus, + const CMsvEntrySelection& aSelection ) + { + LOGTEXT(_L8("NotMtmUi: OpenL start")); + __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm==Type(), Panic( EMmsWrongMtm ) ); + + BaseMtm().SwitchCurrentEntryL( aSelection[0] ); + return OpenL( aStatus ); + } + +// --------------------------------------------------------- +// CNotMtmUi::CloseL +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::CloseL( TRequestStatus& /*aStatus*/ ) + { + User::Leave( KErrNotSupported ); + return NULL; + } + +// --------------------------------------------------------- +// CNotMtmUi::CloseL +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::CloseL( TRequestStatus& /*aStatus*/, + const CMsvEntrySelection& /*aSelection*/ ) + { + User::Leave( KErrNotSupported ); + return NULL; + } + +// --------------------------------------------------------- +// CNotMtmUi::EditL +// Opens a message (editor) or service (settings dialog) for editing. +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::EditL( TRequestStatus& aStatus ) + { + LOGTEXT(_L8("NotMtmUi::EditL start")); + __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm==Type(), Panic( EMmsWrongMtm ) ); + + CMsvOperation* msvoperation = NULL; + + switch ( iBaseMtm.Entry().Entry().iType.iUid ) + { + case KUidMsvMessageEntryValue: + { + CMmsSettingsDialog::TMmsExitCode exitCode = + CMmsSettingsDialog::EMmsExternalInterrupt; + + if( MsvUiServiceUtilities::DiskSpaceBelowCriticalLevelL( + Session(), + KZero ) ) + { + User::Leave( KErrDiskFull ); + } + + if ( !CheckSettingsL( exitCode ) ) + { + TInt32 ap = iSettingsHandler->MmsSettings()->AccessPoint( 0 ); + //settings saved with valid access point + if( !( exitCode==CMmsSettingsDialog::EMmsBack && ApExistsL( ap ) ) ) + { + return CompleteSettingsOperationL( aStatus, exitCode ); + } + } + + if ( iBaseMtm.Entry().Entry().Connected() ) + { + User::Leave( KErrLocked ); + } + LOGTEXT( _L8( "NotMtmUi::EditL launching editor" ) ); + msvoperation = LaunchEditorApplicationL( aStatus, iBaseMtm.Entry().Session() ); + } + break; + + case KUidMsvServiceEntryValue: + LOGTEXT( _L8( "NotMtmUi::EditL - launching settings" ) ); + msvoperation = OpenServiceSettingsDialogL( aStatus ); + break; + + case KUidMsvAttachmentEntryValue: // flow through + case KUidMsvFolderEntryValue: // flow through + default: + User::Leave( KErrNotSupported ); + break; + } + + return msvoperation; + } + +// --------------------------------------------------------- +// CNotMtmUi::EditL +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::EditL( TRequestStatus& aStatus, + const CMsvEntrySelection& aSelection ) + { + BaseMtm().SwitchCurrentEntryL( aSelection[0] ); + return EditL( aStatus ); + } + +// --------------------------------------------------------- +// CNotMtmUi::ViewL +// Opens the message for reading in Viewer. +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::ViewL( TRequestStatus& aStatus ) + { + LOGTEXT( _L8( "NotMtmUi::ViewL" ) ); + __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm == Type(), Panic( EMmsWrongMtm ) ); + + CMsvOperation* msvoperation = NULL; + + switch ( iBaseMtm.Entry().Entry().iType.iUid ) + { + case KUidMsvMessageEntryValue: + // It's a multimedia message + if ( iBaseMtm.Entry().Entry().Connected() ) + { + User::Leave( KErrLocked ); + } + // Open Viewer + LOGTEXT( _L8( "NotMtmUi::ViewL - launching Viewer" ) ); + msvoperation = LaunchEditorApplicationL( aStatus, iBaseMtm.Entry().Session(), EReadOnly ); + break; + case KUidMsvServiceEntryValue: + case KUidMsvAttachmentEntryValue: + case KUidMsvFolderEntryValue: + default: + User::Leave( KErrNotSupported ); + break; + } + return msvoperation; + } + +// --------------------------------------------------------- +// CNotMtmUi::ViewL +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::ViewL( TRequestStatus& aStatus, + const CMsvEntrySelection& aSelection ) + { + __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm == Type(), Panic( EMmsWrongMtm ) ); + BaseMtm().SwitchCurrentEntryL( aSelection[0] ); + return ViewL( aStatus ); + } + +// ----------------------------------------------------------------------------- +// CNotMtmUi::LaunchEditorApplicationL() +// Does the actual opening. +// ----------------------------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::LaunchEditorApplicationL( TRequestStatus& aStatus, + CMsvSession& aSession, + TEditorType aEditorType ) + { + LOGTEXT(_L8("NotMtmUi: LaunchEditorApplicationL start")); + TEditorParameters temp; + + if ( iBaseMtm.HasContext() ) + { + temp.iId=iBaseMtm.Entry().EntryId(); + } + + TMsvEntry tempEntry = iBaseMtm.Entry( ).Entry(); + + CMtmUiDataRegistry* mtmUiDataReg = CMtmUiDataRegistry::NewL( Session( ) ); + CleanupStack::PushL( mtmUiDataReg ); + + CBaseMtmUiData* uiData=mtmUiDataReg->NewMtmUiDataLayerL( this->Type( ) ) ; + CleanupStack::PushL( uiData ); + + TBool supported = ETrue; + + if( uiData->OperationSupportedL( KMtmUiFunctionOpenMessage, tempEntry ) ) + { // Returns value other than zero if operation is not supported + supported = EFalse; + } + + CleanupStack::PopAndDestroy( 2, mtmUiDataReg ); + + if( !supported ) + { + User::Leave( KErrNotSupported ); + } + + switch( aEditorType ) + { + case EReadOnly: + temp.iFlags|=EMsgReadOnly; + break; + case ECreateNewMessage: + temp.iFlags|=EMsgCreateNewMessage ; + temp.iId=KMsvDraftEntryIdValue; + break; + case EEditExisting: //flow through + default: + break; + }; + + temp.iFlags &= ~( EMtmUiFlagEditorPreferEmbedded|EMtmUiFlagEditorNoWaitForExit ); + + temp.iFlags |= ( Preferences() & EMtmUiFlagEditorPreferEmbedded?EMsgLaunchEditorEmbedded:0 ); + + TPckgC paramPack( temp ); + + LOGTEXT( _L8( "Just before calling MsgEditorLauncher" ) ); + return MsgEditorLauncher::LaunchEditorApplicationL( aSession, Type(), aStatus, temp, KNullDesC(), paramPack ); + } + +// --------------------------------------------------------- +// CNotMtmUi::ForwardL +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::ForwardL( TMsvId aDestination, + TMsvPartList aPartList, + TRequestStatus& aCompletionStatus ) + { + LOGTEXT(_L8("NotMtmUi: ForwardL start")); + TEditorParameters editorParams; + editorParams.iFlags &= ~( EMtmUiFlagEditorPreferEmbedded | EMtmUiFlagEditorNoWaitForExit ); + + editorParams.iFlags |= ( ( Preferences() & EMtmUiFlagEditorPreferEmbedded ) ? EMsgLaunchEditorEmbedded : 0 ); + editorParams.iDestinationFolderId = aDestination; + editorParams.iPartList = aPartList; + + editorParams.iFlags |= EMsgForwardMessage; + editorParams.iId=BaseMtm().Entry().EntryId(); + + //we need to check access points here + CMmsSettingsDialog::TMmsExitCode exitCode = CMmsSettingsDialog::EMmsExternalInterrupt; + if ( !CheckSettingsL( exitCode ) ) + { + TInt32 ap = iSettingsHandler->MmsSettings()->AccessPoint( 0 ); + if( exitCode == CMmsSettingsDialog::EMmsBack && ApExistsL( ap ) ) + { + LOGTEXT( _L8( "NotMtmUi::ForwardL launching editor" ) ); + return MsgEditorLauncher::LaunchEditorApplicationL( Session(), + Type(), + aCompletionStatus, + editorParams, + KNullDesC() ); + } + else//user selects exit and settings not saved + { + return CompleteSettingsOperationL( aCompletionStatus, exitCode ); + } + }//if + + LOGTEXT( _L8( "NotMtmUi::ForwardL launching editor" ) ); + return MsgEditorLauncher::LaunchEditorApplicationL( Session(), + Type(), + aCompletionStatus, + editorParams, + KNullDesC() ); + } + +// --------------------------------------------------------- +// CNotMtmUi::ReplyL +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::ReplyL( TMsvId aDestination, + TMsvPartList aPartList, + TRequestStatus& aCompletionStatus ) + { + LOGTEXT(_L8("NotMtmUi: Reply start")); + TEditorParameters editorParams; + editorParams.iFlags |= EMsgReplyToMessageSender; + editorParams.iId = BaseMtm().Entry().EntryId(); + editorParams.iDestinationFolderId = aDestination; + editorParams.iPartList = aPartList; + editorParams.iSpecialAppId = KUidUniEditor; + editorParams.iFlags &= ~( EMtmUiFlagEditorPreferEmbedded | EMtmUiFlagEditorNoWaitForExit ); + + editorParams.iFlags |= ( ( Preferences() & EMtmUiFlagEditorPreferEmbedded ) ? EMsgLaunchEditorEmbedded : 0 ); + + //we need to check access points here + CMmsSettingsDialog::TMmsExitCode exitCode = CMmsSettingsDialog::EMmsExternalInterrupt; + if ( !CheckSettingsL( exitCode ) ) + { + TInt32 ap = iSettingsHandler->MmsSettings()->AccessPoint( 0 ); + if( exitCode == CMmsSettingsDialog::EMmsBack && ApExistsL( ap ) ) + { + LOGTEXT( _L8( "NotMtmUi::ReplyL launching editor" ) ); + return MsgEditorLauncher::LaunchEditorApplicationL( Session(), + Type(), + aCompletionStatus, + editorParams, + KNullDesC() ); + } + else//user selects exit and settings not saved + { + return CompleteSettingsOperationL( aCompletionStatus, exitCode ); + } + } + + //Setting the entry always to read as done for sms + if ( BaseMtm().Entry().Entry().Unread() ) + { + CMsvEntry* cEntry; + cEntry = &(BaseMtm().Entry()); + TMsvEntry entry = cEntry->Entry(); + entry.SetUnread( EFalse ); + cEntry->ChangeL( entry ); + } + + LOGTEXT( _L8( "NotMtmUi::ReplyL launching editor" ) ); + return MsgEditorLauncher::LaunchEditorApplicationL( Session(), + Type(), + aCompletionStatus, + editorParams, + KNullDesC() ); + } + +// --------------------------------------------------------- +// CNotMtmUi::CancelL +// Suspends sending of the selected messages (if possible) +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::CancelL( TRequestStatus& aStatus, + const CMsvEntrySelection& aSelection ) + { + TInt count = aSelection.Count(); + __ASSERT_DEBUG( count, Panic( EMmsWrongParameters ) ); + + CMsvEntry* entry = Session().GetEntryL( aSelection[0] ); + CleanupStack::PushL( entry ); + + while ( count-- ) + { + entry->SetEntryL( aSelection[count] ); + TMsvEntry tempEntry = entry->Entry(); + tempEntry.SetSendingState( KMsvSendStateSuspended ); + + tempEntry.iDate.UniversalTime(); + + entry->ChangeL( tempEntry ); + } + + CleanupStack::PopAndDestroy(); // entry + + TBuf8<1> dummyParams; + dummyParams.Zero(); + return CBaseMtmUi::InvokeAsyncFunctionL( EMmsDeleteSchedule, aSelection, aStatus, dummyParams ); + } + +// --------------------------------------------------------- +// CNotMtmUi::InvokeSyncFunctionL +// --------------------------------------------------------- +// +void CNotMtmUi::InvokeSyncFunctionL( TInt aFunctionId, + const CMsvEntrySelection& aSelection, + TDes8& aParameter ) + { + LOGTEXT(_L8("NotMtmUi: InvokeSyncFuntionL start")); + switch ( aFunctionId ) + { + case KMtmUiMessagingInitialisation: + LOGTEXT(_L8("NotMtmUi: InvokeSyncFuntionL MsgIni")); + CreateDefaultSettingsL(); + break; + case KMtmUiFunctionRestoreFactorySettings: + LOGTEXT(_L8("NotMtmUi: InvokeSyncFuntionL FactorySetts")); + HandleFactorySettingsL( aParameter ); + break; + case KMtmUiFunctionValidateService: + { + LOGTEXT(_L8("NotMtmUi: InvokeSyncFuntionL ValidateService")); + iSettingsHandler->RefreshSettingsL( ); + TInt error = iSettingsHandler->MmsSettings()->ValidateSettings(); + // return the result via aParameter as a TInt packaged into a TDes8 + TPckgBuf resultPackage( error ); + aParameter.Copy( resultPackage ); + } + break; + default: + CBaseMtmUi::InvokeSyncFunctionL( aFunctionId, aSelection, aParameter ); + break; + } + LOGTEXT(_L8("NotMtmUi: InvokeSyncFunctionL end")); + } + +// --------------------------------------------------------- +// CNotMtmUi::InvokeAsyncFunctionL +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::InvokeAsyncFunctionL( TInt aFunctionId, + const CMsvEntrySelection& aSelection, + TRequestStatus& aCompletionStatus, + TDes8& aParameter ) + { + LOGTEXT(_L8("NotMtmUi: InvokeAsyncFuntionL start")); + CMsvOperation* msvoperation = NULL; + switch ( aFunctionId ) + { + case KMtmUiFunctionMessageInfo: + LOGTEXT(_L8("NotMtmUi: InvokeAsyncFuntionL MsgInfo")); + msvoperation = OpenMessageInfoL( aCompletionStatus, aParameter ); + break; + case KMtmUiFunctionMMBox: + LOGTEXT(_L8("NotMtmUi: InvokeAsyncFuntionL MMBox")); + msvoperation = OpenMMBoxDialogL( aCompletionStatus ); + break; + case KMtmUiFunctionFetchMMS: + LOGTEXT(_L8("NotMtmUi: InvokeAsyncFuntionL Fetch")); + if( iNotUiFlags & EOffline + && IS_PHONE_OFF_LINEL() ) + { // We are in offline at the moment -> Infonote + ShowInformationNoteL( R_NOTMTM_OFFLINE_NOT_POSSIBLE, EFalse ); + break; + } + msvoperation = StartFetchingL( aSelection, aCompletionStatus ); + break; + case KMtmUiFunctionDeleteMessage: + LOGTEXT(_L8("NotMtmUi: InvokeAsyncFuntionL Delete")); + msvoperation = StartDeletingL( aSelection, aCompletionStatus ); + break; + default: + break; + } + LOGTEXT(_L8("NotMtmUi: InvokeAsyncFuntionL end")); + return msvoperation; + } + +// --------------------------------------------------------- +// CNotMtmUi::DisplayProgressSummary +// --------------------------------------------------------- +// +TInt CNotMtmUi::DisplayProgressSummary( const TDesC8& /* aProgress */ ) const + { + // This does nothing, because MsgErrorWatcher shows all MMS error messages. + // Furthermore currently MMS engine does not return any sensible progress to report. + return KErrNone; + } + +// --------------------------------------------------------- +// CNotMtmUi::GetResourceFileName +// --------------------------------------------------------- +// +void CNotMtmUi::GetResourceFileName( TFileName& aFileName ) const + { + aFileName = KNotMtmResourceFile; + } + +// --------------------------------------------------------- +// CNotMtmUi::CreateDefaultSettingsL +// --------------------------------------------------------- +// +void CNotMtmUi::CreateDefaultSettingsL() + { + // done in engine by FactorySettings + } + +// --------------------------------------------------------- +// CNotMtmUi::HandleFactorySettingsL +// Reset Factory Settings support +// --------------------------------------------------------- +EXPORT_C void CNotMtmUi::HandleFactorySettingsL( TDes8& aLevel ) + { + iSettingsHandler->HandleFactorySettingsL( aLevel ); + } + +// --------------------------------------------------------- +// CNotMtmUi::DeleteFromQuery() +// Queries from the user where the notifications +// or messages are being deleted from +// --------------------------------------------------------- +TInt CNotMtmUi::DeleteFromQueryL( TInt& result ) + { + LOGTEXT(_L8("NotMtmUi: DeleteFromQuery start")); + TInt index = 0; + CAknListQueryDialog* dlg = new (ELeave) CAknListQueryDialog( &index ); + dlg->PrepareLC( R_NOTUI_DELETE_FROM_QUERY ); + + // Populate list query array + CDesCArrayFlat *array = new(ELeave) CDesCArrayFlat(3); + CleanupStack::PushL(array); + HBufC* buf = StringLoader::LoadLC( R_NOTMTM_DELETE_QUERY_BOTHLOCALANDREMOTE ); + array->AppendL( *buf ); + CleanupStack::PopAndDestroy(); //buf + buf = StringLoader::LoadLC( R_NOTMTM_DELETE_QUERY_LOCALONLY ); + array->AppendL( *buf ); + CleanupStack::PopAndDestroy(); //buf + buf = StringLoader::LoadLC( R_NOTMTM_DELETE_QUERY_REMOTEONLY ); + array->AppendL( *buf ); + CleanupStack::PopAndDestroy(); //buf + dlg->SetItemTextArray( array ); + CleanupStack::Pop(); //array + + TInt queryOk = dlg->RunLD(); + if( queryOk ) + { + /* list query approved, index is usable to see what list item was selected */ + switch( index ) + { + case 0: + result = EMmsDeleteBoth; + break; + case 1: + result = EMmsDeleteNotificationOnly; + break; + case 2: + default: + result = EMmsDeleteMMBoxOnly; + break; + }; + } + else + { + /* list query cancelled, index is unusable */ + } + LOGTEXT(_L8("NotMtmUi: DeleteFromQueryL end")); + return queryOk; + } + +// --------------------------------------------------------- +// CMsvOperation* CNotMtmUi::OpenServiceSettingsDialogL(TRequestStatus& aCompletionStatus) +// Handles MMS service settings +// --------------------------------------------------------- +// +EXPORT_C CMsvOperation* CNotMtmUi::OpenServiceSettingsDialogL( TRequestStatus& aCompletionStatus ) + { + return iSettingsHandler->OpenServiceSettingsDialogL( aCompletionStatus ); + } + +// --------------------------------------------------------- +// CheckSettingsL +// --------------------------------------------------------- +// +TBool CNotMtmUi::CheckSettingsL( ) + { + CMmsSettingsDialog::TMmsExitCode exitCode = CMmsSettingsDialog::EMmsExternalInterrupt; + if ( !CheckSettingsL( exitCode ) ) + { + TInt32 ap = iSettingsHandler->MmsSettings()->AccessPoint( 0 ); + if( !( exitCode==CMmsSettingsDialog::EMmsBack && ApExistsL( ap ) ) ) + { + return EFalse; + } + } + return ETrue; + } + +// --------------------------------------------------------- +// CMsvOperation* CNotMtmUi::CompleteSettingsOperationL( +// TRequestStatus& aCompletionStatus, const CMmsSettingsDialog::TMmsExitCode& aExitCode) +// Creates completed operation after settings dialog closing with appropriate parameters. +// --------------------------------------------------------- +// +EXPORT_C CMsvOperation* CNotMtmUi::CompleteSettingsOperationL( + TRequestStatus& aCompletionStatus, + const CMmsSettingsDialog::TMmsExitCode& aExitCode /* = CMmsSettingsDialog::EMmsExternalInterrupt */ ) + { + return iSettingsHandler->CompleteSettingsOperationL( + aCompletionStatus, + aExitCode ); + } + +// --------------------------------------------------------- +// TInt CNotMtmUi::LaunchSettingsDialogL( +// CMmsSettingsDialog::TMmsExitCode& aExitCode ) +// Opens either MMS Service Settings or MMS Sending Settings dialog. +// --------------------------------------------------------- +// +EXPORT_C void CNotMtmUi::LaunchSettingsDialogL( + CMmsSettingsDialog::TMmsExitCode& aExitCode ) const + { + iSettingsHandler->LaunchSettingsDialogL( aExitCode ); + } + + +// --------------------------------------------------------- +// CNotMtmUi::OpenMessageInfoL(TRequestStatus& aCompletionStatus, TDes8& aParameter) +// Opens the Message Info popup. +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::OpenMessageInfoL( TRequestStatus& aCompletionStatus, + TDes8& /*aParameter*/ ) + { + LOGTEXT( _L8( "NotMtmUi OpenMessageInfo start" ) ); + TInt popCount( 0 ); + + // The items for Info are read from the message entry. + // Note: Most of the stuff is in TMsvEntry, but not all -> MMS entry used all the way. + TMmsMsvEntry entry = static_cast( BaseMtm().Entry().Entry() ); + __ASSERT_DEBUG( entry.iType==KUidMsvMessageEntry, Panic( EMmsNotAMessage ) ); + __ASSERT_DEBUG( entry.iMtm==Type(), Panic( EMmsWrongMtm ) ); + + iMmsClient.LoadMessageL(); + + TMsgInfoMessageInfoData infoData; + + // From - show only for received messages + if ( entry.IsMobileTerminated() ) + { + HBufC* senderNumber = iMmsClient.Sender().AllocLC(); + popCount++; + // Additional space for chars: '<' '>' ',' + 2 x KMmsLRMarker + HBufC* fromText = HBufC::NewLC( entry.iDetails.Length() + senderNumber->Length() + KMmsAdditionalCharsStringLength ); + popCount++; + + // Do we have alias? + if ( senderNumber->Compare( entry.iDetails ) ) + { // yes + TPtr fromTextPtr = fromText->Des(); + fromTextPtr.Append( entry.iDetails ); + fromTextPtr.Append( KMmsCharSpace ); + fromTextPtr.Append( KMmsLRMarker ); + fromTextPtr.Append( KCharLeftAddressIterator ); + fromTextPtr.Append( TMmsGenUtils::PureAddress( senderNumber->Des( ) ) ); + fromTextPtr.Append( KCharRightAddressIterator ); + fromTextPtr.Append( KMmsLRMarker ); + infoData.iFrom.Set( *fromText ); + } + else + { // no + infoData.iFrom.Set( *senderNumber ); + } + } + + // Subject + infoData.iSubject.Set( iMmsClient.SubjectL() ); + + // Supply UTC date-time to message info + infoData.iDateTime = entry.iDate; + + // Type of message -taken directly from resources as this must be a multimedia message + HBufC* msgType = StringLoader::LoadLC( R_NOT_TYPE_TEXT, iCoeEnv ); + popCount++; + infoData.iType.Set( msgType->Des() ); + + // Priority of message + HBufC* priority = NULL; + switch ( iMmsClient.MessagePriority() ) + { + case EMmsPriorityHigh: + { + priority = StringLoader::LoadLC( R_MMS_MESSAGE_PRIORITY_HIGH, iCoeEnv ); + popCount++; + infoData.iPriority.Set( *priority); + break; + } + case EMmsPriorityLow: + { + priority = StringLoader::LoadLC( R_MMS_MESSAGE_PRIORITY_LOW, iCoeEnv ); + popCount++; + infoData.iPriority.Set( *priority); + break; + } + case EMmsPriorityNormal: + { + priority = StringLoader::LoadLC( R_MMS_MESSAGE_PRIORITY_NORMAL, iCoeEnv ); + popCount++; + infoData.iPriority.Set( *priority); + break; + } + default: // Do not show the priority if it's not set + break; + } + + // Size of message. + TInt size = iMmsClient.MessageTransferSize( ); + TInt maxSize = static_cast( + iSettingsHandler->MmsSettings()->MaximumReceiveSize() ); + + if( maxSize > 0 ) + { + if( size > maxSize ) + { + size = maxSize; + } + } + + // Finally make the UI string + TBuf sizeString; + MessageSizeToStringL( sizeString, size ); + infoData.iSize.Set( sizeString ); + + // To + const CMsvRecipientList& recipients = iMmsClient.AddresseeList(); + TInt count = recipients.Count(); + TPtrC separatorPtr( KAddressSeparator ); + + // Calculate size needed + TInt index; + TInt toSize = 0; + + for ( index = 0; index < count; index++ ) + { + toSize += recipients[index].Length(); + if ( index < ( count - 1 ) ) + { // not the last address, add separator space + toSize += separatorPtr.Length(); + } + } + + if ( toSize ) + { + // Form the to-string + HBufC* toList = TurnRecipientsArrayIntoStringLC( recipients ); + popCount++; + infoData.iTo.Set( *toList ); + } + + CMsgInfoMessageInfoDialog* infoDialog = CMsgInfoMessageInfoDialog::NewL(); + + if ( entry.IsMobileTerminated() ) + { + infoDialog->ExecuteLD( infoData, CMsgInfoMessageInfoDialog::EMmsViewer ); + } + else + { + infoDialog->ExecuteLD( infoData, CMsgInfoMessageInfoDialog::EMmsEditor ); + } + + CleanupStack::PopAndDestroy( popCount ); + return CMsvCompletedOperation::NewL( Session(), + KUidMsvLocalServiceMtm, + KNullDesC8, + KMsvLocalServiceIndexEntryId, + aCompletionStatus ); + } + + +// --------------------------------------------------------- +// CNotMtmUi::OpenMMBoxDialogL +// Opens the MMBox Dialog +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::OpenMMBoxDialogL( TRequestStatus& aCompletionStatus ) + { + LOGTEXT( _L8( "NotMtmUi OpenMMBoxDialog start" ) ); + + TInt exitCode; + + CMtmUiDataRegistry* mtmUiDataReg = CMtmUiDataRegistry::NewL( Session( ) ); + CleanupStack::PushL( mtmUiDataReg ); + + CBaseMtmUiData* mtmUiData = mtmUiDataReg->NewMtmUiDataLayerL( this->Type( ) ); + CleanupStack::PushL( mtmUiData ); + CNotMtmUiData* uiData = static_cast ( mtmUiData ); + + CMMBoxDialog* dialog = CMMBoxDialog::NewL( *this, *uiData, Session(), exitCode ); + + dialog->ExecuteLD( R_NOT_MMBOX_DIALOG ); + + CleanupStack::PopAndDestroy( mtmUiData ); + CleanupStack::PopAndDestroy( mtmUiDataReg ); + + return CMsvCompletedOperation::NewL( Session(), + KUidMsvLocalServiceMtm, + KNullDesC8, + KMsvLocalServiceIndexEntryId, + aCompletionStatus ); + } + + + +// --------------------------------------------------------- +// CNotMtmUi::StartFetchingL +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::StartFetchingL( + const CMsvEntrySelection& aSelection, + TRequestStatus& aCompletionStatus ) + { + LOGTEXT( _L8( "NotMtmUi StartFetchingL start" ) ); + // Lets check the expiration if only one notification + if( aSelection.Count( ) == 1 ) + { + TMsvEntry entry; + TMsvId service=-1; + Session().GetEntry( aSelection.At( 0 ), service, entry ); + if( entry.Parent( ) == KMsvGlobalInBoxIndexEntryId ) + { // We are in Inbox + TMsvId origId = iMmsClient.Entry().Entry().Id(); + iMmsClient.SwitchCurrentEntryL( aSelection.At( 0 ) ); + iMmsClient.LoadMessageL( ); + TTime currentTime; + currentTime.HomeTime( ); + TTime expiryTime = iMmsClient.ExpiryDate( ); + iMmsClient.SwitchCurrentEntryL( origId ); + iMmsClient.LoadMessageL( ); + TLocale locale; + expiryTime += locale.UniversalTimeOffset(); + if (locale.QueryHomeHasDaylightSavingOn()) + { + TTimeIntervalHours daylightSaving(1); + expiryTime += daylightSaving; + } + + if( currentTime > expiryTime ) + { // Message is expired + TBool res = EFalse; + TRAPD( err, res=ShowConfirmationQueryL( R_NOT_MMBOX_QUEST_MSG_EXPIRED ) ); + if ( err || !res ) + { // User did not want to fetch expired message or the function leaved + CMmsSettingsDialog::TMmsExitCode exitCode = CMmsSettingsDialog::EMmsBack; + return CompleteSettingsOperationL( aCompletionStatus, exitCode ); + } // else we continue + } + } + } + + //we need to check access points here + CMmsSettingsDialog::TMmsExitCode exitCode = CMmsSettingsDialog::EMmsExternalInterrupt; + if ( !CheckSettingsL( exitCode ) ) + { + TInt32 ap = iSettingsHandler->MmsSettings()->AccessPoint( 0 ); + //settings saved + if( exitCode==CMmsSettingsDialog::EMmsBack && ApExistsL( ap ) ) + { + CMsvOperation* op = NULL; + CAknInputBlock* abs = CAknInputBlock::NewLC( ); + TRAP_IGNORE( op = iMmsClient.FetchMessagesL( aSelection, aCompletionStatus) ); + CleanupStack::PopAndDestroy( abs ); + return op; + } + else//user selects exit and settings not saved + { + return CompleteSettingsOperationL( aCompletionStatus, exitCode ); + } + } + else + { + // OK - settings ok and fetch could be done + CAknInputBlock* abs = CAknInputBlock::NewLC( ); + CMsvOperation* op = NULL; + TRAP_IGNORE( op = iMmsClient.FetchMessagesL( aSelection, aCompletionStatus) ); + CleanupStack::PopAndDestroy( abs ); + return op; + } + } + +// --------------------------------------------------------- +// CNotMtmUi::StartDeletingL +// --------------------------------------------------------- +// +CMsvOperation* CNotMtmUi::StartDeletingL( + const CMsvEntrySelection& aSelection, + TRequestStatus& aCompletionStatus ) + { + LOGTEXT( _L8( "NotMtmUi StartDeletingL start" ) ); + + CMsvOperation* msvoperation = NULL; + + if( aSelection.Count( ) == 0 ) + { // Nothing to delete + return msvoperation; + } + + if( aSelection.Count( ) > 1 ) + { + iFlags |= EDeletingMany; + } + else + { + iFlags &= ~EDeletingMany; + } + + iFlags &= ~EDeletingFromMMBox; + + TInt deleteMode(-1); + + CMsvEntry* cEntry = Session().GetEntryL( aSelection[0] ); + CleanupStack::PushL( cEntry ); + + TMsvEntry entry = cEntry->Entry( ); + + CleanupStack::PopAndDestroy(); //cEntry + + if( entry.Parent( ) == KMsvGlobalInBoxIndexEntryId + || entry.Parent( ) == iMmsClient.GetMmboxFolderL( ) ) + { + if( iNotUiFlags & EOffline + && IS_PHONE_OFF_LINEL() ) + { // We are in offline at the moment -> Infonote + ShowInformationNoteL( R_NOTMTM_OFFLINE_NOT_POSSIBLE, EFalse ); + return msvoperation; + } + } + + if( ( entry.Parent( ) == KMsvGlobalInBoxIndexEntryId ) + && ( iNotUiFlags & EDeleteOptionsSupported ) + && DeleteQueryReallyNeededL( aSelection ) ) + { // Query is really needed (we r in Inbox, DeleteOptions supported + // and the msg has not been deleted from server yet + if( !( DeleteFromQueryL( deleteMode ) ) ) + { // Answered Cancel + return msvoperation; // Return NULL operation + } + if( deleteMode != EMmsDeleteNotificationOnly ) + { + iFlags |= EDeletingFromMMBox; + } + } + else // Either we have no options or we are deleting FR(s) + { + if( entry.Parent( ) == iMmsClient.GetMmboxFolderL( ) ) + { + iFlags |= EDeletingFromMMBox; + deleteMode = EMmsDeleteBoth; + } + else + { + deleteMode = EMmsDeleteNotificationOnly; + } + } + + if( deleteMode == -1 ) + { // For some reason deleteMode was not set + return msvoperation; // Return NULL operation + } + if( iFlags & EDeletingFromMMBox ) + { + CMmsSettingsDialog::TMmsExitCode exitCode = CMmsSettingsDialog::EMmsExternalInterrupt; + if ( !CheckSettingsL( exitCode ) ) + { + TInt32 ap = iSettingsHandler->MmsSettings()->AccessPoint( 0 ); + // just return NULL if the settings are not all right + if( !ApExistsL( ap ) ) + { + return msvoperation; + } + } + } + // Now we can start the deleting process + if( entry.Parent( ) == KMsvGlobalInBoxIndexEntryId + || entry.Parent( ) == iMmsClient.GetMmboxFolderL( ) ) + { // We are now in Inbox + + CMsvProgressReporterOperation* reporter = + CMsvProgressReporterOperation::NewL( + Session(), + aCompletionStatus, + EMbmAvkonQgn_note_erased ); + + CleanupStack::PushL(reporter); + + CMsvOperation* deleteop = iMmsClient.UnscheduledDeleteNotificationL( + aSelection, + (TMmsDeleteOperationType)deleteMode, + reporter->RequestStatus() ); + reporter->SetProgressDecoder( *this ); + reporter->SetOperationL( deleteop ); // Takes immediate ownership + CleanupStack::Pop(); //reporter + msvoperation = reporter; + } + else + { // We are in Outbox/Sent folder -> Synchronously Delete FR + TInt waitNoteId = 0; + waitNoteId = aSelection.Count( ) == 1? + R_NOTMTM_WAIT_DELETING:R_NOTMTM_WAIT_DELETING_MANY; + ShowWaitNoteLC( waitNoteId, ETrue); // Show deleting note + + iMmsClient.DeleteForwardEntryL( aSelection ); + + if( iWaitDialog ) + { + CleanupStack::PopAndDestroy( ); // iWaitDialog + iWaitDialog=NULL; + } + + return msvoperation; // Return NULL operation as DeleteForwardEntryL is actually synchronous + } + + return msvoperation; + } + + +// --------------------------------------------------------- +// CNotMtmUi::TurnRecipientsArrayIntoStringLC +// +// --------------------------------------------------------- +HBufC* CNotMtmUi::TurnRecipientsArrayIntoStringLC( const CMsvRecipientList& aRecip ) const + { + //calc length of string needed + TInt stringLength = 0; + TInt index; + TInt count = aRecip.Count(); + for( index = 0; index < count; index++ ) + { + stringLength += TMmsGenUtils::Alias( aRecip[index] ).Length(); + stringLength += TMmsGenUtils::PureAddress( aRecip[index] ).Length(); + // Additional space for chars: '<' '>' ',' + 2 x KMmsLRMarker + stringLength += KMmsAdditionalCharsStringLength; + } + //construct string + HBufC* toList = HBufC::NewLC( stringLength ); + for( index=0; index < count; index++ ) + { + TPtrC name = TMmsGenUtils::Alias( aRecip[index] ); + TPtrC number = TMmsGenUtils::PureAddress( aRecip[index] ); + TPtr toListPtr = toList->Des(); + if( name.Length()) + { + toListPtr.Append( name ); + toListPtr.Append( KMmsCharSpace ); + toListPtr.Append( KMmsLRMarker ); + toListPtr.Append( KCharLeftAddressIterator ); + toListPtr.Append( number ); + toListPtr.Append( KCharRightAddressIterator ); + toListPtr.Append( KMmsLRMarker ); + } + else + { + toListPtr.Append( number ); + } + + if ( index < ( count - 1 ) ) + { + toListPtr.Append( KMmsCharCommaAndSpace ); + } + } + + return toList; + } + + + +// --------------------------------------------------------- +// CNotMtmUi::MessageSizeToStringL(TDes& aTarget, TInt aFileSize) +// Converts message size in bytes to a kilobyte string. Rounds the bytes up to the +// next full kilo. I.e: +// 0 -> 0KB +// 1 -> 1KB +// 1024 -> 1KB +// 1025 -> 2KB +// --------------------------------------------------------- +// +void CNotMtmUi::MessageSizeToStringL( TDes& aTarget, TInt aFileSize ) const + { + TInt fileSize = aFileSize / KKiloByte; + if ( aFileSize % KKiloByte ) + { + fileSize++; + } + + HBufC* buf = StringLoader::LoadLC( R_NOT_MESSAGE_SIZE_KB, fileSize, iEikonEnv ); + TPtr ptr = buf->Des(); + ptr.Trim(); // remove possible white space from beginning + aTarget.Append( ptr ); + + CleanupStack::PopAndDestroy(); // buf + } + +// --------------------------------------------------------- +// CNotMtmUi::ShowConfirmationQueryL +// --------------------------------------------------------- +// +TInt CNotMtmUi::ShowConfirmationQueryL( TInt aResourceId ) const + { + CAknQueryDialog* dlg = CAknQueryDialog::NewL(); + HBufC* prompt = StringLoader::LoadLC( aResourceId, iCoeEnv ); + TInt retVal = dlg->ExecuteLD( R_NOTUI_CONFIRMATION_QUERY, *prompt ); + CleanupStack::PopAndDestroy( prompt ); + return retVal; + } + +// --------------------------------------------------------- +// CNotMtmUi::ApExistsL +// Checks the existence of given access point +// according to id. +// --------------------------------------------------------- +// +EXPORT_C TBool CNotMtmUi::ApExistsL( TInt32 aAp ) + { + return iSettingsHandler->ApExistsL( aAp ); + } + +// --------------------------------------------------------- +// ConstructWaitNoteLC +// --------------------------------------------------------- + +void CNotMtmUi::ConstructWaitNoteLC( + TBool aVisibilityDelayOff ) + { + delete iWaitDialog; + iWaitDialog = NULL; + iWaitDialog = new (ELeave) CAknWaitDialog( + reinterpret_cast( &iWaitDialog ), + aVisibilityDelayOff ); + CleanupStack::PushL( TCleanupItem( CleanupWaitDialog, (TAny**)&iWaitDialog ) ); + iWaitDialog->PrepareLC( DELETING_WAIT_NOTE ); + } + +// --------------------------------------------------------- +// ShowWaitNoteLC +// --------------------------------------------------------- + +void CNotMtmUi::ShowWaitNoteLC( + TInt aNoteTxtResourceId, + TBool aVisibilityDelayOff ) + { + ConstructWaitNoteLC( aVisibilityDelayOff ); + HBufC* text = StringLoader::LoadLC( aNoteTxtResourceId, iCoeEnv ); + iWaitDialog->SetTextL( *text ); + CleanupStack::PopAndDestroy( ); // text + iWaitDialog->RunLD( ); + } + +// --------------------------------------------------------- +// CleanupWaitDialog +// --------------------------------------------------------- +// +void CNotMtmUi::CleanupWaitDialog( TAny* aAny ) + { + CAknWaitDialog** dialog = (CAknWaitDialog**) aAny; + if ( dialog && *dialog ) + { + delete *dialog; + // Coverty fix, Forward NULL http://ousrv057/cov.cgi?cid=36247 + *dialog = NULL; + dialog = NULL; + } + } + +//-------------------------------- +// DecodeProgress +//-------------------------------- +TInt CNotMtmUi::DecodeProgress( + const TDesC8& /*aProgress*/, + TBuf& aReturnString, + TInt& aTotalEntryCount, + TInt& aEntriesDone, + TInt& aCurrentEntrySize, + TInt& aCurrentBytesTrans, + TBool /*aInternal*/ ) + { + aCurrentEntrySize = 0; + aCurrentBytesTrans = 0; + aEntriesDone = 0; + aTotalEntryCount = 0; + + if( iFlags & EDeletingFromMMBox ) + { + StringLoader::Load( aReturnString, + R_NOTMTM_WAIT_DELETING_REMOTE, + iCoeEnv ); + } + else if( iFlags & EDeletingMany ) + { + StringLoader::Load( aReturnString, + R_NOTMTM_WAIT_DELETING_MANY, + iCoeEnv ); + } + else + { + StringLoader::Load( aReturnString, + R_NOTMTM_WAIT_DELETING, + iCoeEnv ); + } + return KErrNone; + } + +//-------------------------------- +// DeleteQueryRequiredByMtm +//-------------------------------- +EXPORT_C TBool CNotMtmUi::DeleteQueryRequiredByMtm() + { + TBool result(EFalse); + if( iNotUiFlags & EDeleteOptionsSupported ) + { + return ETrue; + } + return result; + } + +//-------------------------------- +// DeleteQueryReallyNeeded +//-------------------------------- +TBool CNotMtmUi::DeleteQueryReallyNeededL( const CMsvEntrySelection& aSelection ) + { + TBool result( ETrue ); + if( aSelection.Count( ) == 1 ) + { + CMsvEntry* cEntry = Session().GetEntryL( aSelection[0] ); + CleanupStack::PushL( cEntry ); + + TMsvEntry entry = cEntry->Entry( ); + + CleanupStack::PopAndDestroy(); //cEntry + + // Delete from server is not needed if it's been deleted + if( ( entry.iMtmData2 & KMmsOperationFetch ) // Fetch+Forward=DELETE! + && ( entry.iMtmData2 & KMmsOperationForward ) // + && ( entry.iMtmData2 & KMmsOperationFinished ) // Finished + && !( entry.iMtmData2 & KMmsOperationResult ) ) // Succesfully + { // Returns false if only one entry available + // and it has been deleted from server already + result = EFalse; + } + } + return result; + } + +// --------------------------------------------------------- +// CNotMtmUi::ShowInformationNoteL +// --------------------------------------------------------- +// +void CNotMtmUi::ShowInformationNoteL( TInt aResourceID, TBool aWaiting ) + { + HBufC* string = NULL; + string = StringLoader::LoadLC( aResourceID, iCoeEnv ); + + CAknInformationNote* note = new ( ELeave ) + CAknInformationNote( aWaiting ); + note->ExecuteLD( *string ); + + CleanupStack::PopAndDestroy(); //string + } + +// End of File