diff -r 000000000000 -r 72b543305e3a email/imum/Utils/Src/ImumInHealthServicesImpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/email/imum/Utils/Src/ImumInHealthServicesImpl.cpp Thu Dec 17 08:44:11 2009 +0200 @@ -0,0 +1,952 @@ +/* +* 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: ImumInHealthServicesImpl.cpp +* +*/ + + +// INCLUDE FILES +#include +#include // MsvUiServiceUtilities +#include // CEmailAccounts +#include +#include + +#include "ImumInternalApiImpl.h" // CImumInternalApiImpl +#include "ImumMboxManager.h" +#include "EmailUtils.H" +#include "ImumInHealthServicesImpl.h" +#include "ImumInMailboxUtilitiesImpl.h" +#include "ImumUtilsLogging.h" + + + +// EXTERNAL DATA STRUCTURES +// EXTERNAL FUNCTION PROTOTYPES +// CONSTANTS +// MACROS +#ifdef __WINS__ +_LIT( KIMAEmulatorImei, "123456789012345" ); +#endif // __WINS__ + +// LOCAL CONSTANTS AND MACROS +// MODULE DATA STRUCTURES +// LOCAL FUNCTION PROTOTYPES +// FORWARD DECLARATIONS + +// ============================ MEMBER FUNCTIONS =============================== + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::CImumInHealthServicesImpl() +// ---------------------------------------------------------------------------- +// +CImumInHealthServicesImpl::CImumInHealthServicesImpl( + CImumInternalApiImpl& aMailboxApi ) + : + iInternalApi( aMailboxApi ), + iExtendedSettings( NULL ), + iRoot( NULL ), + iUtils( NULL ) + { + IMUM_CONTEXT( CImumInHealthServicesImpl::CImumInHealthServicesImpl, 0, KLogInApi ); + IMUM_IN(); + IMUM_OUT(); + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::~CImumInHealthServicesImpl() +// ---------------------------------------------------------------------------- +// +CImumInHealthServicesImpl::~CImumInHealthServicesImpl() + { + IMUM_CONTEXT( CImumInHealthServicesImpl::~CImumInHealthServicesImpl, 0, KLogInApi ); + IMUM_IN(); + + delete iExtendedSettings; + iExtendedSettings = NULL; + delete iRoot; + iRoot = NULL; + iUtils = NULL; + + IMUM_OUT(); + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::ConstructL() +// ---------------------------------------------------------------------------- +// +void CImumInHealthServicesImpl::ConstructL() + { + IMUM_CONTEXT( CImumInHealthServicesImpl::ConstructL, 0, KLogInApi ); + IMUM_IN(); + + iExtendedSettings = CImumMboxDataExtension::NewL(); + GetIMEIFromThePhoneL(); + iRoot = iInternalApi.MsvSession().GetEntryL( KMsvRootIndexEntryIdValue ); + iRoot->SetSortTypeL( TMsvSelectionOrdering( + KMsvGroupByType | KMsvGroupByStandardFolders, + EMsvSortByDetailsReverse, ETrue ) ); + iUtils = const_cast( + &iInternalApi.MailboxUtilitiesL() ); + + IMUM_OUT(); + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::NewL() +// ---------------------------------------------------------------------------- +// +CImumInHealthServicesImpl* CImumInHealthServicesImpl::NewL( + CImumInternalApiImpl& aMailboxApi ) + { + IMUM_STATIC_CONTEXT( CImumInHealthServicesImpl::NewL, 0, utils, KLogInApi ); + IMUM_IN(); + + CImumInHealthServicesImpl* self = NewLC( aMailboxApi ); + CleanupStack::Pop( self ); + + IMUM_OUT(); + + return self; + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::NewLC() +// ---------------------------------------------------------------------------- +// +CImumInHealthServicesImpl* CImumInHealthServicesImpl::NewLC( + CImumInternalApiImpl& aMailboxApi ) + { + IMUM_STATIC_CONTEXT( CImumInHealthServicesImpl::NewLC, 0, utils, KLogInApi ); + IMUM_IN(); + + CImumInHealthServicesImpl* self = new ( ELeave ) CImumInHealthServicesImpl( aMailboxApi ); + + CleanupStack::PushL( self ); + self->ConstructL(); + + IMUM_OUT(); + + return self; + } + +/****************************************************************************** + + Cleanup operations + +******************************************************************************/ + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::GetIMEIFromTheEntry() +// ---------------------------------------------------------------------------- +// +TIMDErrors CImumInHealthServicesImpl::GetIMEIFromTheEntry( + const TMsvId aEntryId, + TDes& aIMEI ) const + { + TMsvEntry mailbox; + TIMDErrors result = GetMailboxEntry( aEntryId, mailbox ); + + if ( result == EIMDNoError ) + { + aIMEI.Copy( mailbox.iDescription.Left( KIMAMaxPhoneIdLength ) ); + } + + return result; + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::GetIMEIFromTheEntry() +// ---------------------------------------------------------------------------- +// +TIMDErrors CImumInHealthServicesImpl::GetIMEIFromTheEntry( + const TMsvEntry& aEntry, + TDes& aIMEI ) const + { + // IMEI is stored into description field + aIMEI.Copy( aEntry.iDescription.Left( KIMAMaxPhoneIdLength ) ); + + return EIMDNoError; + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::GetIMEIFromThePhone() +// ---------------------------------------------------------------------------- +// +void CImumInHealthServicesImpl::GetIMEIFromThePhoneL() + { + IMUM_CONTEXT( CImumInHealthServicesImpl::GetIMEIFromThePhoneL, 0, KLogInApi ); + IMUM_IN(); + + // In Emulator version, the imei cannot be fetched, so the basic number + // is used instead +#ifndef __WINS__ + + RTelServer telServer; + User::LeaveIfError( telServer.Connect() ); + CleanupClosePushL(telServer); + + TInt numPhones = 0; + User::LeaveIfError( telServer.EnumeratePhones( numPhones ) ); + if ( numPhones < 1 ) + { + User::Leave( KErrNotFound ); + } + RTelServer::TPhoneInfo info; + User::LeaveIfError( telServer.GetPhoneInfo( 0, info ) ); + RMobilePhone mobilePhone; + User::LeaveIfError( mobilePhone.Open( telServer, info.iName ) ); + CleanupClosePushL( mobilePhone ); + + //mobilePhone.Initialise(); + TUint32 identityCaps; + User::LeaveIfError( mobilePhone.GetIdentityCaps( identityCaps ) ); + + if ( identityCaps & RMobilePhone::KCapsGetSerialNumber ) + { + TRequestStatus status; + RMobilePhone::TMobilePhoneIdentityV1 mobilePhoneIdentity; + + mobilePhone.GetPhoneId( status, mobilePhoneIdentity ); + + User::WaitForRequest( status ); + User::LeaveIfError( status.Int() ); + + iIMEI.Copy( mobilePhoneIdentity.iSerialNumber ); + } + else + { + User::Leave( KErrNotSupported ); + } + + CleanupStack::PopAndDestroy( &mobilePhone ); + CleanupStack::PopAndDestroy( &telServer ); +#else + iIMEI.Copy( KIMAEmulatorImei ); +#endif // __WINS__ + + IMUM1(0, "Phones IMEI code: %S", &iIMEI); + + IMUM_OUT(); + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::StoreIMEIToMailbox() +// ---------------------------------------------------------------------------- +// +TIMDErrors CImumInHealthServicesImpl::StoreIMEIToMailbox( + const TMsvId aMailboxId ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::StoreIMEIToMailbox, 0, KLogInApi ); + IMUM1_IN( "aMailboxId = 0x%x", aMailboxId ); + + // Get available mailbox entries + TMsvEntry entry; + TIMDErrors result = GetMailboxEntry( aMailboxId, entry ); + + // Imap4 & Pop3 & Smtp protocols contain two entries + if ( result == EIMDNoError ) + { + // Attempt to store the IMEI code to the entry + result = StoreIMEIToEntry( entry.Id() ); + } + + // Imap4 / Pop3 protocols have two different entries + if ( iUtils->IsMailMtm( entry.iMtm ) ) + { + TMsvEntry secondaryEntry; + result = GetMailboxEntry( entry.iRelatedId, entry ); + + if ( result == EIMDNoError ) + { + // Attempt to store the IMEI code to the entry + result = StoreIMEIToEntry( entry.Id() ); + } + } + + IMUM_OUT(); + + return result; + } + + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::StoreIMEIToEntry() +// ---------------------------------------------------------------------------- +// +TIMDErrors CImumInHealthServicesImpl::StoreIMEIToEntry( + const TMsvId aMailboxId ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::StoreIMEIToEntry, 0, KLogInApi ); + IMUM1_IN( "aMailboxId = 0x%x", aMailboxId ); + + TRAPD( error, StoreIMEIToEntryL( aMailboxId ) ); + + IMUM_OUT(); + return ( error == KErrNone ) ? EIMDNoError : EIMDStoringFailureWithIMEI; + } + + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::StoreIMEIToEntryL() +// ---------------------------------------------------------------------------- +// +void CImumInHealthServicesImpl::StoreIMEIToEntryL( + const TMsvId aMailboxId ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::StoreIMEIToEntryL, 0, KLogInApi ); + IMUM1_IN( "aMailboxId = 0x%x", aMailboxId ); + + CMsvEntry* centry = iInternalApi.MsvSession().GetEntryL( aMailboxId ); + CleanupStack::PushL( centry ); + + TMsvEntry tentry = centry->Entry(); + tentry.iDescription.Set( iIMEI ); + centry->ChangeL( tentry ); + + CleanupStack::PopAndDestroy( centry ); + centry = NULL; + + IMUM_OUT(); + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::GetMailboxEntry() +// ---------------------------------------------------------------------------- +// +TIMDErrors CImumInHealthServicesImpl::GetMailboxEntry( + const TMsvId aMailboxId, + TMsvEntry& aMailboxEntry ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::GetMailboxEntry, 0, KLogInApi ); + IMUM1_IN( "aMailboxId = 0x%x", aMailboxId ); + + // Get both receiving and sending entries of the mailbox + TIMDErrors result = EIMDNoError; + + TMsvId service; + TInt error = iInternalApi.MsvSession().GetEntry( + aMailboxId, service, aMailboxEntry ); + + // Make sure getting of the entry was ok + if ( error == KErrNone ) + { + // Verify that the entry has mail mtm + if ( !iUtils->IsMailMtm( aMailboxEntry.iMtm, ETrue ) ) + { + result = EIMDNotMailMtmId; + } + // Mailbox, log the details + else + { + IMUM0( 0, "************ Entry Data START ******************" ); + IMUM1( 0, "MailboxId = 0x%x", aMailboxEntry.Id() ); + IMUM1( 0, "RelatedId = 0x%x", aMailboxEntry.iRelatedId ); + IMUM1( 0, "MTM type = 0x%x", aMailboxEntry.iMtm.iUid ); + IMUM1( 0, "Visible = %d", aMailboxEntry.Visible() ); + IMUM1( 0, "iMtmData2 = 0x%x", aMailboxEntry.iMtmData2 ); + IMUM1( 0, "iDescription = %S", &aMailboxEntry.iDescription ); + IMUM1( 0, "iDetails = %S", &aMailboxEntry.iDetails ); + IMUM0( 0, "************* Entry Data END *******************" ); + + //Make sure that all settings are ok + if ( aMailboxEntry.iDetails.Length() > KIMASMaxMailboxNameLength ) + { + if ( aMailboxEntry.iMtm == KUidMsgTypeIMAP4 ) + { + result = EIMDGetEntryFailure; + TRAP_IGNORE( result = iInternalApi.SettingsStorerL().CheckMailboxNameImap( aMailboxEntry ) ); + // Should SettingsStorerL leave, result == EIMDGetEntryFailure + } + else if ( aMailboxEntry.iMtm == KUidMsgTypePOP3 ) + { + result = EIMDGetEntryFailure; + TRAP_IGNORE( result = iInternalApi.SettingsStorerL().CheckMailboxNamePop( aMailboxEntry ) ); + // Should SettingsStorerL leave, result == EIMDGetEntryFailure + } + else if ( aMailboxEntry.iMtm == KUidMsgTypeSMTP ) + { + result = EIMDGetEntryFailure; + TRAP_IGNORE( result = iInternalApi.SettingsStorerL().CheckMailboxNameSmtp( aMailboxEntry ) ); + // Should SettingsStorerL leave, result == EIMDGetEntryFailure + } + else + { + result = EIMDGetEntryFailure; + } + } + } + } + else + { + result = EIMDGetEntryFailure; + } + + IMUM1( 0, "Result of getting the entry: %d", result ); + IMUM_OUT(); + return result; + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::VerifyMailboxHealth() +// ---------------------------------------------------------------------------- +// +TIMDErrors CImumInHealthServicesImpl::VerifyMailboxHealth( + const TMsvId aMailboxId ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::VerifyMailboxHealth, 0, KLogInApi ); + IMUM1_IN( "aMailboxId = 0x%x", aMailboxId ); + + TMsvEntry primaryEntry; + TMsvEntry secondaryEntry; + TMsvEntry* secondaryEntryPtr = NULL; + TIMDErrors verification = GetMailboxEntry( aMailboxId, primaryEntry ); + + // Imap4 & Pop3 & Smtp protocols contain two entries + if ( verification == EIMDNoError && + iUtils->IsMailMtm( primaryEntry.iMtm ) ) + { + verification = GetMailboxEntry( + primaryEntry.iRelatedId, secondaryEntry ); + + if ( verification == EIMDNoError ) + { + secondaryEntryPtr = &secondaryEntry; + } + } + + // Make sure + if ( verification == EIMDNoError ) + { + verification = VerifyMailboxHealth( primaryEntry, secondaryEntryPtr ); + } + + IMUM_OUT(); + return verification; + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::VerifyMailboxHealth() +// ---------------------------------------------------------------------------- +// +TIMDErrors CImumInHealthServicesImpl::VerifyMailboxHealth( + const TMsvEntry& aPrimaryEntry, + const TMsvEntry* aSecondaryEntry ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::VerifyMailboxHealth, 0, KLogInApi ); + IMUM_IN(); + + // Verify that SMTP part of the mailbox has got the settings + // Verify that SMTP account id's matches with the settings + // Verify that SMTP mailbox id's matches with the settings + TIMDErrors verification = MatchEntryWithSettings( aPrimaryEntry ); + IMUM1( 0, "Mailbox primary entry IMEI settings matching result: %d", verification ); + + // Verify that related part of the mailbox has got the settings + // Verify that related account id's matches with the settings + // Verify that related mailbox id's matches with the settings + if ( !verification && aSecondaryEntry ) + { + verification = MatchEntryWithSettings( *aSecondaryEntry ); + IMUM1( 0, "Mailbox secondary entry IMEI settings matching result: %d", verification ); + } + + // Verify that primary entry has IMEI code stored + if ( !verification ) + { + verification = VerifyEntryIMEI( aPrimaryEntry ); + IMUM1( 0, "Mailbox primary entry IMEI verification result: %d", verification ); + if( verification == EIMDMissingIMEI ) + { + // Mailbox has no IMEI code stored. This Mailbox is most likely created + // with CEmailAccounts. Lock the account to current Phone. + verification = StoreIMEIToMailbox( aPrimaryEntry.Id() ); + IMUM1( 0, "IMEI missing. Lock to current device: %d", verification ); + } + } + + // Verify that related entry has IMEI code stored + if ( !verification && aSecondaryEntry ) + { + verification = VerifyEntryIMEI( *aSecondaryEntry ); + IMUM1( 0, "Mailbox secondary entry IMEI verification result: %d", verification ); + if( verification == EIMDMissingIMEI ) + { + // Mailbox has no IMEI code stored. This Mailbox is most likely created + // with CEmailAccounts. Lock the account to current Phone. + verification = StoreIMEIToMailbox( aSecondaryEntry->Id() ); + IMUM1( 0, "IMEI missing. Lock to current device: %d", verification ); + } + } + + IMUM_OUT(); + + return verification; + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::MatchEntryWithSettings() +// ---------------------------------------------------------------------------- +// +TIMDErrors CImumInHealthServicesImpl::MatchEntryWithSettings( + const TMsvEntry& aMailbox ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::MatchEntryWithSettings, 0, KLogInApi ); + IMUM1_IN( "aMailbox.Id = 0x%x", aMailbox.Id() ); + IMUM_OUT(); + + switch ( aMailbox.iMtm.iUid ) + { + case KSenduiMtmImap4UidValue: + return VerifyImap4EntryWithSettings( aMailbox ); + + case KSenduiMtmPop3UidValue: + return VerifyPop3EntryWithSettings( aMailbox ); + + case KSenduiMtmSmtpUidValue: + return VerifySmtpEntryWithSettings( aMailbox ); + + default: + // 3rd party mailbox + // MTM UID is unknown -> check technology type and return + // EIMDNoError if it is mailbox + if( iUtils->IsMailbox( aMailbox.Id() ) ) + { + return EIMDNoError; + } + break; + } + + return EIMDUnknownMailbox; + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::VerifyImap4EntryWithSettings() +// ---------------------------------------------------------------------------- +// +TIMDErrors CImumInHealthServicesImpl::VerifyImap4EntryWithSettings( + const TMsvEntry& aMailbox ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::VerifyImap4EntryWithSettings, 0, KLogInApi ); + IMUM1_IN( "aMailbox.Id = 0x%x", aMailbox.Id() ); + + // Get IMAP4 account information from the repository + TIMDErrors verification = EIMDNoError; + TImapAccount imapAccount; + TRAPD( error, iInternalApi.EmailAccountsL().GetImapAccountL( + aMailbox.Id(), imapAccount ) ); + + // Continue only, if successful + if ( error == KErrNone ) + { + // Verify that the entry's account id matches with repository + if ( aMailbox.iMtmData2 != imapAccount.iImapAccountId ) + { + verification = EIMDImap4AccountIdNotMatching; + } + + // Verify that the related id matches with the one in the repository + if ( verification == EIMDNoError && + aMailbox.iRelatedId != imapAccount.iSmtpService ) + { + verification = EIMDImap4RelatedEntryIdNotMatching; + } + } + else + { + verification = EIMDImap4AccountFailure; + } + + IMUM_OUT(); + return verification; + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::VerifyPop3EntryWithSettings() +// ---------------------------------------------------------------------------- +// +TIMDErrors CImumInHealthServicesImpl::VerifyPop3EntryWithSettings( + const TMsvEntry& aMailbox ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::VerifyPop3EntryWithSettings, 0, KLogInApi ); + IMUM1_IN( "aMailbox.Id = 0x%x", aMailbox.Id() ); + + // Get POP3 account information from the repository + TIMDErrors verification = EIMDNoError; + TPopAccount popAccount; + TRAPD( error, iInternalApi.EmailAccountsL().GetPopAccountL( + aMailbox.Id(), popAccount ) ); + + // Continue only, if successful + if ( error == KErrNone ) + { + // Verify that the entry's account id matches with repository + if ( aMailbox.iMtmData2 != popAccount.iPopAccountId ) + { + verification = EIMDPop3AccountIdNotMatching; + } + + // Verify that the related id matches with the one in the repository + if ( verification == EIMDNoError && + aMailbox.iRelatedId != popAccount.iSmtpService ) + { + verification = EIMDPop3RelatedEntryIdNotMatching; + } + } + else + { + verification = EIMDPop3AccountFailure; + } + + IMUM_OUT(); + return verification; + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::VerifySmtpEntryWithSettings() +// ---------------------------------------------------------------------------- +// +TIMDErrors CImumInHealthServicesImpl::VerifySmtpEntryWithSettings( + const TMsvEntry& aMailbox ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::VerifySmtpEntryWithSettings, 0, KLogInApi ); + IMUM1_IN( "aMailbox.Id = 0x%x", aMailbox.Id() ); + + // Get SMTP account information from the repository + TIMDErrors verification = EIMDNoError; + TSmtpAccount smtpAccount; + TRAPD( error, iInternalApi.EmailAccountsL().GetSmtpAccountL( + aMailbox.Id(), smtpAccount ) ); + + // Continue only, if successful + if ( error == KErrNone ) + { + // Verify that the entry's account id matches with repository + if ( aMailbox.iMtmData2 != smtpAccount.iSmtpAccountId ) + { + verification = EIMDSmtpAccountIdNotMatching; + } + + // Verify that the related id matches with the one in the repository + if ( verification == EIMDNoError && + aMailbox.iRelatedId != smtpAccount.iRelatedService ) + { + verification = EIMDSmtpRelatedEntryIdNotMatching; + } + } + else + { + verification = EIMDSmtpAccountFailure; + } + + IMUM_OUT(); + return verification; + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::VerifyEntryIMEI() +// ---------------------------------------------------------------------------- +// +TIMDErrors CImumInHealthServicesImpl::VerifyEntryIMEI( + const TMsvEntry& aMailbox ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::VerifyEntryIMEI, 0, KLogInApi ); + IMUM1_IN( "aMailbox.Id = 0x%x", aMailbox.Id() ); + + TIMDErrors result = EIMDNoError; + + // In emulator, always return true for the IMEI verification, + // so that mismatching IMEI codes doesn't prevent debugging + + // Make sure the field contains at least something + if ( aMailbox.iDescription.Length() ) + { + if ( iIMEI.Match( aMailbox.iDescription ) ) + { + TDriveUnit driveUnit = EDriveC; + TRAPD( err, driveUnit = + iInternalApi.MsvSession().CurrentDriveL() ); + + // When memory card restored to another phone emailbox should be visible + if ( err == KErrNone && driveUnit == EDriveC ) + { + result = StoreIMEIToMailbox( aMailbox.Id() ); + } + else + { + result = EIMDMismatchingIMEI; + } + } + } + else + { + result = EIMDMissingIMEI; + } + + IMUM_OUT(); + return result; + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::IsRequiredMailbox() +// ---------------------------------------------------------------------------- +// +TBool CImumInHealthServicesImpl::IsRequiredMailbox( + const TMsvEntry& aEntry, + const TMuiuFlags& aFlags ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::IsRequiredMailbox, 0, KLogInApi ); + IMUM1_IN( "aEntry.Id() = 0x%x", aEntry.Id() ); + + IMUM1( 0, "ServiceEntry: %d", aEntry.iType.iUid == KUidMsvServiceEntryValue ); + IMUM1( 0, "Entry ID not Local: %d", aEntry.Id() != KMsvLocalServiceIndexEntryIdValue ); + + // Accept only services. + TBool result = ( aEntry.iType.iUid == KUidMsvServiceEntryValue ) && + ( aEntry.Id() != KMsvLocalServiceIndexEntryIdValue ); + + IMUM1( 0, "Result after service test: %d", result ); + + if ( result ) + { + IMUM1( 0, "Get healthy mailboxes: %d", !aFlags.Flag( EFlagHealthy ) ); + IMUM1( 0, "Entry is visible: %d", aEntry.Visible() ); + IMUM1( 0, "Entry is SMTP: %d", aEntry.iMtm == KSenduiMtmSmtpUid ); + + // For valid mailboxes, only visible entries are allowed. For cleanup, + // all entries must be allowed. + result = !aFlags.Flag( EFlagHealthy ) | aEntry.Visible(); + + // Smtp services are invisible, so the result must be acceptable + // for them. + result |= !aEntry.Visible() && aEntry.iMtm == KSenduiMtmSmtpUid; + + IMUM1( 0, "Result after entry test: %d", result ); + } + + if ( result ) + { + // Entry is valid service entry. Now, check if the mailbox is... + + // ...Imap4 and it is required... + IMUM2( 0, "IMAP4 required: %d AND entry is IMAP4 %d", + aFlags.Flag( EFlagImap4 ), + aEntry.iMtm == KSenduiMtmImap4Uid ); + + result = + aFlags.Flag( EFlagImap4 ) && + aEntry.iMtm == KSenduiMtmImap4Uid; + + // ...or Pop3 and it is required... + IMUM2( 0, "POP3 required: %d AND entry is POP3 %d", + aFlags.Flag( EFlagPop3 ), + aEntry.iMtm == KSenduiMtmPop3Uid ); + + result |= + aFlags.Flag( EFlagPop3 ) && + aEntry.iMtm == KSenduiMtmPop3Uid; + + // ...or Smtp and it is required... + IMUM2( 0, "SMTP required: %d AND entry is SMTP %d", + aFlags.Flag( EFlagSmtp ), + aEntry.iMtm == KSenduiMtmSmtpUid ); + + result |= + aFlags.Flag( EFlagSmtp ) && + aEntry.iMtm == KSenduiMtmSmtpUid; + + // ...or other MTM and it is required + IMUM2( 0, "Other required: %d AND entry is other %d", + aFlags.Flag( EFlagOtherService ), + aEntry.iMtm != KSenduiMtmSmtpUid && + aEntry.iMtm != KSenduiMtmPop3Uid && + aEntry.iMtm != KSenduiMtmImap4Uid ); + + result |= + aFlags.Flag( EFlagOtherService ) && + aEntry.iMtm != KSenduiMtmSmtpUid && + aEntry.iMtm != KSenduiMtmPop3Uid && + aEntry.iMtm != KSenduiMtmImap4Uid; + + IMUM1( 0, "Result of service test: %d", result ); + } + + IMUM_OUT(); + return result; + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::DoGetMailboxList() +// ---------------------------------------------------------------------------- +// +void CImumInHealthServicesImpl::DoGetMailboxList( + RMailboxIdArray& aMailboxArray, + const TMuiuFlags& aFlags ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::DoGetMailboxList, 0, KLogInApi ); + IMUM_IN(); + + TBool getHealthy = aFlags.Flag( EFlagHealthy ); + + for ( TInt item = iRoot->Count(); --item >= 0; ) + { + // Check if the item is mailbox flagged to be retrieved + const TMsvEntry& candidate = ( *iRoot )[item]; + if ( IsRequiredMailbox( candidate, aFlags ) ) + { + // Append to array, if healthy and healthy required OR + // unhealthy and unhealthy required + if ( IsMailboxHealthy( candidate.Id() ) == getHealthy ) + { + IMUM1( 0, "Adding candidate 0x%x to list", candidate.Id() ); + aMailboxArray.Append( candidate.Id() ); + } + } + } + + IMUM_OUT(); + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::DoCleanup() +// ---------------------------------------------------------------------------- +// +void CImumInHealthServicesImpl::DoCleanup( + const RMailboxIdArray& aMailboxArray ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::DoCleanup, 0, KLogInApi ); + IMUM_IN(); + + for ( TInt mailbox = aMailboxArray.Count(); --mailbox >= 0; ) + { + TMsvId serviceId; + TMsvEntry entry; + TInt error = iInternalApi.MsvSession().GetEntry( + aMailboxArray[mailbox], serviceId, entry ); + + // We detect only missing settings, so remove the entries only if + // created on this phone + if ( error == KErrNone && VerifyEntryIMEI( entry ) == EIMDNoError ) + { + + iInternalApi.MsvSession().RemoveEntry( entry.Id() ); + iInternalApi.MsvSession().RemoveEntry( entry.iRelatedId ); + } + } + + IMUM_OUT(); + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::PrepareFlags() +// ---------------------------------------------------------------------------- +// +TMuiuFlags CImumInHealthServicesImpl::PrepareFlags( + const TInt64 aFlags ) const + { + TMuiuFlags flags = aFlags; + + return flags; + } + +/****************************************************************************** + + Functions from the base classes + +******************************************************************************/ + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::GetMailboxList() +// ---------------------------------------------------------------------------- +// +TInt CImumInHealthServicesImpl::GetMailboxList( + RMailboxIdArray& aHealthyMailboxArray, + const TInt64 aFlags, + const TBool aClearArray ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::GetMailboxList, 0, KLogInApi ); + IMUM2_IN( "aFlags = 0x%x, aClearArray = %d", aFlags, aClearArray ); + + TInt error = KErrNone; + + if ( aClearArray ) + { + aHealthyMailboxArray.Reset(); + } + + DoGetMailboxList( aHealthyMailboxArray, PrepareFlags( aFlags ) ); + + IMUM_OUT(); + + return error; + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::GetHealthyMailboxList() +// ---------------------------------------------------------------------------- +// +TInt CImumInHealthServicesImpl::GetHealthyMailboxList( + RMailboxIdArray& aHealthyMailboxArray, + const TInt64 aFlags, + const TBool aClearArray ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::GetHealthyMailboxList, 0, KLogInApi ); + IMUM_IN(); + + IMUM_OUT(); + return GetMailboxList( aHealthyMailboxArray, aFlags, aClearArray ); + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::IsMailboxHealthy() +// ---------------------------------------------------------------------------- +// +TBool CImumInHealthServicesImpl::IsMailboxHealthy( + const TMsvId aMailboxId ) const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::IsMailboxHealthy, 0, KLogInApi ); + IMUM1_IN( "aMailboxId = 0x%x", aMailboxId ); + + TIMDErrors verification = VerifyMailboxHealth( aMailboxId ); + + IMUM_OUT(); + return !verification; + } + +// ---------------------------------------------------------------------------- +// CImumInHealthServicesImpl::CleanupUnhealthyMailboxes() +// ---------------------------------------------------------------------------- +// +void CImumInHealthServicesImpl::CleanupUnhealthyMailboxes() const + { + IMUM_CONTEXT( CImumInHealthServicesImpl::CleanupUnhealthyMailboxes, 0, KLogInApi ); + IMUM_IN(); + + RMailboxIdArray unhealthyMailboxes; + TMuiuFlags flags; + + flags.SetFlag( EFlagImap4 ); + flags.SetFlag( EFlagPop3 ); + + DoGetMailboxList( unhealthyMailboxes, flags ); + DoCleanup( unhealthyMailboxes ); + + unhealthyMailboxes.Reset(); + + IMUM_OUT(); + } + + +// End of File +