FCL/sf/app/commonemail: comparison ipsservices/ipssosplugin/src/ipsplgsosbaseplugin.cpp

equal deleted inserted replaced

-:478bc57ad291
+:64e38f08e49c
 // <qmail>
 #include "ipsplgsosbaseplugin.hrh"
 #include "ipsplgmailstoreroperation.h"
 #include "ipsplgmessagepartstoreroperation.h"
 #include "BasePlugin.h"
 //<Qmail>
 #include "ipssosextendedsettingsmanager.h"
 #include "ipssettingkeys.h"
 //</Qmail>
 //</qmail>
 {
 if(aInterfaceUid != KEmailMailboxStateExtensionUid)
 {
 User::Leave(KErrNotSupported);
 }
 return iStateExtension;
 }
 //</Qmail>
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // <qmail> iSettingsApi, iWait removed
-CIpsPlgSosBasePlugin::~CIpsPlgSosBasePlugin()
+EXPORT_C CIpsPlgSosBasePlugin::~CIpsPlgSosBasePlugin()
 {
 FUNC_LOG;
 iOperations.ResetAndDestroy();
 iActivitytimers.ResetAndDestroy();
 iOperations.Close();
 TRAP( err, aosession.RelayCommandL(
 EServerAPIEmailDisableAOEmailPlugin,
 dummyBuf ) );
 }
 aosession.Close();
 #endif
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::CompleteConstructL()
 CleanupStack::PushL( smtpSet );
 acc->LoadSmtpSettingsL( smtpAcc, *smtpSet );
 address = smtpSet->EmailAddress().AllocL();
 CleanupStack::PopAndDestroy( 2, acc );
 // </qmail>
 CleanupStack::PushL( address ); // << address
 CFSMailAddress* fsAddress = CFSMailAddress::NewLC();    // << fsAddress
 fsAddress->SetEmailAddress( *address );
 result->SetOwnMailAddressL( fsAddress );
 CleanupStack::Pop( fsAddress ); // >> fsAddress
 TMsvId service;
 if( !iSessionOk )
 {
 User::Leave( KErrNotReady );
 }
 // <qmail> RAlwaysOnlineClientSession - related code removed
 // Prepare the parameters to be forwarded to AO-server
 TPckg<TMsvId> param = aMailBoxId.Id();
 // delete MRU list from cen rep
 aSourceFolderId,
 aDestinationFolderId );
 ret = KErrNone;
 }
 ret = KErrNotSupported;
 TFSProgress progress = {
 TFSProgress::EFSStatus_RequestComplete, 0, 0, ret };
 aOperationObserver.RequestResponseL(
 progress, aRequestId );
 return ret;
 }
 RArray<TFSMailMsgId>& /*aNewMessages*/,
 const TFSMailMsgId& /*aSourceFolderId*/,
 const TFSMailMsgId& /*aDestinationFolderId*/ )
 	{
 	}
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-MDesCArray* CIpsPlgSosBasePlugin::GetMrusL(
-const TFSMailMsgId& aMailBoxId)
-{
-return iMruList->GetMruListL( aMailBoxId );
-}
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-void CIpsPlgSosBasePlugin::SetMrusL(
-const TFSMailMsgId& aMailBoxId,
-MDesCArray*  aNewMruList )
-{
-iMruList->SetMruListL( aMailBoxId, aNewMruList );
-}
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::GoOnlineL( const TFSMailMsgId& aMailBoxId )
 {
 || baseOp->IpsOpType() == EIpsOpTypeImap4PopulateOp ) )
 {
 DeleteAndRemoveOperation( i, KErrCancel );
 }
 }
 #ifndef RD_101_EMAIL
 RAlwaysOnlineClientSession aosession;
 err = aosession.Connect();
 if ( err == KErrNone )
 {
 TPckgBuf<TMsvId> buf(aMailBoxId.Id());
 TRAP( err, aosession.RelayCommandL(
 EServerAPIEmailCancelAllAndDoNotDisconnect, buf ) );
 }
 aosession.Close();
 #endif
 return err;
 }
 // ----------------------------------------------------------------------------
 const TInt aRequestId )
 {
 FUNC_LOG;
 // asynchronous message creation is started here to enable canceling of the operation
 TMsvPartList partList( KMsvMessagePartBody );
 CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewLC(*this);
 //<qmail> removed mboxEntry from parameters + changed iSmtpService to pointer
 CIpsPlgCreateMessageOperation* op = CIpsPlgCreateMessageOperation::NewL(
 *iSmtpService,
 *iSession,
 watcher->iStatus,
 partList,
 aMailBoxId,
 aOperationObserver,
 aRequestId );
 //</qmail>
 watcher->SetOperation( op );
 iOperations.AppendL( watcher );
 CleanupStack::Pop( watcher );
 }
 // </qmail>
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 CFSMailMessage* CIpsPlgSosBasePlugin::CreateForwardMessageL(
 const TFSMailMsgId& /*aMailBoxId*/,
 const TFSMailMsgId& /*aOriginalMessageId*/,
 }
 // <qmail>
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::CreateForwardMessageL(
 const TFSMailMsgId& aMailBoxId,
 const TFSMailMsgId& aOriginalMessageId,
 MFSMailRequestObserver& aOperationObserver,
 const TInt aRequestId,
 const TDesC& /*aHeaderDescriptor*/ )
 {
 FUNC_LOG;
 // asynchronous message creation is started here to enable canceling of the operation
 // 1. part of function checs that body text and all
 // attachments are fetched
 TMsvEntry orgMsg;
 TMsvId service;
 User::LeaveIfError( iSession->GetEntry(
 aOriginalMessageId.Id(), service, orgMsg ) );
 if ( orgMsg.Id() ==  KMsvNullIndexEntryIdValue )
 {
 User::Leave(KErrNotFound);
 }
 if ( ( orgMsg.Parent() == KMsvSentEntryIdValue ) &&
 ( orgMsg.iMtm == KSenduiMtmSmtpUid ) )
 {
 iSmtpService->ChangeServiceIdL( orgMsg );
 }
 TMsvPartList partList( KMsvMessagePartBody | KMsvMessagePartAttachments );
 CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewLC(*this);
 //<qmail> changed iSmtpService to pointer
 CIpsPlgCreateForwardMessageOperation* op = CIpsPlgCreateForwardMessageOperation::NewL(
 *iSmtpService,
 *iSession,
 watcher->iStatus,
 partList,
 aMailBoxId,
 orgMsg.Id(),
 aOperationObserver,
 aRequestId );
 //</qmail>
 watcher->SetOperation( op );
 iOperations.AppendL( watcher );
 CleanupStack::Pop( watcher );
 }
 // </qmail>
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 CFSMailMessage* CIpsPlgSosBasePlugin::CreateReplyMessageL(
 const TFSMailMsgId& /*aMailBoxId*/,
 const TFSMailMsgId& /*aOriginalMessageId*/,
 const TBool /*aReplyToAll*/,
 const TDesC& /*aHeaderDescriptor*/ )
 {
 return NULL; // prevents compiler warning
 }
 // <qmail>
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::CreateReplyMessageL(
 const TFSMailMsgId& aMailBoxId,
 const TFSMailMsgId& aOriginalMessageId,
 const TBool aReplyToAll,
 MFSMailRequestObserver& aOperationObserver,
 const TInt aRequestId,
 const TDesC& /* aHeaderDescriptor */ )
 {
 FUNC_LOG;
 // asynchronous message creation is started here to enable canceling of the operation
 // find orginal message header and check that body is fetched
 TMsvEntry orgMsg;
 TMsvId service;
 User::LeaveIfError(
 iSession->GetEntry( aOriginalMessageId.Id(), service, orgMsg ) );
 if ( orgMsg.Id() ==  KMsvNullIndexEntryIdValue )
 {
 User::Leave(KErrNotFound);
 }
 if ( ( orgMsg.Parent() == KMsvSentEntryIdValue ) &&
 ( orgMsg.iMtm == KSenduiMtmSmtpUid ) )
 {
 iSmtpService->ChangeServiceIdL( orgMsg );
 }
 // partList flags control e.g. what kind of recipient set is created
 TMsvPartList partList = KMsvMessagePartBody | KMsvMessagePartDescription
 | KMsvMessagePartOriginator;
 if( aReplyToAll )
 {
 partList |= KMsvMessagePartRecipient;
 }
 CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewLC(*this);
 //<qmail> changed iSmtpService to pointer
 CIpsPlgCreateReplyMessageOperation* op = CIpsPlgCreateReplyMessageOperation::NewL(
 *iSmtpService,
 *iSession,
 watcher->iStatus,
 partList,
 aMailBoxId,
 orgMsg.Id(),
 aOperationObserver,
 aRequestId );
 //</qmail>
 watcher->SetOperation( op );
 iOperations.AppendL( watcher );
 CleanupStack::Pop( watcher );
 }
 // </qmail>
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 //
 void CIpsPlgSosBasePlugin::StoreMessageL(
 const TFSMailMsgId& aMailBoxId,
 CFSMailMessage& aMessage )
 	{
 FUNC_LOG;
 TInt status( KErrNone);
 if ( incoming )
 {
 		// <qmail> Cmail change to synchronous call (UpdateMessageFlagsL) ignored,
 // <qmail> because it causes emulator & HW to freeze on 10.1
 CIpsPlgSingleOpWatcher* opW = CIpsPlgSingleOpWatcher::NewLC( *this );
 CMsvOperation* op = iMsgMapper->UpdateMessageFlagsAsyncL(
 msgId.Id(), aMessage, opW->iStatus );
 if ( op )
 {
 opW->SetOperation( op );
 iOperations.AppendL( opW );
 CleanupStack::Pop( opW );
 void CIpsPlgSosBasePlugin::StoreMessagesL(
 const TFSMailMsgId& /*aMailBox*/,
 RPointerArray<CFSMailMessage> &messages,
 MFSMailRequestObserver& aOperationObserver,
 const TInt aRequestId )
 {
 CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewL(*this);
 CleanupStack::PushL(watcher);
 CIpsPlgMailStorerOperation* op =
 CIpsPlgMailStorerOperation::NewLC(
 *iSession,
 watcher->iStatus,
 *this,
 messages,
 aOperationObserver,
 aRequestId );
 watcher->SetOperation(op);
 iOperations.AppendL(watcher);
 CleanupStack::Pop( 2, watcher );
 }
 // </qmail>
 return NULL; // prevents compiler warning
 }
 // <qmail>
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::NewChildPartFromFileL(
 const TFSMailMsgId& aMailBoxId,
 const TFSMailMsgId& /* aParentFolderId */,
 const TFSMailMsgId& aMessageId,
 const TFSMailMsgId& /* aParentPartId */,
 MFSMailRequestObserver& aOperationObserver,
 const TInt aRequestId )
 {
 FUNC_LOG;
 CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewLC(*this);
 CIpsPlgNewChildPartFromFileOperation* op = CIpsPlgNewChildPartFromFileOperation::NewL(
 *iSession,
 watcher->iStatus,
 aMailBoxId,
 aMessageId,
 aContentType,
 aFilePath,
 aOperationObserver,
 aRequestId,
 iMsgMapper);
 watcher->SetOperation( op );
 iOperations.AppendL( watcher );
 CleanupStack::Pop( watcher );
 }
 // </qmail>
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 CFSMailMessagePart* CIpsPlgSosBasePlugin::NewChildPartFromFileL(
 const TFSMailMsgId& /*aMailBoxId*/,
 const TFSMailMsgId& /*aParentFolderId*/,
 const TFSMailMsgId& /*aMessageId*/,
 const TFSMailMsgId& /*aParentPartId*/,
 User::Leave(KErrFSMailPluginNotSupported);
 	}
 // <qmail>
 // ----------------------------------------------------------------------------
 // Supports currently deletion of attachments and multipart structures
 // which are represented as folders in Symbian store)
 // ----------------------------------------------------------------------------
 //
 void CIpsPlgSosBasePlugin::RemoveChildPartL(
 const TFSMailMsgId& /* aMailBoxId */,
 const TFSMailMsgId& /* aParentFolderId */,
 const TFSMailMsgId& aMessageId,
 MFSMailRequestObserver& aOperationObserver,
 const TInt aRequestId )
 {
 FUNC_LOG;
 CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewLC(*this);
 CIpsPlgRemoveChildPartOperation* op = CIpsPlgRemoveChildPartOperation::NewL(
 *iSession,
 watcher->iStatus,
 aMessageId,
 aPartId,
 aOperationObserver,
 aRequestId);
 watcher->SetOperation( op );
 iOperations.AppendL( watcher );
 CleanupStack::Pop( watcher );
 }
 // </qmail>
 // ----------------------------------------------------------------------------
 // The implementation bypass CImEmailMessage and its email's attachment
 // manager. Instead, it calls Symbian framework classes directly by
 // accessing the attachment entry.
 // Qmail change: returns file handle for read/write
 // ----------------------------------------------------------------------------
 TInt CIpsPlgSosBasePlugin::GetMessagePartFileL(
 const TFSMailMsgId& /* aMailBoxId */,
 const TFSMailMsgId& /* aParentFolderId */,
 const TFSMailMsgId& /* aMessageId */,
 const TFSMailMsgId& aMessagePartId,
 RFile& aFileHandle)
 const TFSMailMsgId& /* aParentFolderId */,
 const TFSMailMsgId& /* aMessageId */,
 const TFSMailMsgId& aMessagePartId )
 	{
 FUNC_LOG;
 //<qmail> Rewritten in Qmail: CIpsPlgOperationWait is no longer used
 // Notice that SetContentL sets only the content of text/plain message part:
 // text/html part can be modified directly using GetMessagePartFileL
 	CMsvEntry* cEntry( NULL );
 CMsvStore* store = NULL;
 // following code should fill text/plain content
 cEntry = iSession->GetEntryL( aMessagePartId.Id() );
 CleanupStack::PushL( cEntry );
 TBool hasStore = cEntry->HasStoreL();
 if ( hasStore ) {
 {
 }
 //<qmail>
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::StoreMessagePartsL(
 RPointerArray<CFSMailMessagePart>&  aMessageParts,
 MFSMailRequestObserver& aOperationObserver,
 const TInt aRequestId )
 {
 CleanupStack::PushL(watcher);
 CIpsPlgMessagePartStorerOperation* op =
 CIpsPlgMessagePartStorerOperation::NewLC(*iSession,
 watcher->iStatus, *this, aMessageParts,
 aOperationObserver, aRequestId);
 watcher->SetOperation(op);
 iOperations.AppendL(watcher);
 CleanupStack::Pop( 2, watcher );
 }
 //<//qmail>
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::UnregisterRequestObserver( TInt /* aRequestId */)
 {
 }
 // ----------------------------------------------------------------------------
 op->StartSendL( aMessageId.Id() );
 iOperations.AppendL(watcher);
 CleanupStack::Pop( watcher );
 	}
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::SendMessageL( CFSMailMessage& /*aMessage*/ )
 {
 FUNC_LOG;
 // <qmail>
 User::Leave( KErrFSMailPluginNotSupported );
 CleanupStack::PushL(sel);
 TInt count = aMessages.Count();
 TMsvEntry tEntry;
 TMsvId service;
 for(TInt i=0; i<count; i++)
 {
 iSession->GetEntry( aMessages[i].Id(), service, tEntry );
 //make sure that only messages get deleted.
 if( tEntry.iType == KUidMsvMessageEntry )
 {
 			// <qmail>
 sel->AppendL( tEntry.Id() );
 			// </qmail>
 }
 }
 CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewL( *this );
 CleanupStack::PushL( watcher );
 //<qmail>
 CMsvOperation* op = CIpsPlgDeleteOperation::NewL( *iSession,
 watcher->iStatus, sel );
 CleanupStack::PushL(sel);
 TInt count = aMessages.Count();
 TMsvEntry tEntry;
 TMsvId service;
 for(TInt i=0; i<count; i++)
 {
 iSession->GetEntry( aMessages[i].Id(), service, tEntry );
 //make sure that only messages get deleted.
 if( tEntry.iType == KUidMsvMessageEntry )
 {
 sel->AppendL( tEntry.Id() );
 }
 }
 CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewL( *this );
 CleanupStack::PushL( watcher );
 CMsvOperation* op = CIpsPlgDeleteOperation::NewL( *iSession,
 watcher->iStatus, sel, aOperationObserver, aRequestId );
 watcher->SetOperation( op );
 	const TDesC& /*aUsername*/, const TDesC& /*aPassword*/ )
 	{
 // <qmail> not used; should be removed
 //    FUNC_LOG;
 //	TBool cancelled = EFalse;
 //
 //	if ( aPassword.Length() > 0 )
 //	    {
 //    	//Set new password and signal (possible) ongoing connect operation
 //    	//CIpsSetDataApi* api = CIpsSetDataApi::NewL( *iSession );
 //        //CleanupStack::PushL( api );
 //
 //        //CMsvEntry* cEntry = iSession->GetEntryL( aMailBoxId.Id() );
 //        //CleanupStack::PushL( cEntry );
 //
 //        //api->SetNewPasswordL( *cEntry, aPassword );
 //
 //        //CleanupStack::PopAndDestroy( 2, api );//cEntry, api
 //
 //        //now signal through eventhandler that credientials have been set
 //	    }
 //	else
 //	    {
 //	    cancelled = ETrue;
 //	    }
 }
 aMessageEntry = iCachedEntry;
 aImEmailMessage = iCachedEmailMessage;
 }
 // ----------------------------------------------------------------------------
 // CIpsPlgSosBasePlugin::TakeMessageEntryL( )
 // Takes ownership of the cached objects or creates new ones
 // ----------------------------------------------------------------------------
 iCachedEmailMessage->IsActive() )
 {
 // Can't use the ones that are in cache, create new ones and don't replace the ones in cache
 aMessageEntry = iSession->GetEntryL( aId );
 aImEmailMessage = 0;
 if ( aMessageEntry->Entry().iType == KUidMsvMessageEntry )
 {
 CleanupStack::PushL( aMessageEntry );
 aImEmailMessage = CImEmailMessage::NewL( *aMessageEntry );
 CleanupStack::Pop();
 	aMessageEntry = iCachedEntry;
 	aImEmailMessage = iCachedEmailMessage;
 	iCachedEntry = 0;
 	iCachedEmailMessage = 0;
 	}
 // Ownership is transferred to the caller
 CleanupStack::PushL( aMessageEntry );
 CleanupStack::PushL( aImEmailMessage );
 }
 CMsvEntry* aMessageEntry,
 CImEmailMessage* aImEmailMessage )
 	{
 	// Clean old ones from the cache
 	CleanCachedMessageEntries();
 	// Always save the latest ones in the cache
 	iCachedEntry = aMessageEntry;
 	iCachedEmailMessage = aImEmailMessage;
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 //
 void CIpsPlgSosBasePlugin::CleanCachedMessageEntries()
 {
 void CIpsPlgSosBasePlugin::DeleteAndRemoveOperation(
 const TInt aOpArrayIndex, TInt aCompleteCode )
 {
 FUNC_LOG;
 CIpsPlgSingleOpWatcher* opWatcher = iOperations[aOpArrayIndex];
 // <qmail> removed; does nothing
 // The operations matches, handle it in protocol plugin...if needed.
 //TRAP_IGNORE( HandleOpCompletedL( *opWatcher, aCompleteCode ) );
 // </qmail>
 const CIpsPlgBaseOperation* op = opWatcher->BaseOperation();
 FUNC_LOG;
 CFSMailMessagePart* textBodyPart = aMessage->PlainTextBodyPartL();
 if ( textBodyPart )
 {
 CleanupStack::PushL( textBodyPart );
 CFSMailMessage* origMsg = GetMessageByUidL(
 aMailBoxId,
 TFSMailMsgId(),
 aOriginalMessageId,
 EFSMsgDataStructure );
 if ( origMsg )
 {
 CleanupStack::PushL( origMsg );
 CFSMailMessagePart* origMsgTextBodyPart =
 origMsg->PlainTextBodyPartL();
 if ( origMsgTextBodyPart )
 {
 CleanupStack::PushL( origMsgTextBodyPart );
 // Use the content provided in aHeaderDescriptor
 // instead of what is provided by
 // CreateForwardSmtpMessage..
 TPckgBuf<TReplyForwardParams> pckg;
 pckg.Copy( aHeaderDescriptor );
 TPtr hPtr( pckg().iHeader->Des() );
 HBufC* body = HBufC::NewLC(
 textBodyPart->FetchedContentSize() );
 TPtr bPtr( body->Des() );
 origMsgTextBodyPart->GetContentToBufferL( bPtr, 0 );
 HBufC* content = HBufC::NewLC(
 hPtr.Length() + bPtr.Length() );
 TPtr cPtr( content->Des() );
 cPtr.Append( hPtr );
 cPtr.Append( bPtr );
 textBodyPart->SetContent( cPtr );
 textBodyPart->SaveL();
 CleanupStack::PopAndDestroy( content );
 sel->AppendL( service );
 CIpsPlgBaseOperation* op = CIpsPlgDisconnectOp::NewL(
 *iSession,
 watcher->iStatus,
 service,
 ActivityTimerL( aMailBoxId ),
 aMailBoxId,
 &aObserver,
 aRequestId );
 watcher->SetOperation( op );
 CleanupStack::PopAndDestroy( sel );
 iOperations.AppendL( watcher );
 return iSyncStateHandler->ConnOpRunning( aMailBoxId );
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::SetMailboxName(
 const TFSMailMsgId& aMailboxId,
 const TDesC& /*aMailboxName*/ )
 {
 FUNC_LOG;
 TMsvEntry tEntry;
 TMsvId service;
 {
 FUNC_LOG;
 TBool ret( EFalse );
 for ( TInt i = 0; i < iOperations.Count(); i++ )
 {
 if( iOperations[i]->BaseOperation() &&
 iOperations[i]->BaseOperation()->FSMailboxId() == aMailboxId )
 {
 ret = ETrue;
 }
 }
 const TFSMailMsgId& aActiveFolderId)
 {
 TMsvId service;
 TMsvEntry folder;
 iSession->GetEntry( aActiveFolderId.Id(), service, folder );
 //currently, no actions unless this is inbox
 //also, if id is '0', it means inbox before first sync...it doesn't really exist yet
 if( folder.iDetails.CompareF( KIpsPlgInbox ) == 0 || folder.Id() == 0 ||
 ( folder.iMtm == KSenduiMtmPop3Uid ) &&
 ( folder.iType == KUidMsvServiceEntry ) &&
 ( folder.iServiceId == aActiveFolderId.Id() ) )
 {
 //folder is inbox
 == KIpsSosEmailSyncStarted )
 {
 //we won't do anything if sync is already started
 return;
 }
 //check are we in polling mode
 NmIpsSosExtendedSettingsManager* eMgr=
 new NmIpsSosExtendedSettingsManager(aActiveMailboxId.Id());
 QVariant value;
 bool ok = eMgr->readSetting(IpsServices::ReceptionActiveProfile, value);
 delete eMgr;
 if ( ok )
 {
 TInt profile = value.toInt();
 if ( profile != IpsServices::EmailSyncProfileManualFetch )
 {
 // let's sync
 GoOnlineL(aActiveMailboxId);
 }
 }
 }
 }
 // </qmail>

changeset 72	64e38f08e49c
parent 65	478bc57ad291
child 68	83cc6bae1de8