diff -r 000000000000 -r 72b543305e3a email/imum/Utils/Src/EmailUtils.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/email/imum/Utils/Src/EmailUtils.cpp Thu Dec 17 08:44:11 2009 +0200 @@ -0,0 +1,1158 @@ +/* +* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* Static functions for imum +* +*/ + + +// INCLUDE FILES +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // CErrorUI +#include +#include +#include +#include // CMuiuOperationWait +#include // MsvUiServiceUtilities +#include +#include +#include +#include // CMtmStore +#include // BaseMtmUi +#include // Messaging keys +#include // CRepository +#include +#include +#include +#include +#include +#include // KDC_MTM_RESOURCE_DIR +#include +#include +#include +#include "ImumInMailboxUtilitiesImpl.h" +#include "ImumInMailboxServicesImpl.h" + +#include "SenduiMtmUids.h" +#include "ImumMboxManager.h" +#include "ImumMboxData.h" +#include "EmailFeatureUtils.h" +#include "EmailUtils.H" +#include "ImumUtilsLogging.h" +#include "ImumPanic.h" +#include +#include "ImumMboxSettingsCtrl.h" +#include "ImumUtilsLogging.h" +#include "IMSSettingsNoteUi.h" +#include "ImumInternalApiImpl.h" +#include "ImumDaSettingsKeys.h" +#include "ImumInSettingsData.h" // CImumInSettingsData + +// EXTERNAL DATA STRUCTURES +// EXTERNAL FUNCTION PROTOTYPES +// CONSTANTS +const TInt KBytesInKiloByte = 1024; +const TInt KImumSizeBufferSize = 32; +const TInt KImumReplaceCharacterCount = 2; +const TInt KIMSMaxAoMailboxes = 2; +const TInt KImumExtraStringLength = 4; +_LIT( KImumDefaultNameFormat, "%S(%02d)" ); +_LIT(KEmailUtilsComma, ","); +_LIT(KEmailUtilsSpace, " "); +_LIT( KIMSDirAndResFileName,"z:ImumUtils.rsc" ); + +// MACROS +// LOCAL CONSTANTS AND MACROS +// MODULE DATA STRUCTURES +// LOCAL FUNCTION PROTOTYPES +// FORWARD DECLARATIONS + +// ============================ MEMBER FUNCTIONS =============================== + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::CheckAvailableDiskSpaceForDownloadL +// This is static function +// ---------------------------------------------------------------------------- +// +EXPORT_C TBool MsvEmailMtmUiUtils::CheckAvailableDiskSpaceForDownloadL( + TInt aMsgSize, + CEikonEnv& aEikonEnv, + CMsvSession& aSession ) +// +// Check there is enough disk space on the specified drive to fetch a message +// of aMsgSize bytes. If not, display a message and return EFalse. +// static + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::CheckAvailableDiskSpaceForDownloadL, 0, utils, KLogUi ); + + if ( MsvUiServiceUtilities::DiskSpaceBelowCriticalLevelL( + aSession, aMsgSize ) ) + { + CErrorUI* errorUi = CErrorUI::NewLC( aEikonEnv ); + errorUi->ShowGlobalErrorNoteL( KErrDiskFull ); + CleanupStack::PopAndDestroy( errorUi ); + return EFalse; + } + return ETrue; + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::CheckActiveAOLimitsL() +// +// This function goes through all the mailboxes and checks, if there are any +// Always Online enabled boxes around. The included mailbox id is ignored +// during the search. If less than 2 ( <2 ) always online mailboxes are found, +// ETrue is returned, otherwise EFalse is returned. +// ---------------------------------------------------------------------------- +// +TBool MsvEmailMtmUiUtils::CheckActiveAOLimitsL( + CImumInternalApi& aEmailApi, + const TMsvId aMailboxId ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::CheckActiveAOLimitsL, 0, utils, KLogUi ); + + // Get the list of healthy mailboxes from the API + TInt count = 0; + const MImumInHealthServices& healthApi = aEmailApi.HealthServicesL(); + MImumInHealthServices::RMailboxIdArray mailboxes; + + // Get the list of mailboxes in array. Gather the list based on the smtpId, + // since the aMailboxId is actually also the smtpId + if ( healthApi.GetMailboxList( mailboxes, + MImumInHealthServices::EFlagIncludeSmtp | + MImumInHealthServices::EFlagGetHealthy ) == KErrNone ) + { + for ( TInt mbox = mailboxes.Count(); --mbox >= 0; ) + { + if ( aMailboxId != mailboxes[mbox] ) + { + // Create object for the extended mail settings + CImumInSettingsData* settings = + aEmailApi.MailboxServicesL().LoadMailboxSettingsL( + mailboxes[mbox] ); + CleanupStack::PushL( settings ); + + TInt aoState = 0; + if ( settings ) + { + settings->GetAttr( + TImumDaSettings::EKeyAutoRetrieval, aoState ); + + // If always online is on, increase the count + if ( aoState != TImumDaSettings::EValueAutoOff ) + { + count++; + } + } + CleanupStack::PopAndDestroy( settings ); + settings = NULL; + } + } + } + + mailboxes.Reset(); + + return count < KIMSMaxAoMailboxes; + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::DoCEntryCopyMoveL +// This is static function +// ---------------------------------------------------------------------------- +// +EXPORT_C CMsvOperation* MsvEmailMtmUiUtils::DoCEntryCopyMoveL( + CMsvEntry& aEntry, const CMsvEntrySelection& aSel, TMsvId aTargetId, + TRequestStatus& aCompletionStatus, TBool aCopy) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::DoCEntryCopyMoveL, 0, utils, KLogUi ); + + CMsvOperation* op = NULL; + if(aCopy) + { + op = aEntry.CopyL(aSel, aTargetId, aCompletionStatus); + } + else + { + op = aEntry.MoveL(aSel, aTargetId, aCompletionStatus); + } + return op; + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::StripCompleteEntriesLC +// This is static function +// ---------------------------------------------------------------------------- +// +EXPORT_C CMsvEntrySelection* MsvEmailMtmUiUtils::StripCompleteEntriesLC( + const CMsvEntry& aParent, const CMsvEntrySelection& aSelection) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::StripCompleteEntriesLC, 0, utils, KLogUi ); + + CMsvEntrySelection* entries=aSelection.CopyLC(); + TInt cc = entries->Count(); + TMsvEntry tEntry; + while(cc--) + { + tEntry = aParent.ChildDataL((*entries)[cc]); + TMsvEmailEntry eEntry( tEntry ); + + TBool complete = tEntry.Complete(); + TBool partial = eEntry.PartialDownloaded(); + + if( complete && !partial ) + { + entries->Delete(cc); + } + } + return entries; + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::StripDeletedEntriesLC +// This is static function +// ---------------------------------------------------------------------------- +// +EXPORT_C CMsvEntrySelection* MsvEmailMtmUiUtils::StripDeletedEntriesLC( + const CMsvEntry& aParent, const CMsvEntrySelection& aSelection) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::StripDeletedEntriesLC, 0, utils, KLogUi ); + // static + CMsvEntrySelection* entries=aSelection.CopyLC(); + TInt cc = entries->Count(); + while(cc--) + { + const TMsvEmailEntry mailEntry(aParent.ChildDataL((*entries)[cc])); + if(EDisconnectedDeleteOperation == mailEntry.DisconnectedOperation()) + { + entries->Delete(cc); + } + } + return entries; + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::SetMessageInfoDataLCCCCC +// This is static function +// sets fields in the message info data array using TMsvEntry and CImHeader +// information; the TDes parameters are needed so that the strings have +// persisted memory to live in since the info data elements are all TPtrs +// ---------------------------------------------------------------------------- +// +EXPORT_C void MsvEmailMtmUiUtils::SetMessageInfoDataLCCCCC( + TMsgInfoMessageInfoData& aInfoData, + CBaseMtm& aMtm, + CCoeEnv& aEnv, + TDes& /* aDateBuf */, + TDes& /* aTimeBuf */, + TDes& aSizeBuf, + TDes& aPriorityBuf ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::SetMessageInfoDataLCCCCC, 0, utils, KLogUi ); + + //retrieve header + CMsvStore* store = aMtm.Entry().ReadStoreL(); + CleanupStack::PushL( store ); + CImHeader* header = CImHeader::NewLC(); + header->RestoreL( *store ); + + //subject + HBufC* tmpSubj = header->Subject().AllocLC(); + aInfoData.iSubject.Set( *tmpSubj ); + + //date and time + TMsvEntry tentry = aMtm.Entry().Entry(); + aInfoData.iDateTime = tentry.iDate; + + //size + TInt size = tentry.iSize / KBytesInKiloByte; //in bytes + if ( tentry.iSize % KBytesInKiloByte ) + { + size++; + } + TBuf kB; + StringLoader::Load( kB, R_IMAS_MESSAGE_INFO_KB, &aEnv ); + StringLoader::Format( aSizeBuf, kB, -1, size ); + aInfoData.iSize.Set( aSizeBuf ); + + //Priority + MsvEmailMtmUiUtils::GetPriorityString(tentry,aEnv,aPriorityBuf ); + aInfoData.iPriority.Set( aPriorityBuf ); + + //to field + HBufC* toList = TurnArrayIntoCommaSeparatedStringLC( + header->ToRecipients() ); + aInfoData.iTo.Set( *toList ); + + //cc field + HBufC* ccList = TurnArrayIntoCommaSeparatedStringLC( + header->CcRecipients() ); + aInfoData.iCC.Set( *ccList ); + + //bcc field + HBufC* bccList = TurnArrayIntoCommaSeparatedStringLC( + header->BccRecipients() ); + aInfoData.iBCC.Set( *bccList ); + + //from field + HBufC* tmpFrom = header->From().AllocLC(); + aInfoData.iFrom.Set( *tmpFrom ); + + //take HBufCs out + CleanupStack::Pop( 5 ); // CSI: 47 # tmpFrom, bccList, ccList, toList, tmpSubj. + //destroy store and header. if not, message info in outbox prevents + //mail sending! + CleanupStack::PopAndDestroy( 2 ); // CSI: 47 # header, store. + //put HBufCs back, so no need to change function name. + CleanupStack::PushL( tmpSubj ); + CleanupStack::PushL( toList ); + CleanupStack::PushL( ccList ); + CleanupStack::PushL( bccList ); + CleanupStack::PushL( tmpFrom ); + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::SetMessageInfoDataLCC +// This is static function +// sets fields in the message info data array using TMsvEntry and CImHeader +// information; the TDes parameters are needed so that the strings have +// persisted memory to live in since the info data elements are all TPtrs +// ---------------------------------------------------------------------------- +// +EXPORT_C TBool MsvEmailMtmUiUtils::SetMessageInfoDataLCC( + TMsgInfoMessageInfoData& aInfoData, + CBaseMtm& aMtm, + CCoeEnv& aEnv, + TDes& /* aDateBuf */, + TDes& /* aTimeBuf */, + TDes& aSizeBuf, + TDes& aPriorityBuf ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::SetMessageInfoDataLCC, 0, utils, KLogUi ); + + //retrieve header + CMsvStore* store = NULL; + CImHeader* header = NULL; + TRAPD( storeError, store = aMtm.Entry().ReadStoreL() ); + if ( storeError == KErrNone ) + { + CleanupStack::PushL( store ); + header = CImHeader::NewLC(); + TRAP( storeError, header->RestoreL( *store ) ); + // if restore leaves then we can find out lots of info from + // TMsvEntry's fields. + if ( storeError != KErrNone ) + { + CleanupStack::PopAndDestroy( 2, store ); // CSI: 47 # header, store. + header = NULL; + store = NULL; + } + // if no errors, then store and header should be left to cleanup stack. + } + + TMsvEntry tentry = aMtm.Entry().Entry(); + + //subject + if ( header ) + { + aInfoData.iSubject.Set( header->Subject() ); + } + else + { + aInfoData.iSubject.Set( tentry.iDescription ); + } + + //date and time + aInfoData.iDateTime = tentry.iDate; + + //size + TInt size = tentry.iSize / KBytesInKiloByte; //in bytes + if ( tentry.iSize % KBytesInKiloByte ) + { + size++; + } + TBuf kB; + StringLoader::Load( kB, R_IMAS_MESSAGE_INFO_KB, &aEnv ); + StringLoader::Format( aSizeBuf, kB, -1, size ); + aInfoData.iSize.Set( aSizeBuf ); + + //Priority + MsvEmailMtmUiUtils::GetPriorityString(tentry,aEnv,aPriorityBuf ); + aInfoData.iPriority.Set( aPriorityBuf ); + + if ( header ) + { + //to field + HBufC* toList = TurnArrayIntoCommaSeparatedStringLC( + header->ToRecipients() ); + aInfoData.iTo.Set( *toList ); + + //cc field + HBufC* ccList = TurnArrayIntoCommaSeparatedStringLC( + header->CcRecipients() ); + aInfoData.iCC.Set( *ccList ); + + //from field + aInfoData.iFrom.Set( header->From() ); + } + else + { + // to field + HBufC* toList = HBufC::NewLC( 0 ); + aInfoData.iTo.Set( *toList ); + + // cc field + HBufC* ccList = HBufC::NewLC( 0 ); + aInfoData.iCC.Set( *ccList ); + + // from field + aInfoData.iFrom.Set( tentry.iDetails ); + } + + return ( header != NULL ); + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::TurnArrayIntoCommaSeparatedStringLC +// This is static function +// returns an HBufC* which contains all of the lines in aTextArray concaternated +// together with commas separating them +// ---------------------------------------------------------------------------- +// +HBufC* MsvEmailMtmUiUtils::TurnArrayIntoCommaSeparatedStringLC(CDesCArray& aTextArray) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::TurnArrayIntoCommaSeparatedStringLC, 0, utils, KLogUi ); + + TInt totalLength=0; + //first calculate the length of string required + TInt index = 0; + for(index=0;indexDes().Append(aTextArray[index]); + + //don't add for last item + if(index != ( aTextArray.Count() - 1 ) ) + { + list->Des().Append(KEmailUtilsComma); + list->Des().Append(KEmailUtilsSpace); + } + } + + return list; + } + + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::ReplaceCharacters +// This is static function +// ---------------------------------------------------------------------------- +// +void MsvEmailMtmUiUtils::ReplaceCharacters( TDes& aText ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::ReplaceCharacters, 0, utils, KLogUi ); + + TBuf replaceChars; + replaceChars.Zero(); + replaceChars.Append( CEditableText::EParagraphDelimiter ); + replaceChars.Append( CEditableText::ETabCharacter ); + AknTextUtils::ReplaceCharacters( + aText, + replaceChars, + CEditableText::ESpace ); + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::StripCharacters +// This is static function +// ---------------------------------------------------------------------------- +// +void MsvEmailMtmUiUtils::StripCharacters( TDes& aText ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::StripCharacters, 0, utils, KLogUi ); + + TBuf stripChars; + stripChars.Zero(); + stripChars.Append( CEditableText::EParagraphDelimiter ); + stripChars.Append( CEditableText::ETabCharacter ); + AknTextUtils::StripCharacters( + aText, + stripChars ); + } + + +// ---------------------------------------------------------------------------- +// DisconnectMailboxL +// ---------------------------------------------------------------------------- +// +EXPORT_C TBool MsvEmailMtmUiUtils::DisconnectMailboxL( + const TMsvEntry& aService, CMsvSession& aSession ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::DisconnectMailboxL, 0, utils, KLogUi ); + + __ASSERT_DEBUG( aService.iMtm != KSenduiMtmSmtpUid, + User::Panic( KImumMtmUiPanic, EPanicRcvServiceMustBePOP3OrIMAP4) ); + + if ( CIMSSettingsNoteUi::ShowQueryL( + R_IMAS_SETTINGS_DIALOG_MAILSET_DISCON, R_EMAIL_CONFIRMATION_QUERY ) ) + { + CMtmStore* mtmStore = CMtmStore::NewL( aSession ); + CleanupStack::PushL(mtmStore); + CBaseMtmUi& relatedMtmUi = mtmStore->GetMtmUiAndSetContextLC(aService); + CMuiuOperationWait* wait = + CMuiuOperationWait::NewLC( EActivePriorityWsEvents + 10 ); // CSI: 47 # . + CMsvOperation* op = relatedMtmUi.CloseL(wait->iStatus); + wait->Start(); + CleanupStack::PopAndDestroy( wait ); + delete op; + CleanupStack::PopAndDestroy( 2, mtmStore ); // CSI: 47 # release mtmui. + + return ETrue; // did disconnect succeed? + } + else + { + return EFalse; + } + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::DoOfflineChecksL() +// Function to check offline mode +// ---------------------------------------------------------------------------- +// +EXPORT_C TBool MsvEmailMtmUiUtils::DoOfflineChecksL( TMsvId /*aService*/ ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::DoOfflineChecksL, 0, utils, KLogUi ); + + if ( !MsvEmailMtmUiFeatureUtils::LocalFeatureL( + KCRUidCoreApplicationUIs, KCoreAppUIsNetworkConnectionAllowed, 1 ) ) + { + // offline mode has been set + HBufC* text = StringLoader::LoadLC( + R_IMUM_OFFLINE_NOT_POSSIBLE, CCoeEnv::Static() ); + CAknInformationNote* note = new (ELeave) + CAknInformationNote(); + note->ExecuteLD( *text ); + CleanupStack::PopAndDestroy( text ); + + return ETrue; + } + + return EFalse; + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::RemoveOfflineDeleteL() +// ---------------------------------------------------------------------------- +// +EXPORT_C TInt MsvEmailMtmUiUtils::RemoveOfflineDeleteL( + CBaseMtm& aBaseMtm, + TInt aFunctionId, + TMsvId aEntryId ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::RemoveOfflineDeleteL, 0, utils, KLogUi ); + + TBuf8<1> params; + params.Zero(); + + // Create the selection and add the id into it + CMsvEntrySelection* selection = new(ELeave) CMsvEntrySelection; + CleanupStack::PushL( selection ); + selection->AppendL( aEntryId ); + + // Create waiting operation and the main operation + CMuiuOperationWait* wait = CMuiuOperationWait::NewLC(); + CMsvOperation* op = aBaseMtm.InvokeAsyncFunctionL( + aFunctionId, + *selection, + params, + wait->iStatus ); + + // Start the waiter operation + wait->Start(); + + // Get the error from waiter + TInt error = wait->iStatus.Int(); + + // Cleanup the objects + delete op; + op = NULL; + CleanupStack::PopAndDestroy( 2, selection ); // CSI: 47 # wait, selection. + wait = NULL; + selection = NULL; + + return error; + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::AcquireDiskSpace() +// ---------------------------------------------------------------------------- +// +EXPORT_C TInt MsvEmailMtmUiUtils::AcquireDiskSpace( + RFs& aFileSession, + const TInt aDriveNo, + const TInt aSize ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::AcquireDiskSpace, 0, utils, KLogUi ); + + // Try to reserve diskspace + TInt error = aFileSession.ReserveDriveSpace( + aDriveNo, aSize ); + + // If reserving ok, get access + if ( error == KErrNone ) + { + error = aFileSession.GetReserveAccess( aDriveNo ); + } + + return error; + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::SendAOCommandL() +// ---------------------------------------------------------------------------- +// +EXPORT_C void MsvEmailMtmUiUtils::SendAOCommandL( + const TAlwaysOnlineServerAPICommands aCommand, + TMsvId aMailboxId ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::SendAOCommandL, 0, utils, KLogUi ); + + // Create connection to Always Online + RAlwaysOnlineClientSession aoclient; + CleanupClosePushL(aoclient); + User::LeaveIfError(aoclient.Connect()); + + // Prepare the parameters to be forwarded to AO-server + TPckg param = aMailboxId; + + // Send message to server and close it + aoclient.RelayCommandL(aCommand, param); + CleanupStack::PopAndDestroy(); + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::GetAccountId() +// ---------------------------------------------------------------------------- +// +TUint32 MsvEmailMtmUiUtils::GetAccountId( + const CImumMboxData& aAccountSettings ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::GetAccountId, 0, utils, KLogUi ); + + if ( aAccountSettings.iIsImap4 ) + { + return aAccountSettings.iImap4AccountId.iImapAccountId; + } + else + { + return aAccountSettings.iPop3AccountId.iPopAccountId; + } + } + +// ---------------------------------------------------------------------------- +// CImumMboxSettingsCtrl::CreateCenRepConnectionL() +// ---------------------------------------------------------------------------- +// +void MsvEmailMtmUiUtils::CreateCenRepConnectionL( + CRepository*& aRepository, + TUid aRepositoryUid ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::CreateCenRepConnectionL, 0, utils, KLogUi ); + + // If session doesn't exist, create one + if ( !aRepository ) + { + aRepository = CRepository::NewL( aRepositoryUid ); + } + } +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::StoreSecuritySettings() +// ---------------------------------------------------------------------------- +// +void MsvEmailMtmUiUtils::StoreSecuritySettings( + CImBaseEmailSettings& aSettings, + const TIMASMailSecurity& aSecurity ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::StoreSecuritySettings, 0, utils, KLogUi ); + + switch( aSecurity ) + { + case EImumSecurityOn: + aSettings.SetSecureSockets( ETrue ); + aSettings.SetSSLWrapper( EFalse ); + break; + + case EImumSecurityMs: + aSettings.SetSecureSockets( EFalse ); + aSettings.SetSSLWrapper( ETrue ); + break; + + case EImumSecurityOff: + aSettings.SetSecureSockets( EFalse ); + aSettings.SetSSLWrapper( EFalse ); + break; + + default: + break; + } + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::StoreSecuritySettings() +// ---------------------------------------------------------------------------- +// +void MsvEmailMtmUiUtils::StoreSecuritySettings( + CImBaseEmailSettings& aSettings, + const TImumDaSettings::TSecurityValues& aSecurity ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::StoreSecuritySettings, 0, utils, KLogUi ); + + switch( aSecurity ) + { + case TImumDaSettings::EValueSecurityTls: + aSettings.SetSecureSockets( ETrue ); + aSettings.SetSSLWrapper( EFalse ); + break; + + case TImumDaSettings::EValueSecuritySsl: + aSettings.SetSecureSockets( EFalse ); + aSettings.SetSSLWrapper( ETrue ); + break; + + case TImumDaSettings::EValueSecurityOff: + aSettings.SetSecureSockets( EFalse ); + aSettings.SetSSLWrapper( EFalse ); + break; + + default: + break; + } + } + + +// --------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::RestoreSecuritySettings() +// --------------------------------------------------------------------------- +// +TInt MsvEmailMtmUiUtils::RestoreSecuritySettings( + const CImBaseEmailSettings& aSettings ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::RestoreSecuritySettings, 0, utils, KLogUi ); + + TInt security = 0; + + // Security: TLS + if( aSettings.SecureSockets() ) + { + security = TImumDaSettings::EValueSecurityTls; + } + // Security: MS + else if( aSettings.SSLWrapper() ) + { + security = TImumDaSettings::EValueSecuritySsl; + } + // Security Off + else + { + security = TImumDaSettings::EValueSecurityOff; + } + + return security; + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::GetDefaultSecurityPort() +// ---------------------------------------------------------------------------- +// +TUint32 MsvEmailMtmUiUtils::GetDefaultSecurityPort( + const TIMASMailSecurity aSecurity, + const TBool aIncoming, + const TBool aIsImap4 ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::GetDefaultSecurityPort, 0, utils, KLogUi ); + + TUint32 port( 0 ); // this should never be returned + + switch( aSecurity ) + { + case EImumSecurityOn: + case EImumSecurityOff: + { + if ( aIncoming ) + { + port = aIsImap4 ? KIMASDefaultPortImap4 : + KIMASDefaultPortPop3; + } + else + { + port = KIMASDefaultPortSmtp; + } + } + break; + case EImumSecurityMs: + { + if ( aIncoming ) + { + port = aIsImap4 ? KIMASDefaultSecurityPortImap4 : + KIMASDefaultSecurityPortPop3; + } + else + { + port = KIMASDefaultSecurityPortSmtp; + } + } + break; + default: + break; + } + return port; + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::CallNewMessagesL() +// ---------------------------------------------------------------------------- +// +EXPORT_C void MsvEmailMtmUiUtils::CallNewMessagesL( const TMsvId aMailboxId ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::CallNewMessagesL, 0, utils, KLogUi ); + + MNcnInternalNotification* notification = NULL; + + // Create a dummy array. It is not currently used to anything. + CDesCArrayFlat* dummyArray = new (ELeave) CDesCArrayFlat( 1 ); + CleanupStack::PushL( dummyArray ); + + // No need to tell user, that we could not connect to NCN + TRAP_IGNORE( notification = + MNcnInternalNotification::CreateMNcnInternalNotificationL() ); + + if ( notification ) + { + // Ignore result, user is not interested about it, hopefully. + TInt result = notification->NewMessages( + EMailMessage, aMailboxId, *dummyArray ); + } + else + { + } + + CleanupStack::PopAndDestroy( dummyArray ); + dummyArray = NULL; + delete notification; + notification = NULL; + + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::LoadResourceFileL() +// ---------------------------------------------------------------------------- +// +EXPORT_C void MsvEmailMtmUiUtils::LoadResourceFileL( + RConeResourceLoader& aResourceLoader ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::LoadResourceFileL, 0, utils, KLogUi ); + + RFs fs; + CleanupClosePushL(fs); + User::LeaveIfError(fs.Connect()); + TFileName resourceFileName(KIMSDirAndResFileName); + BaflUtils::NearestLanguageFile(fs,resourceFileName); + CleanupStack::PopAndDestroy( 1 ); + + TFileName fileName; + TParse parse; + parse.Set( resourceFileName, &KDC_RESOURCE_FILES_DIR, NULL ); + fileName.Copy( parse.FullName() ); + + // Attempt to load the resource + aResourceLoader.OpenL( fileName ); + + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::GetMailboxName() +// ---------------------------------------------------------------------------- +// +void MsvEmailMtmUiUtils::GetMailboxName( + TDes& aDest, + CMsvSession& aMsvSession, + TMsvId aMailboxId ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::GetMailboxName, 0, utils, KLogUi ); + + aDest.Zero(); + + // Get mailbox + TMsvEntry mailbox; + TMsvId serviceId; + TInt error = aMsvSession.GetEntry( aMailboxId, serviceId, mailbox ); + + if ( error == KErrNone ) + { + aDest.Copy( mailbox.iDetails.Left( KIMASMaxMailboxNameLength ) ); + } + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::CreateConnectingToText() +// ---------------------------------------------------------------------------- +// +EXPORT_C void MsvEmailMtmUiUtils::CreateConnectingToText( + TDes& aDest, + CMsvSession& aMsvSession, + TMsvId aMailboxId ) + { + IMUM_STATIC_CONTEXT( CBaseMtmUi::EProgressStringMaxLen, 0, utils, KLogUi ); + + // Get mailbox name + TBuf name; + MsvEmailMtmUiUtils::GetMailboxName( name, + aMsvSession, aMailboxId ); + + // Combine mailbox name with a resource string + TRAP_IGNORE( CIMSSettingsNoteUi::MakeStringL( aDest, R_EMAIL_CONNECTING_SERVER,name ) ); + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::ContinueRenamingL() +// ---------------------------------------------------------------------------- +// +TBool MsvEmailMtmUiUtils::ContinueRenamingL( + CImumInternalApi& aMailboxApi, + TInt& aResult, + TDes& aAccountName, + const TMsvId aOwningMailbox, + const TInt aNumber, + const CMsvEntry& aAccount, + const TBool aGenerate ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::ContinueRenamingL, 0, utils, KLogUi ); + + // Max number of mailboxes is checked + // Allow name generating. This is for Email Wizard, which attempts + // to generate the mailbox name. + TBool doContinue = ( aNumber <= KImumMaxMailboxes ); + + // Check if the name is already used + if ( doContinue ) + { + doContinue = IsAccountNameUsedL( + aMailboxApi, aResult, aAccountName, aOwningMailbox, aAccount ); + } + + return doContinue && aGenerate; + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::CheckAccountNameL() +// ---------------------------------------------------------------------------- +// +void MsvEmailMtmUiUtils::CheckAccountNameL( + CImumInternalApi& aMailboxApi, + TDes& aAccountName, + const TMsvId aOwningMailbox, + const TBool& aGenerate ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::CheckAccountNameL, 0, utils, KLogUi ); + + // Remove illegal characters from the name, such as tabulators and enters + ReplaceCharacters( aAccountName ); + + // Get entrypoint of the root + int result = KErrNone; + CMsvSession& session = aMailboxApi.MsvSession(); + CMsvEntry* root = session.GetEntryL( + KMsvRootIndexEntryIdValue ); + CleanupStack::PushL( root ); + + // Sort the root + root->SetSortTypeL( TMsvSelectionOrdering( + KMsvGroupByType | KMsvGroupByStandardFolders, + EMsvSortByDetailsReverse, ETrue ) ); + + // This is the first suggested name of the mailbox + TMuiuSettingsText originalName; + originalName.Copy( aAccountName ); + + // Find an account name + TInt mailbox = 0; + for ( TInt number = 1; ContinueRenamingL( + aMailboxApi, result, aAccountName, aOwningMailbox, + number, *root, aGenerate ); + ++number ) + { + // Rename and set the result + result = ChangeAccountNameL( + originalName, aAccountName, ++mailbox ); + } + + // User must be notified, when invalid name is offered + if ( result == KErrAlreadyExists && aGenerate ) + { + result = KErrNone; + } + + CleanupStack::PopAndDestroy( root ); + root = NULL; + + User::LeaveIfError( result ); + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::IsAccountNameUsedL() +// ---------------------------------------------------------------------------- +// +TBool MsvEmailMtmUiUtils::IsAccountNameUsedL( + CImumInternalApi& aMailboxApi, + TInt& aResult, + const TDesC& aAccountName, + const TMsvId aOwningMailbox, + const CMsvEntry& aAccount ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::IsAccountNameUsedL, 0, utils, KLogUi ); + + FeatureManager::InitializeLibL(); + + if(FeatureManager::FeatureSupported(KFeatureIdSelectableEmail)) + { + // Because the unhealthy mailbox's name is not used. + // So try to filter the unhealthy mailbox's name. + aResult = KErrNone; + } + + const MImumInHealthServices& healthServices = aMailboxApi.HealthServicesL(); + + // Search through all the mail account entries until duplicate name + // is found, or all entries are searched through + TInt item = aAccount.Count(); + while ( --item >= 0 && !aResult ) + { + const TMsvEntry& entry = aAccount[item]; + + if(FeatureManager::FeatureSupported(KFeatureIdSelectableEmail)) + { + // If the mailbox is unhealthy, ignore it. + if ( ( !healthServices.IsMailboxHealthy( entry.Id() ) ) && + ( !( ( entry.iType == KUidMsvServiceEntry) && + ( entry.Id() != KMsvLocalServiceIndexEntryId ) && + ( !MuiuEmailTools::IsMailMtm( entry.iMtm, ETrue ) ) ) ) ) + { + continue; + } + } + + // Interrupt the search if mailbox entry with same name is found + if ( !aAccountName.CompareC( entry.iDetails ) && + aMailboxApi.MailboxUtilitiesL().IsMailbox( entry ) && + entry.Id() != aOwningMailbox && + entry.iRelatedId != aOwningMailbox ) + { + aResult = KErrAlreadyExists; + } + else + { + aResult = KErrNone; + } + } + + FeatureManager::UnInitializeLib(); + + // If mailbox account with the same name is found, return ETrue + return ( aResult == KErrAlreadyExists ); + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::ChangeAccountNameL() +// ---------------------------------------------------------------------------- +// +TInt MsvEmailMtmUiUtils::ChangeAccountNameL( + const TDesC& aOriginalAccountName, + TDes& aAccountName, + const TInt aNumber ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::ChangeAccountNameL, 0, utils, KLogUi ); + + // Make sure the is enough room in the mailbox name for the string "(%d)" + const TInt maxLength = + KImasImailServiceNameLength - KImumExtraStringLength; + + // Remove KISIAExtraStringLength amount of letters from the string in + // case the max length has been exceeded. + if ( aOriginalAccountName.Length() > maxLength ) + { + aAccountName.Copy( aAccountName.Left( maxLength ) ); + } + + // Add the brackets with number inside to the end of the string + TMuiuSettingsText tempText; + tempText.Copy( aAccountName ); + tempText.Format( KImumDefaultNameFormat, &aOriginalAccountName, aNumber ); + aAccountName.Copy( tempText ); + + return KErrNone; + } + +// ---------------------------------------------------------------------------- +// MsvEmailMtmUiUtils::GetPriorityString() +// ---------------------------------------------------------------------------- +// +void MsvEmailMtmUiUtils::GetPriorityString( + const TMsvEntry& aEntry, + CCoeEnv& aEnv, + TDes& aPriorityBuf ) + { + IMUM_STATIC_CONTEXT( MsvEmailMtmUiUtils::GetPriorityString, 0, utils, KLogUi ); + + TInt emailPriority = EMsvMediumPriority; + emailPriority = aEntry.Priority(); + + if ( emailPriority == EMsvHighPriority ) + { + StringLoader::Load( aPriorityBuf, R_IMAS_MESSAGE_INFO_PRIORITY_HIGH, &aEnv ); + } + else if ( emailPriority == EMsvLowPriority ) + { + StringLoader::Load( aPriorityBuf, R_IMAS_MESSAGE_INFO_PRIORITY_LOW, &aEnv ); + } + else + { + StringLoader::Load( aPriorityBuf, R_IMAS_MESSAGE_INFO_PRIORITY_NORMAL, &aEnv ); + } + } + +// End of File + +