FCL/sf/app/messaging: comparison email/imap4mtm/imapprotocolcontroller/src/cimapprotocolcontroller.cpp

equal deleted inserted replaced

-:6a20128ce557
+:ebfee66fde93
+// Copyright (c) 2008-2009 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:
+//
+#include <imapset.h>
+#include <mentact.h>
+#include <miut_err.h>
+#include "cimapprotocolcontroller.h"
+#include "cimapsettings.h"
+#include "cimapsessionmanager.h"
+#include "cimapsession.h"
+#include "cimapsessionconsts.h"
+#include "cimapmailstore.h"
+#include "cimapofflinecontrol.h"
+#include "cimapsyncmanager.h"
+#include "cimapfolder.h"
+#include "cimapcompoundcopyfromlocal.h"
+#include "cimapcompoundcopytolocal.h"
+#include "cimapcompoundcopywithinservice.h"
+#include "cimapcompoundcreate.h"
+#include "cimapcompounddelete.h"
+#include "cimapcompounddeletefolder.h"
+#include "cimapcompounddisconnect.h"
+#include "cimapcompoundrename.h"
+#include "cimapcompoundselect.h"
+#include "cimapcompoundsyncfolder.h"
+#include "cimapcompoundsynctree.h"
+#include "cimapcompoundsyncservice.h"
+#include "cimapopbackgroundsync.h"
+#include "cimapidlecontroller.h"
+#include "cimapupdateflagoperation.h"
+#include "cimaplogger.h"
+#include "mobilitytestmtmapi.h"
+// at the moment we do not need more than 2 sessions
+const TInt KImapSessionArrayGranularity = 2;
+const TUid KUidImapServerMtm = {0x10003C4E};
+CImapProtocolController::CImapProtocolController(CMsvServerEntry& aEntry,CImapOfflineControl& aImapOfflineControl):
+	CMsgActive(EPriorityStandard),
+	iEntry(aEntry),
+	iImapSessionArray(KImapSessionArrayGranularity),
+	iImapOfflineControl(aImapOfflineControl)
+	{
+	}
+CImapProtocolController::~CImapProtocolController()
+	{
+	Cancel();
+	// The mail store needs to be deleted before DisconnectAll() as its destructor
+	// uses the session that DisconnectAll() destroys.
+	delete iImapMailStore;
+	//serviceid indicates that we are online
+	if(iServiceId!=0)
+		{
+		DisconnectAll();
+		}
+	delete iBackgroundSyncOp;
+	delete iImapCompound;
+	delete iMigrateCompound;
+	delete iImapSyncManager;
+	delete iImapIdleController;
+	delete iImapSettings;
+	delete iMobilityManager;
+	// Need to destroy the sessions before the session manager is deleted.
+	// This is because session manager will cleanup transport handler code,
+	// and it is important to ensure that the sockets are not being used
+	// by the session when that happens.
+	iImapSessionArray.ResetAndDestroy();
+	delete iImapSessionManager;
+	}
+EXPORT_C CImapProtocolController* CImapProtocolController::NewL(CMsvServerEntry& aEntry,CImapOfflineControl& aImapOfflineControl)
+	{
+	CImapProtocolController* self = new (ELeave) CImapProtocolController(aEntry,aImapOfflineControl);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+/**
+Part of two phase construction
+Note that syncmanager is not constructed until a connection is made.
+*/
+void CImapProtocolController::ConstructL()
+	{
+	iImapSettings       = CImapSettings::NewL(iEntry);
+	iImapMailStore 		= CImapMailStore::NewL(iEntry);
+	iImapSessionManager = CImapSessionManager::NewL(*iImapSettings, *iImapMailStore);
+	iFlushPrimary = EFalse;
+	// We're an active object...
+	CActiveScheduler::Add(this);
+	}
+/**
+Query connection status - return true if at least one IMAP Session exists and is
+connected. Also return true if migrating.
+This is not a compound operation.
+@return
+*/
+EXPORT_C TBool CImapProtocolController::Connected() const
+	{
+	if (iImapSessionArray.Count() > 0 || iMigrateState != ENotMigrating)
+		{
+		// Sessions are deleted if a disconnect is observed,
+		// therefore the existance of any sessions indicates
+		// that the Protocol Controller is connected.
+		return ETrue;
+		}
+	return EFalse;
+	}
+/**
+If a connected session already exists, this API shall complete immediately with
+KErrServerBusy. Otherwise, this API uses the IMAP Session Manager to create and connect
+an IMAP Session object that can be used for subsequent commands.
+On successful connection, the passed request status is completed. This API can not
+be used to instantiate further IMAP Session objects.
+Sequence For Connect
+	CreateSession
+	SelectInboxRW
+	Finished
+@param aStatus
+@param aSelection
+@leave KErrServerBusy if a connected session already exists
+*/
+EXPORT_C void CImapProtocolController::ConnectL( TRequestStatus& aStatus,
+												 CMsvEntrySelection& aSelection )
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::ConnectL()");
+	ResetProgress();
+	if (Connected())
+		{
+		// Do not call Complete() - this would result in the Protocol
+		// Controller disconnecting all sessions.
+		TRequestStatus* pStatus = &aStatus;
+		User::RequestComplete(pStatus, KErrServerBusy);
+		}
+	else
+		{
+		// Load the Service Settings
+		iServiceId = aSelection[0];
+		iImapSettings->LoadSettingsL(iServiceId);
+		// We're going online - create a session manager if none exists
+		if (iImapSessionManager==NULL)
+			{
+			// session manage may have been deleted due to a mobility error
+			iImapSessionManager = CImapSessionManager::NewL(*iImapSettings, *iImapMailStore);
+			}
+		// create a sync manager
+		delete iImapSyncManager;
+		iImapSyncManager = NULL;
+		iImapSyncManager = CImapSyncManager::NewL( iEntry, *iImapSettings);
+		// create the mobility manager if mobility supported
+		delete iMobilityManager;
+		iMobilityManager = NULL;
+		if (iImapSettings->BearerMobility())
+			{
+			iMobilityManager = CImMobilityManager::NewL(KUidImapServerMtm, iServiceId, *this);
+			}
+		// Create the primary session pointer
+		CImapSession* imapSession = NULL;
+		iImapSessionArray.AppendL(imapSession);
+		// Request the session manager to connect the session
+		iImapSessionManager->GetSessionL(iStatus, iImapSessionArray[0]);
+		iForegroundSession = 0;
+		iRequestedOp = EConnect;
+		iCurrentOp = iRequestedOp;
+		Queue(aStatus);
+		SetActive();
+		}
+	}
+/**
+This method allows the client to connect to an IMAP account and initialise a
+background synchronisation of the account once connection has completed. If a
+connected IMAP Session already exists, the API shall complete immdediately with
+KErrServerBusy.
+On successful connection, a background synchronisation is started and the passed
+request status is completed. The background synchronisation is processed by a
+CImapBackgroundSyncOp object, which will notify the Protocol Controller that
+the process has completed via a callback function void
+BackgroundSyncCompleted( TInt aError )
+Sequence For ConnectAndSynchronise
+	CreateSession
+	StartBackgroundSyncOp
+	Finished
+@param aStatus
+@param aSelection
+@leave KErrServerBusy if a connected session already exists
+*/
+EXPORT_C void CImapProtocolController::ConnectAndSynchroniseL( TRequestStatus& aStatus,
+															   CMsvEntrySelection& aSelection )
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::ConnectAndSynchroniseL()");
+	// Issue the connect request (this will cause ResetProgress() to be called)
+	ConnectL(aStatus, aSelection);
+	// Create the Background Sync Operation object
+	if (IsActive())
+		{
+		__ASSERT_DEBUG(iBackgroundSyncOp==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::EConnectAndSyncBgSyncOpIsNotNull));
+		iBackgroundSyncOp = CImapOpBackgroundSync::NewL(*this, iEntry, *iImapSyncManager, *iImapSettings, *iImapMailStore, iImapOfflineControl);
+		}
+	}
+/**
+Logs out and disconnects all connected sessions with the remote server.
+Disconnect request is handled and acted upon during migration, unlike other
+client-requested operations which are rejected (with KErrServerBusy).
+The Bearer Mobility Manager is deleted prior to acting on this request,
+effectively de-registering the server MTM from the mobility framework
+@param aStatus
+*/
+EXPORT_C void CImapProtocolController::DisconnectL(TRequestStatus& aStatus)
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::DisconnectL()");
+	__ASSERT_DEBUG(iImapCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::EDisconnectCompoundIsNotNull));
+	// de-register for mobility notifications
+	delete iMobilityManager;
+	iMobilityManager = NULL;
+	// Disconnect allowed to happen even if we are migrating...
+	switch (iMigrateState)
+		{
+		case ENotMigrating:
+		case EHandlingConnectError:
+			{
+			// normal behaviour...
+			DoDisconnectL(aStatus);
+			break;
+			}
+		case EConnectingAfterMigrate: // Cancel connecting of new session
+		case EStartingReconnect:	  // already disconnected. Cancel dummy request
+		case EWaitingForNewCarrier:   // already disconnected. Cancel dummy request
+		case EWaitingInitialCarrierRejected: // already disconnected. Cancel dummy request
+			{
+			Cancel();
+			// mark offline and complete
+			DisconnectAll();
+			Queue(aStatus);
+			Complete(KErrNone);
+			break;
+			}
+		case EDisconnectingForMigrate:
+			{
+			// already doing a graceful disconnect, switch to main state machine.
+			iMigrateState = ENotMigrating;
+			iRequestedOp  = EDisconnect;
+			iCurrentOp    = EDisconnect;
+			// however, using the iMigrateCompound pointer...
+			iImapCompound = iMigrateCompound;
+			iMigrateCompound = NULL;
+			Queue(aStatus);
+			break;
+			}
+		case EWaitingForOpToComplete:
+		case EWaitingForOpToStop:
+		default:
+			{
+			__ASSERT_DEBUG(iBackgroundSyncOp==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::EDisconnectUnexpectedMigrateState));
+			break;
+			}
+		}
+	}
+void CImapProtocolController::DoDisconnectL(TRequestStatus& aStatus)
+	{
+	// Unlike the other async methods, DisconnectL() will wait for any flush operation to finish
+	// and then initiate the disconnect.
+	// Consequently there is no need to call CompleteIfBackgroundOpInProgress()
+	ResetProgress();
+	iImapCompound = CImapCompoundDisconnect::NewL( *iImapSyncManager,
+												   iEntry,
+												   *iImapSettings,
+												   *iImapSessionManager,
+												   *iImapMailStore,
+												   iImapSessionArray,
+												   iImapOfflineControl,
+												   ETrue );
+	iRequestedOp = EDisconnect;
+	if (iCurrentOp != ECancelRecoverPrimary)
+		{
+		// Cancel any outstanding background sync
+		if (iBackgroundSyncOp!=NULL)
+			{
+			iBackgroundSyncOp->Cancel();
+			delete iBackgroundSyncOp;
+			iBackgroundSyncOp=NULL;
+			// Flush the session, now that it has been cancelled
+			iCurrentOp = ECancelRecoverPrimary;
+			CImapSession* session = iImapSessionArray[0];
+			session->FlushCancelledCommand(iStatus);
+			SetActive();
+			}
+		else
+			{
+			StartPrimaryOperation();
+			SetActive();
+			}
+		}
+	// NOTE: In the case of iCurrentOp == ECancelRecoverPrimary, DoRunL() will start the async
+	// iImapCompound operation after the flush has completed.
+	// The iImapCompound will expect aStatus to have been queued so that it can be Completed later.
+	Queue(aStatus);
+	}
+/**
+Checks the status of the CImapSessions
+@return ETrue if a backgroundsync is in progress and the second session is busy,
+		EFalse otherwise.
+*/
+EXPORT_C TBool CImapProtocolController::Busy() const
+	{
+	// second session is busy if a compound operation exists.
+	if (BackgroundSyncInProgress() && iImapCompound!=NULL)
+		{
+		return ETrue;
+		}
+	return EFalse;
+	}
+/**
+Gets the access point ID in use for the connection to the server
+@param aIap On return stores the access point ID value
+@return KErrNone if successful, or a system wide error code
+*/
+EXPORT_C TInt CImapProtocolController::GetAccessPointIdForConnection(TUint32& aAccessPointId) const
+	{
+	if (iImapSessionManager)
+		{
+		return iImapSessionManager->GetAccessPointIdForConnection(aAccessPointId);
+		}
+	return KErrNotFound;
+	}
+/**
+Returns whether a Background synchronisation is in progress
+@return ETrue if a Background synchronisation is in progress, EFalse otherwise
+*/
+EXPORT_C TBool CImapProtocolController::BackgroundSyncInProgress() const
+	{
+	return (iBackgroundSyncOp != NULL);
+	}
+/**
+Cancels an outstanding background synchronise operation. Calls
+CImapOpBackgroundSync::Cancel() to propagate the cancel and kicks off
+an asynchronous cleanup operation.
+The cancel request is completed immediately with KErrNone if no background
+sync was in operation, otherwise it is completed with KErrCancel when
+the cleanup process is complete.
+*/
+EXPORT_C void CImapProtocolController::CancelBackgroundSync(TRequestStatus& aStatus)
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::CancelBackgroundSync()");
+	ResetProgress();
+	Queue(aStatus);
+	if (BackgroundSyncInProgress())
+		{
+		if (iMigrateState != ENotMigrating && iBackgroundSyncOp->IsSuspendedForMigrate())
+			{
+			delete iBackgroundSyncOp;
+			iBackgroundSyncOp = NULL;
+			Complete(KErrCancel);
+			}
+		else
+			{
+			iBackgroundSyncOp->CancelAndCleanup();
+			iWaitForBackgroundSync = ETrue;
+			}
+		}
+	else
+		{
+		Complete(KErrNone);
+		}
+	}
+/**
+Wait for background sync operation to complete. This effectively makes a background
+synchronise a foreground operation blocking subsequent Server MTM requests until the
+synchonise is completed.
+@param aStatus
+*/
+EXPORT_C void CImapProtocolController::WaitForBackground(TRequestStatus& aStatus)
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::WaitForBackground()");
+	ResetProgress();
+	Queue(aStatus);
+	// Wait for background operation to complete: is one running?
+	if (!BackgroundSyncInProgress())
+		{
+		// No, complete immediately
+		Complete(KErrNone);
+		}
+	else
+		{
+		// Otherwise, wait for completion
+		iWaitForBackgroundSync = ETrue;
+		}
+	}
+/**
+Completes the passed request status if a background operation is in progress,
+or if the primary session is being recovered following a cancel operation.
+This should be called prior to starting a compound operation that requires the
+primary session to be performed.
+This method must be called before assigning iRequestedOp,
+for any operation that requires the primary session.
+@return ETrue if the user request has been completed
+		EFalse otherwise.
+*/
+TBool CImapProtocolController::CompleteIfBackgroundOpInProgress(TRequestStatus& aStatus)
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::CompleteIfBackgroundOpInProgress()");
+	if (BackgroundSyncInProgress() || iCurrentOp==ECancelRecoverPrimary || iMigrateState!=ENotMigrating)
+		{
+		// Complete the user request
+		// Do not call Complete() - this would result in the Protocol
+		// Controller disconnecting all sessions.
+		TRequestStatus* status = &aStatus;
+		User::RequestComplete(status, KErrServerBusy);
+		return ETrue;
+		}
+	return EFalse;
+	}
+/**
+Synchronise Folder Tree - calls CImapSyncManager::SynchroniseTreeL()
+Sequence For SynchroniseTree
+	StopIdle
+	SynchroniseTree // CImapSyncManager Operation
+@param aStatus
+@leave
+*/
+EXPORT_C void CImapProtocolController::SynchroniseTreeL(TRequestStatus& aStatus)
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::SynchroniseTreeL()");
+	__ASSERT_DEBUG(iImapCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESynchroniseTreeCompoundIsNotNull));
+	ResetProgress();
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		iImapCompound = CImapCompoundSyncTree::NewL( *iImapSyncManager,
+													 iEntry,
+													 *iImapSettings );
+		iRequestedOp = ESync;
+		StartPrimaryOperation();
+		Queue(aStatus);
+		SetActive();
+		}
+	}
+/**
+Perform a full account synchronisation - calls CImapSyncManager::SynchroniseL()
+Sequence For SynchroniseAll
+	StopIdle
+	SynchroniseL  // CImapSyncManager Operation
+@param aStatus
+@leave
+*/
+EXPORT_C void CImapProtocolController::SynchroniseAllL( TRequestStatus& aStatus )
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::SynchroniseAllL()");
+	__ASSERT_DEBUG(iImapCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESynchroniseAllCompoundIsNotNull));
+	ResetProgress();
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		iImapCompound = CImapCompoundSyncService::NewL( *iImapSyncManager,
+												    	iEntry,
+												    	*iImapSettings,
+												    	*iImapMailStore,
+												    	iImapOfflineControl,
+												    	EFalse);
+		iRequestedOp = ESync;
+		StartPrimaryOperation();
+		Queue(aStatus);
+		SetActive();
+		}
+	}
+/**
+Callback function to notify Protocol Controller that a background sync
+operation has completed.
+Deletes the CImapOpBackgroundComplete object that has just completed.
+If WaitForBackground has been previously called, completes the user request.
+@param aError
+*/
+EXPORT_C void CImapProtocolController::BackgroundSyncComplete(TInt aError)
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::BackgroundSyncComplete()");
+	__ASSERT_DEBUG(iBackgroundSyncOp!=NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ENoBackgroundSyncInProgress));
+	// get final sync progress...
+	// unless a foreground operation is being performed
+	if (iImapCompound == NULL)
+		{
+		iBackgroundSyncOp->Progress(iProgress);
+		}
+	if (iMigrateState != ENotMigrating)
+		{
+		// If the protocol controller is not active, then there is no
+		// operation currently in progress. Therefore we are now ready to
+		// migrate. Complete the request here, and then Disconnect current sockets in DoMigrateRunL().
+		// We cannot just test existance of a compound operation object, as there may be a "paused" operation.
+		if (!IsActive())
+			{
+			// Complete the request so that, we migrate from DoMigrateRunL()
+			SetActive();
+			TRequestStatus* pStatus = &iStatus;
+			User::RequestComplete(pStatus, KErrNone);
+			}
+		// the background sync may have been completed early to allow
+		// a migration to occur. If that is the case, then we do not want
+		// to delete the background sync operation object - it will need
+		// to be restarted once the migrate has occurred. Otherwise, just
+		// process the completion of the background sync normally.
+		if (iBackgroundSyncOp->IsSuspendedForMigrate())
+			{
+			return;
+			}
+		}
+	// Deleting the background sync op.
+	// CImapOpBackgroundComplete must finish immediately after calling this API
+	delete iBackgroundSyncOp;
+	iBackgroundSyncOp = NULL;
+	if (aError>0)
+		{
+		// translate positive error codes, weed out non-fatal errors
+		ThranslateSessionError(aError);
+		}
+	TBool foregroundOpCancelled = EFalse;
+	if (aError==KErrNone || aError==KErrCancel)
+		{
+		if (iImapCompound==NULL && iMigrateState == ENotMigrating)
+			{
+			// only start IDLE if foreground operation not in progress
+			StartIdle();
+			MOBILITY_TEST_MTM_STATE(iServiceId, KMobilityTestMtmStateImapIdle);
+			}
+		}
+	else
+		{
+		// Cancel any foreground operation - the primary session has
+		// failed, so all sessions are to be torn down.
+		if (iImapCompound != NULL)
+			{
+			iImapCompound->Cancel();
+			foregroundOpCancelled = ETrue;
+			delete iImapCompound;
+			iImapCompound=NULL;
+			}
+		// DisconnectAll will be process by DoComplete if a client request is outstanding.
+		if (!iWaitForBackgroundSync && !foregroundOpCancelled)
+			{
+			// Drop all session connections and mark the service offline.
+			DisconnectAll();
+			}
+		}
+	// Store the error in the progress object
+	iProgress.iGenericProgress.iErrorCode=aError;
+	iProgress.iGenericProgress.iState=TImap4GenericProgress::EIdle;
+	// Complete the client request if it was waiting for notification of
+	// bg sync complete, or if we have cancelled an foreground operation
+	if (iWaitForBackgroundSync || foregroundOpCancelled)
+		{
+		iCancelInProgress = ETrue;
+		Complete(aError);
+		iCancelInProgress = EFalse;
+		}
+	iWaitForBackgroundSync = EFalse;
+	}
+/**
+CopyToLocalL() is used to fetch a selection of messages from the remote
+server as a single operation, without return to idle state between handling each
+message. The email is fetched to the local mirror of the containing folder. Optionally
+this function can also copy the message to a local folder, specified in aDestination.
+A fetch to mirror only is performed by calling with aDestination set to
+KMsvNullIndexEntryId
+Sequence For CopyToLocal
+	StopIdle
+	SelectSourceMailboxRO
+	FetchMessage(s)
+	InboxDuplicateCopy
+@param aStatus
+@param aSourceSel
+@param aDestination
+*/
+EXPORT_C void CImapProtocolController::CopyToLocalL(TRequestStatus& aStatus,
+													const CMsvEntrySelection& aSourceSel,
+													const TMsvId aDestination)
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::CopyToLocalL()");
+	__ASSERT_DEBUG(iImapCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ECopyToLocalCompoundIsNotNull));
+	ResetProgress();
+	// Instead of calling CompleteIfBackgroundOpInProgress(), just check whether a flush is occurring
+	// on the primary session (always index 0).
+	// If a background op is in progress, then the copy will be performed on a secondary session.
+	if (iCurrentOp == ECancelRecoverPrimary || iMigrateState != ENotMigrating)
+		{
+		// Do not call Complete() - this would result in the Protocol
+		// Controller disconnecting all sessions.
+		TRequestStatus* pStatus = &aStatus;
+		User::RequestComplete(pStatus, KErrServerBusy);
+		return;
+		}
+	// must be set before calling SelectSession
+	iRequestedOp = ECopyToLocal;
+	// request the session to use.
+	TBool startNow = SelectSessionL(iForegroundSession);
+	if (iBackgroundSyncOp && iImapSettings->UseSyncDownloadRules())
+		{
+		// we need a non-const copy of the message selection to operate on.
+		CMsvEntrySelection* selection = aSourceSel.CopyLC();
+		// show the list to the background sync controller
+		iBackgroundSyncOp->RemoveFromSelectionL(*selection);
+		// Create the copy to local operation object using the (possibly) updated selection
+		iImapCompound = CImapCompoundCopyToLocal::NewL(*iImapSyncManager,
+		                    			               iEntry,
+		                                			   *iImapSettings,
+		                                			   *iImapMailStore,
+		                                               EFalse,
+		                                               *selection,
+		                                               aDestination);
+		CleanupStack::PopAndDestroy(selection);
+		}
+	else
+		{
+		// Create the compound operation object
+		iImapCompound = CImapCompoundCopyToLocal::NewL(*iImapSyncManager,
+		                    			               iEntry,
+		                                			   *iImapSettings,
+		                                			   *iImapMailStore,
+		                                               EFalse,
+		                                               aSourceSel,
+		                                               aDestination);
+		}
+	if (startNow)
+		{
+		// A session is ready - start the command
+		// otherwise a request to connect a secondary session has been issued
+		if (iForegroundSession==0)
+			{
+			// Primary session
+			StartPrimaryOperation();
+			}
+		else
+			{
+			// Secondary session
+			iCurrentOp = iRequestedOp;
+			iImapCompound->StartOperation(iStatus, *iImapSessionArray[iForegroundSession]);
+			}
+		}
+	Queue(aStatus);
+	SetActive();
+	}
+/**
+PopulateL() performs the same action as CopyToLocalL(), however uses the passed
+TImImap4GetPartialMailInfo object instead of using the default parameters. This
+allows the client application to specify the parts of the message that are to be
+fetched, and to impose limits to on the amount of data that can be transferred.
+Sequence For Populate
+	StopIdle
+	SelectSourceMailboxRO
+	FetchMessage(s)
+	InboxDuplicateCopy
+@param aStatus
+@param aSourceSel
+@param aGetPartialMailInfo
+*/
+EXPORT_C void CImapProtocolController::PopulateL(TRequestStatus& aStatus,
+const CMsvEntrySelection& aSourceSel,
+TImImap4GetPartialMailInfo aGetPartialMailInfo)
+	{
+	__LOG_FORMAT((KDefaultLog, "CImapProtocolController::PopulateL() - START - iCurrentOp: %d, iRequestedOp: %d", iCurrentOp, iRequestedOp ));
+	__ASSERT_DEBUG(iImapCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::EPopulateCompoundIsNotNull));
+	// Instead of calling CompleteIfBackgroundOpInProgress(), just check whether a flush is occurring
+	// on the primary session (always index 0).
+	// If a background op is in prgoress, then the copy will be performed on a secondary session.
+	ResetProgress();
+	// If a flush is occurring on the primary session (always index 0) then we are busy
+	if (iCurrentOp == ECancelRecoverPrimary || iMigrateState != ENotMigrating)
+		{
+		// Do not call Complete() - this would result in the Protocol
+		// Controller disconnecting all sessions.
+		TRequestStatus* pStatus = &aStatus;
+		User::RequestComplete(pStatus, KErrServerBusy);
+	    __LOG_TEXT(KDefaultLog, "CImapProtocolController::PopulateL() - END - KErrServerBusy...");
+		return;
+		}
+	// must be set before calling SelectSessionL()
+	iRequestedOp = EPopulate;
+	// request the session to use.
+	TBool startNow = SelectSessionL(iForegroundSession);
+	__LOG_FORMAT((KDefaultLog, "CImapProtocolController::PopulateL() - iCurrentOp: %d, iRequestedOp: %d, startNow: %d", iCurrentOp, iRequestedOp, startNow ));
+	if (iBackgroundSyncOp && iImapSettings->UseSyncDownloadRules())
+		{
+		// we need a non-const copy of the message selection to operate on.
+		CMsvEntrySelection* selection = aSourceSel.CopyLC();
+		// show the list to the background sync controller
+		iBackgroundSyncOp->RemoveFromSelectionL(*selection);
+		// Create the copy to local operation object using the (possibly) updated selection
+		iImapCompound = CImapCompoundCopyToLocal::NewL(*iImapSyncManager,
+			                			               iEntry,
+		    	                        			   *iImapSettings,
+		        	                    			   *iImapMailStore,
+		            	                               EFalse,
+		                	                           *selection,
+		                    	                       KMsvNullIndexEntryId,
+		                        	                   aGetPartialMailInfo);
+		CleanupStack::PopAndDestroy(selection);
+		}
+	else
+		{
+		// Create the compound operation object
+		iImapCompound = CImapCompoundCopyToLocal::NewL(*iImapSyncManager,
+	    	                			               iEntry,
+	        	                        			   *iImapSettings,
+	            	                    			   *iImapMailStore,
+	                	                               EFalse,
+	                    	                           aSourceSel,
+	                        	                       KMsvNullIndexEntryId,
+	                            	                   aGetPartialMailInfo);
+		}
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::PopulateL() - done creation of CompoundCopyToLocal...");
+	if (startNow)
+		{
+		// A session is ready - start the command
+		// otherwise a request to connect a secondary session has been issued
+		if (iForegroundSession==0)
+			{
+			// Primary session
+	        __LOG_TEXT(KDefaultLog, "CImapProtocolController::PopulateL() - starting primary op...");
+			StartPrimaryOperation();
+			}
+		else
+			{
+			// Secondary session
+	        __LOG_TEXT(KDefaultLog, "CImapProtocolController::PopulateL() - starting compound op...");
+			iCurrentOp = iRequestedOp;
+			iImapCompound->StartOperation(iStatus, *iImapSessionArray[iForegroundSession]);
+			}
+		}
+	Queue(aStatus);
+	SetActive();
+	__LOG_FORMAT((KDefaultLog, "CImapProtocolController::PopulateL() - END - iCurrentOp: %d, iRequestedOp: %d, startNow: %d", iCurrentOp, iRequestedOp, startNow ));
+	}
+/**
+MoveToCopyL() shall enable a selection of messages to be moved as a single operation,
+without return to idle state between handling each message. If a message has not been
+previously fetched (ie is not complete on the local mirror of the IMAP folder) the
+message is fetched to the local mirror and a copy is then made in the local service
+folder. The message is then deleted from the IMAP folder on the remote server and the
+local mirror.
+Sequence For MoveToLocal
+	StopIdle
+	SelectSourceMailbox
+	FetchMessage
+	InboxDuplicateCopy
+	DeleteMessage
+@param aStatus
+@param aSourceSel
+@param aDestination
+*/
+EXPORT_C void CImapProtocolController::MoveToLocalL(TRequestStatus& aStatus,
+													const CMsvEntrySelection& aSourceSel,
+													const TMsvId aDestination)
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::MoveToLocalL()");
+	__ASSERT_DEBUG(iImapCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::EMoveToLocalCompoundIsNotNull));
+	ResetProgress();
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		// We can't do a 'movetolocal' with the destination being the same as the
+		// source, as then the mirror will be out of sync. We must be moving to somewhere
+		// outside this service. Check this.
+		if (!IdIsLocalL(aDestination))
+			{
+			// Complete the user request
+			// Do not call Complete() - this would result in the Protocol
+			// Controller disconnecting all sessions.
+			TRequestStatus* status = &aStatus;
+			User::RequestComplete(status, KErrNotSupported);
+			}
+		else
+			{
+			iImapCompound = CImapCompoundCopyToLocal::NewL(*iImapSyncManager,
+														   iEntry,
+														   *iImapSettings,
+														   *iImapMailStore,
+														   ETrue,
+		                                               	   aSourceSel,
+		                                               	   aDestination);
+			iRequestedOp = EMoveToLocal;
+			StartPrimaryOperation();
+			Queue(aStatus);
+			SetActive();
+			}
+		}
+	}
+/**
+Copy within service is the operation of moving a message or selection of messages from
+one mailbox  to another on the remote IMAP server. This is done by issuing a COPY IMAP
+command to the remote server, followed by a sync operation on the destination folder.
+Sequence For CopyWithinService
+	StopIdle
+	SelectSourceMailboxRO
+	CopyMessage
+	SelectDestinationMailboxRO
+	NewSyncFolder
+@param aStatus
+@param aSourceSel
+@param aDestination
+*/
+EXPORT_C void CImapProtocolController::CopyWithinServiceL( TRequestStatus& aStatus,
+							 					  		   const CMsvEntrySelection& aSourceSel,
+							 					  		   const TMsvId aDestination )
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::CopyWithinServiceL()");
+	__ASSERT_DEBUG(iImapCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ECopyWithinServiceCompoundIsNotNull));
+	ResetProgress();
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		iImapCompound = CImapCompoundCopyWithinService::NewL( *iImapSyncManager,
+															  iEntry,
+															  *iImapSettings,
+															  EFalse,
+															  aSourceSel,
+															  aDestination);
+		iRequestedOp = ECopyWithinService;
+		StartPrimaryOperation();
+		Queue(aStatus);
+		SetActive();
+		}
+	}
+/**
+Move within service is the same as Copy Within Service, however the message is deleted
+from the original location following the copy operation.
+Sequence For MoveWithinService
+	StopIdle
+	SelectSourceMailboxRW
+	CopyMessage
+	DeleteMessage
+	SelectDestinationMailboxRO
+	NewSyncFolder
+@param aStatus
+@param aSourceSel
+@param aDestination
+*/
+EXPORT_C void CImapProtocolController::MoveWithinServiceL( TRequestStatus& aStatus,
+							 					  		   const CMsvEntrySelection& aSourceSel,
+							 					  		   const TMsvId aDestination )
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::MoveWithinServiceL()");
+	__ASSERT_DEBUG(iImapCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::EMoveWithinServiceCompoundIsNotNull));
+	ResetProgress();
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		iImapCompound = CImapCompoundCopyWithinService::NewL( *iImapSyncManager,
+															  iEntry,
+															  *iImapSettings,
+															  ETrue,
+															  aSourceSel,
+															  aDestination );
+		iRequestedOp = EMoveWithinService;
+		StartPrimaryOperation();
+		Queue(aStatus);
+		SetActive();
+		}
+	}
+/**
+Copy from local is the action of copying an email from a local service folder (for
+example the local inbox) to a folder on the remote IMAP service. This is done using
+the IMAP APPEND command.
+Sequence For CopyFromLocal
+	AppendMessage
+	SelectDestinationMailboxRO
+	NewSyncFolder
+@param aStatus
+@param aSourceSel
+@param aDestination
+*/
+EXPORT_C void CImapProtocolController::CopyFromLocalL( TRequestStatus& aStatus,
+						 					  		   const CMsvEntrySelection& aSourceSel,
+						 					  		   const TMsvId aDestination )
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::CopyFromLocalL()");
+	__ASSERT_DEBUG(iImapCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ECopyFromLocalCompoundIsNotNull));
+	ResetProgress();
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		iImapCompound = CImapCompoundCopyFromLocal::NewL( *iImapSyncManager,
+														  iEntry,
+														  *iImapSettings,
+														  EFalse,
+														  aSourceSel,
+														  aDestination );
+		iRequestedOp = ECopyFromLocal;
+		StartPrimaryOperation();
+		Queue(aStatus);
+		SetActive();
+		}
+	}
+/**
+Move from local is the action of moving an email from a local service folder (for
+example the local inbox) to a folder on the remote IMAP service. It is performed
+by following the same steps as for a Copy From Local operation, using the IMAP APPEND
+command, however the local copy of the message is deleted after the APPEND has
+successfully completed.
+Sequence For MoveFromLocal
+	StopIdle
+	AppendMessage
+	DeleteLocalMessage
+	SelectDestinationMailboxRO
+	NewSyncFolder
+@param aStatus
+@param aSourceSel
+@param aDestination
+*/
+EXPORT_C void CImapProtocolController::MoveFromLocalL( TRequestStatus& aStatus,
+						 					  		   const CMsvEntrySelection& aSourceSel,
+						 					  		   const TMsvId aDestination )
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::MoveFromLocalL()");
+	__ASSERT_DEBUG(iImapCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ECopyFromLocalCompoundIsNotNull));
+	ResetProgress();
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		iImapCompound = CImapCompoundCopyFromLocal::NewL( *iImapSyncManager,
+														  iEntry,
+														  *iImapSettings,
+														  ETrue,
+														  aSourceSel,
+														  aDestination );
+		iRequestedOp = EMoveFromLocal;
+		StartPrimaryOperation();
+		Queue(aStatus);
+		SetActive();
+		}
+	}
+/**
+Deletes the specified messages from the remote server.
+Sequence For Delete
+	StopIdle
+	SelectSourceMailboxRW
+	Store /delete flags for each message
+	Expunge remote messages
+	Delete local messages
+@param aStatus
+@param aSourceSel
+*/
+EXPORT_C void CImapProtocolController::DeleteL(TRequestStatus& aStatus,
+									   		   const CMsvEntrySelection& aSourceSel)
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::DeleteL()");
+	__ASSERT_DEBUG(iImapCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::EDeleteCompoundIsNotNull));
+	ResetProgress();
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		// Create the compound object for message delete
+		iImapCompound = CImapCompoundDelete::NewL(*iImapSyncManager,
+												  iEntry,
+												  *iImapSettings,
+												  aSourceSel);
+		iRequestedOp = EDelete;
+		StartPrimaryOperation();
+		Queue(aStatus);
+		SetActive();
+		}
+	}
+/**
+Deletes the specified folder(s) on the remote IMAP Server.
+Sequence For DeleteFolder
+	StopIdle
+	SelectSourceMailboxRW
+	DeleteAllMessages
+	CloseFolder
+	DeleteLocalFolder
+@param aStatus
+@param aSelection
+*/
+EXPORT_C void CImapProtocolController::DeleteFolderL( TRequestStatus& aStatus,
+											 		  const CMsvEntrySelection& aSelection )
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::DeleteFolderL()");
+	__ASSERT_DEBUG(iImapCompound == NULL, TImapServerPanic::ImapPanic(TImapServerPanic::EDeleteFolderCompoundIsNotNull));
+	ResetProgress();
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		iImapCompound = CImapCompoundDeleteFolder::NewL( *iImapSyncManager,
+													     iEntry,
+													     *iImapSettings,
+													     aSelection );
+		iRequestedOp = EDelete;
+		StartPrimaryOperation();
+		Queue(aStatus);
+		SetActive();
+		}
+	}
+/**
+NewOnlySyncL() is used to synchronise recent messages in the specified folder,
+i.e. any messages that have arrived in the remote IMAP mailbox since the last
+synchronisation. This is done by requesting (FETCHing) the header details for
+messages with UID's that are greater than the highest UID of the messages present
+in the local mirror of the folder. The message's header summary information,
+flags etc are stored as new entries in the Message Server entry array under the
+folder entry, and the header information is streamed to the Mailstore using the
+Mailstore API.
+Sequence For NewSyncFolder
+	StopIdle
+	SelectSourceMailboxRW
+	NewSyncFolder
+@param aStatus
+*/
+EXPORT_C void CImapProtocolController::NewOnlySyncFolderL( TRequestStatus& aStatus )
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::NewOnlySyncFolderL()");
+	__ASSERT_DEBUG(iImapCompound == NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ENewOnlySyncFolderCompoundIsNotNull));
+	ResetProgress();
+	if (iMigrateState!=ENotMigrating)
+		{
+		// Complete the user request if migrating.
+		// Do not call Complete() - this would result in the Protocol
+		// Controller disconnecting all sessions.
+		TRequestStatus* status = &aStatus;
+		User::RequestComplete(status, KErrServerBusy);
+		return;
+		}
+	// If we support idle, and the server we are talking to supports idle,
+	// then we don't need to do the new only sync as IMAP idle will take
+	// care of it for us.
+	// Just complete the user request with KErrNone.
+	if (iImapSettings->ImapIdle() && iImapSessionArray[0]->ImapIdleSupported())
+		{
+		__LOG_TEXT(KDefaultLog, "CImapProtocolController::NewOnlySyncFolderL() - Immediate complete as idle is in use");
+		Queue(aStatus);
+		Complete(KErrNone);
+		return;
+		}
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		CImapFolder* folder = iImapSyncManager->Inbox();
+		TMsvId inboxId = folder->MailboxId();
+		iImapCompound = CImapCompoundSyncFolder::NewL( *iImapSyncManager,
+													   iEntry,
+													   *iImapSettings,
+													   *iImapMailStore,
+													   ETrue,
+													   inboxId);
+		iRequestedOp = ESync;
+		StartPrimaryOperation();
+		Queue(aStatus);
+		SetActive();
+		}
+	}
+/**
+The full synchronisation of a folder involves the synchronisation of messages newly
+received at the IMAP server, as described for NewOnlySyncL, above, and the
+synchronisation of "old messages", ie messages that have previously been synchronised
+to the local mirror of the folder.
+When synchronising old messages, messages that have been marked for delete locally
+are marked such on the remote folder (the actual delete occurs either at the end of
+the synchronisation process, or is deferred until the connection is cancelled),
+messages that have been removed from the remote server (by another client) are
+deleted locally and any outstanding offline operations are performed, for example
+move operations may be outstanding, etc.
+Sequence For FullSyncFolder
+	StopIdle
+	SelectSourceMailboxRW
+	SyncFolder
+@param aStatus
+@param aFolder
+*/
+EXPORT_C void CImapProtocolController::FullSyncFolderL( TRequestStatus& aStatus,
+											   			const TMsvId aFolder )
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::FullSyncFolderL()");
+	__ASSERT_DEBUG(iImapCompound == NULL, TImapServerPanic::ImapPanic(TImapServerPanic::EFullSyncFolderCompoundIsNotNull));
+	ResetProgress();
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		iImapCompound = CImapCompoundSyncFolder::NewL( *iImapSyncManager,
+													   iEntry,
+													   *iImapSettings,
+													   *iImapMailStore,
+													   EFalse,
+													   aFolder );
+		iRequestedOp = ESync;
+		StartPrimaryOperation();
+		Queue(aStatus);
+		SetActive();
+		}
+	}
+/**
+SELECT is made available to the client application directly via an IMAP MTM command
+which is handled by this function. It allows the client to specifically SELECT a
+mailbox and then, using the Synchronise MTM command, to specifically request the
+selected mailbox is synchronised.
+Sequence For Select
+	StopIdle
+	SelectSourceMailboxRW
+@param aStatus
+@param aFolder
+*/
+EXPORT_C void CImapProtocolController::SelectL(TRequestStatus& aStatus, const TMsvId aFolder)
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::SelectL()");
+	__ASSERT_DEBUG(iImapCompound == NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESelectCompoundIsNotNull));
+	ResetProgress();
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		iImapCompound = CImapCompoundSelect::NewL( *iImapSyncManager,
+												   iEntry,
+												   *iImapSettings,
+												   aFolder );
+		iRequestedOp = ESelect;
+		StartPrimaryOperation();
+		Queue(aStatus);
+		SetActive();
+		}
+	}
+/**
+Performs a full sync on the currently selected mailbox.
+Sequence For FullSyncSelectedFolder
+	StopIdle
+	SyncFolder
+@param aStatus
+*/
+EXPORT_C void CImapProtocolController::FullSyncSelectedFolderL( TRequestStatus& aStatus )
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::FullSyncSelectedFolderL()");
+	__ASSERT_DEBUG( iImapCompound == NULL, TImapServerPanic::ImapPanic(TImapServerPanic::EFullSyncSelectedFolderCompoundIsNotNull));
+	ResetProgress();
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		iImapCompound = CImapCompoundSyncFolder::NewL( *iImapSyncManager,
+													   iEntry,
+													   *iImapSettings,
+													   *iImapMailStore,
+													   EFalse );
+		iRequestedOp = ESync;
+		StartPrimaryOperation();
+		Queue(aStatus);
+		SetActive();
+		}
+	}
+/**
+Creates a new folder on the remote IMAP service with the given name.
+Sequence For Create
+	StopIdle
+	Create
+@param aStatus
+@param aParent
+@param aLeafName
+@param aFolder
+*/
+EXPORT_C void CImapProtocolController::CreateL( TRequestStatus& aStatus,
+				  					   			const TMsvId aParent,
+				  					   			const TDesC& aLeafName,
+				  					   			const TBool aFolder )
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::CreateL()");
+	__ASSERT_DEBUG(iImapCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ECreateCompoundIsNotNull));
+	ResetProgress();
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		iImapCompound = CImapCompoundCreate::NewL( *iImapSyncManager,
+												   iEntry,
+												   *iImapSettings,
+												   aParent,
+												   aLeafName,
+												   aFolder );
+		iRequestedOp = ECreate;
+		StartPrimaryOperation();
+		Queue(aStatus);
+		SetActive();
+		}
+	}
+/**
+Renames the specified folder. Note that although this does cause a write to the
+remote folder, it does not change the contents of the folder and hence does not
+force a re-synchronisation of the folder.
+Sequence For Rename
+	StopIdle
+	RenameRemote
+	RenameLocal
+@param aStatus
+@param aTarget
+@param aNewName
+*/
+EXPORT_C void CImapProtocolController::RenameL( TRequestStatus& aStatus,
+				  					   			const TMsvId aTarget,
+				  					   			const TDesC& aNewName )
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::RenameL()");
+	__ASSERT_DEBUG(iImapCompound == NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ERenameCompoundIsNotNull));
+	ResetProgress();
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		iImapCompound = CImapCompoundRename::NewL( *iImapSyncManager,
+												   iEntry,
+												   *iImapSettings,
+												   aTarget,
+												   aNewName );
+		iRequestedOp = ERename;
+		StartPrimaryOperation();
+		Queue(aStatus);
+		SetActive();
+		}
+	}
+EXPORT_C void CImapProtocolController::DoRunL()
+	{
+	// Handle all migration operations in a separate state machnine.
+	if (iMigrateState != ENotMigrating)
+		{
+		DoMigrateRunL();
+		return;
+		}
+	// ProcessError completes and returns ETrue if an error occured
+	if (ProcessError(iStatus.Int()))
+		{
+		return;
+		}
+	switch (iCurrentOp)
+		{
+	case EConnect:
+		{
+		// Collect the final connect progress information
+		iImapSessionManager->Progress(iProgress.iGenericProgress);
+		// Set last socket activity timeout to iMtmData1. This is used by Imcm.
+		User::LeaveIfError( iEntry.SetEntry( iServiceId ) );
+		TMsvEntry entry=iEntry.Entry();
+		entry.SetMtmData1(iImapSessionManager->LastSocketActivityTimeout());
+		User::LeaveIfError( iEntry.ChangeEntry( entry ) );
+		TRAP_IGNORE(MarkOnOrOfflineL(ETrue));
+		// Create an IMAP IDLE controller
+		delete iImapIdleController;
+		iImapIdleController=NULL;
+		iImapIdleController = CImapIdleController::NewL(*this, iImapSessionArray[0], *iImapSyncManager, iEntry, *iImapSettings, *iImapMailStore);
+		// Register the connection with the mobility manager,
+		// if we are a mobile service
+		if (iMobilityManager)
+			{
+			iMobilityManager->SetConnection(iImapSessionManager->GetConnectionL());
+			}
+		// kick off a background sync if it was requested.
+		if (iBackgroundSyncOp != NULL)
+			{
+			iBackgroundSyncOp->StartSync(*iImapSessionArray[0]);
+			iCurrentOp = EIdle;
+			}
+		else
+			{
+			StartIdle();
+			}
+		// complete the connect request
+		Complete(iStatus.Int());
+		break;
+		}
+	case EConnectSecondary:
+		{
+		// perform the user-requested operation using the
+		// newly created imap session
+		iCurrentOp = iRequestedOp;
+		if(iImapCompound->Suspended())
+			{
+			// if the operation was previously suspended for migration, resume it...
+			iImapCompound->ResumeOperationL(iStatus, *iImapSessionArray[iForegroundSession]);
+			}
+		else
+			{
+			// otherwise, just start the operation.
+			iImapCompound->StartOperation(iStatus, *iImapSessionArray[iForegroundSession]);
+			}
+		SetActive();
+		break;
+		}
+	case EStopIdle:
+		{
+		// Idle has been cancelled, the primary session is available
+		// Kick off the requested operation
+		iCurrentOp = iRequestedOp;
+		iImapCompound->StartOperation(iStatus, *iImapSessionArray[0]);
+		SetActive();
+		break;
+		}
+	case EDisconnect:
+		{
+		TRAP_IGNORE( MarkOnOrOfflineL( EFalse ) );
+		iImapSessionArray.ResetAndDestroy();
+		// update last operation progress state
+		iImapCompound->Progress(iProgress);
+		delete iImapCompound;
+		iImapCompound = NULL;
+		iServiceId=0;
+		Complete(iStatus.Int());
+		break;
+		}
+	case ECancelRecoverPrimary:
+		{
+		// Primary session is successfully recovered
+		// Start the next requested operation
+		if (iRequestedOp == EIdle)
+			{
+			// We should only go into Idle if no async operations have been requested.
+			// Consequently, CMsgActive::iReport should be NULL.
+			// We can't ASSERT this here as it is a private member of CMsgActive, but it is worth checking while debugging.
+			StartIdle();
+			}
+		else if (iRequestedOp == EDisconnect)
+			{
+			// We should only start a primary operation if an async operation has been requested, and an aStatus Queue()ed.
+			// Consequently, CMsgActive::iReport should NOT be NULL.
+			// We can't ASSERT this here as it is a private member of CMsgActive, but it is worth checking while debugging.
+			StartPrimaryOperation();
+			SetActive();
+			}
+		else
+			{
+			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::EProtocolControllerUnexpectedRequestedOp));
+			}
+		break;
+		}
+	case ESync:
+	case ESelect:
+	case ECopyToLocal:
+	case ECopyWithinService:
+	case ECopyFromLocal:
+	case EMoveToLocal:
+	case EMoveWithinService:
+	case EMoveFromLocal:
+	case EPopulate:
+	case EDelete:
+	case EDeleteFolder:
+	case ECreate:
+	case ERename:
+	case EUpdateFlag:
+		{
+		// update last operation progress state
+		iImapCompound->Progress(iProgress);
+		delete iImapCompound;
+		iImapCompound = NULL;
+		if ((iRequestedOp==ESelect) && (iProgress.iGenericProgress.iErrorCode==KErrNone))
+			{
+			// Do not start IDLE following a select request
+			Complete(iStatus.Int());
+			}
+		else
+			{
+			// Start idle and complete the server mtm request.
+			StartIdle();
+			Complete(iStatus.Int());
+			}
+		break;
+		}
+	case EIdle:	// shouldn't happen
+	default:
+		{
+		Complete(iStatus.Int());
+		break;
+		}
+		} // end of switch (iCurrentOp)
+	}
+/**
+This variation on DoRunL() presents a super-state machine, that replaces
+the default state machine during a migration process.
+*/
+void CImapProtocolController::DoMigrateRunL()
+	{
+	// waiting for existing operation to stop to allow migration to occur.
+	__LOG_FORMAT((KDefaultLog, "CImapProtocolController::DoMigrateRunL(iMigrateState = %d) CurrentOp = %d", iMigrateState, iCurrentOp));
+	switch (iMigrateState)
+		{
+		case EWaitingForOpToStop:
+		case EWaitingForOpToComplete:
+			{
+			// operation has completed (is either finished, or has "paused"
+			// to allow migration to complete. Do any tidying up necessary.
+			ProcessOpCompleteForMigrate();
+			// is there also a background sync op in progress? if not (or if the
+			// background sync op is suspended, we are now ready to migrate,
+			// otherwise wait for the background op to complete.
+			 //
+			if (!iBackgroundSyncOp || iBackgroundSyncOp->IsSuspendedForMigrate())
+				{
+				// Asynch disconnect current sockets.
+				DisconnectForMigrateL();
+				}
+			break;
+			}
+		case EDisconnectingForMigrate:
+			{
+			// The disconnect operation has completed. Delete IMAP Sessions.
+			iImapSessionArray.ResetAndDestroy();
+			// delete the migration compound object
+			delete iMigrateCompound;
+			iMigrateCompound = NULL;
+			// Notify the mobility framework that we are ready to migrate.
+			iMigrateState = EWaitingForNewCarrier;
+			iMobilityManager->MigrateToNewCarrier();
+			// do not set waiting if NewCarrierActive has been called synchronously.
+			if (iMigrateState == EWaitingForNewCarrier)
+				{
+				// Now in a waiting state, set self active
+				iStatus = KRequestPending;
+				SetActive();
+				}
+			break;
+			}
+		case EHandlingConnectError:
+			{
+			// register with the mobility framework
+			iMobilityManager->SetConnection(iImapSessionManager->GetConnectionL());
+			// empty the session array
+			TInt numSessions = iImapSessionArray.Count();
+			for (TInt i=0; i<numSessions; ++i)
+				{
+				if (iImapSessionArray[i])
+					{
+					iImapSessionManager->Disconnect(*(iImapSessionArray[i]));
+					}
+				}
+			iImapSessionArray.ResetAndDestroy();
+			// reject the initial carrier
+			iMigrateState = EWaitingInitialCarrierRejected;
+			iMobilityManager->NewCarrierRejected();
+			if (iMigrateState == EWaitingInitialCarrierRejected)
+				{
+				iStatus = KRequestPending;
+				SetActive();
+				}
+			break;
+			}
+		case EStartingReconnect:
+			{
+			NewPrimarySessionL();
+			break;
+			}
+		case EConnectingAfterMigrate:
+			{
+			if (iStatus.Int()!=KErrNone)
+				{
+				// An error has occurred while attempting to re-connect
+				// - reject this new carrier, wait to see if a new one turns up.
+				iMigrateState = EWaitingForNewCarrier;
+				iMobilityManager->NewCarrierRejected();
+				// Now in a waiting state, set self active
+				if (iMigrateState == EWaitingForNewCarrier)
+					{
+					iStatus = KRequestPending;
+					SetActive();
+					}
+				}
+			else
+				{
+				iMobilityManager->NewCarrierAccepted();
+				RestartAfterMigrateL();
+				}
+			break;
+			}
+		case ENotMigrating:
+		case EWaitingForNewCarrier:
+		case EWaitingInitialCarrierRejected:
+			// DoRunMigrateL() Should never be called in this state.
+		default:
+			{
+			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::EProtocolControllerUnexpectedMigrateState));
+			break;
+			}
+		}
+	}
+/**
+Called when completing an outstanding client request.
+Handles negative (system-wide) error codes returned
+on completion of asynchronous service requests.
+*/
+void CImapProtocolController::DoComplete(TInt& aErr)
+	{
+	__LOG_FORMAT((KDefaultLog, "CImapProtocolController::DoComplete() - START - aErr = %d, CurrentOp = %d, iCancelInProgress: %d", aErr, iCurrentOp, iCancelInProgress));
+	// Requested operation is completed.
+	iRequestedOp = EIdle;
+	// return if everything is OK
+	if (aErr==KErrNone)
+		{
+	    __LOG_TEXT( KDefaultLog, "CImapProtocolController::DoComplete() - END - KErrNone" );
+		return;
+		}
+	// First retrieve the progress information
+	this->Progress();
+	// log that a cancel has occurred and return
+	if (aErr==KErrCancel)
+		{
+	    __LOG_TEXT( KDefaultLog, "CImapProtocolController::DoComplete() - dealing with cancel case..." );
+		iProgress.iGenericProgress.iErrorCode=aErr;
+		if(!iCancelInProgress)
+			{
+	        __LOG_TEXT( KDefaultLog, "CImapProtocolController::DoComplete() - no cancel in progress, so disconnecting all..." );
+			DisconnectAll();
+			}
+	    __LOG_TEXT( KDefaultLog, "CImapProtocolController::DoComplete() - END - KErrCancel" );
+		return;
+		}
+	// Non-fatal errors should have been handled prior to this.
+	__LOG_TEXT( KDefaultLog, "CImapProtocolController::DoComplete() - fatal error - disconnect all..." );
+	// iServiceId = 0, indicates we are already disconnected.
+	if(iServiceId!=0)
+		{
+		DisconnectAll();
+		}
+	// Save error code in progress and flag the disconnect
+	iProgress.iGenericProgress.iState=TImap4GenericProgress::EDisconnected;
+	iProgress.iGenericProgress.iErrorCode=aErr;
+__LOG_TEXT( KDefaultLog, "CImapProtocolController::DoComplete() - END - fatal error" );
+	}
+/**
+Cancels any outstanding client requested asynchronous operations and recovers
+the primary session if required.
+This function is exclusively for the use of the CImapServerMtm, and only calls
+Cancel() if the PC is currently active performing the requested operation.
+If the PC is active for other reasons (for example, waiting for a bearer
+migration to complete), the appropriate action is taken.
+*/
+EXPORT_C void CImapProtocolController::CancelAndCleanup()
+	{
+	__LOG_FORMAT( (KDefaultLog, "CImapProtocolController::CancelAndCleanup() - START - iCurrentOp: %d, iRequestedOp: %d, iFlushPrimary: %d", iCurrentOp, iRequestedOp, iFlushPrimary ) );
+	if ( iMigrateState == ENotMigrating ||
+	     iMigrateState == EWaitingForOpToComplete ||
+	     iMigrateState == EWaitingForOpToStop )
+		{
+		// In these states the protocol controller is currently doing something
+		// at the clients request.
+		// iCancelInProgress
+		iCancelInProgress = ETrue;
+		Cancel();
+	    __LOG_TEXT(KDefaultLog, "CImapProtocolController::CancelAndCleanup() - done DoCancel");
+		// DoCancel() will set iFlushPrimary to ETrue for operations that require
+		// a flush after being cancelled. This will cause DoRunL() to be called when the
+		// session has been flushed. In the case of bearer migration, the next step will
+		// be started in DoRunL.
+		if (iFlushPrimary)
+			{
+			iRequestedOp = EIdle; // We want to return to idle when the flush has completed.
+			iCurrentOp = ECancelRecoverPrimary;
+			CImapSession* session = iImapSessionArray[0];
+			session->FlushCancelledCommand(iStatus);
+			SetActive();
+			iFlushPrimary = EFalse;
+			}
+		// clear the cancelling flag
+		iCancelInProgress = EFalse;
+		}
+	else
+		{
+		// in other migration states, we don't want to cancel because we
+		// are active for migration purposes. However, we do need to clean
+		// compound operation objects and complete the user.
+		iRequestedOp = iCurrentOp = EIdle;
+		// Update the progress object
+		iProgress.iGenericProgress.iState = TImap4GenericProgress::EIdle;
+		iProgress.iGenericProgress.iErrorCode = KErrCancel;
+		delete iImapCompound;
+		iImapCompound = NULL;
+		CMsgActive::DoCancel(); // completes the user request.
+		}
+__LOG_TEXT(KDefaultLog, "CImapProtocolController::CancelAndCleanup() - END");
+	}
+/**
+DoCancel - called by CMsgActive::Cancel() to cancel asychronous services:
+Cancel() must not be called on this class to cancel a requested async
+service - CancelAndCleanup() should be used instead. CancelAndCleanup()
+provides support for cancelling requested operations while this class
+has become active for migration purposes.
+However, Cancel() must always be called eventually as the iStatus needs
+to be cleared. Hence this function must support all cancel operations.
+This class is allows for Cancel() to be called internally to cancel
+async operations that have been launched internally for migration
+purposes, without completing the CImapServerMtm.
+*/
+void CImapProtocolController::DoCancel()
+	{
+	__LOG_FORMAT( (KDefaultLog, "CImapProtocolController::DoCancel() - START - iCurrentOp: %d, iRequestedOp: %d, iFlushPrimary: %d", iCurrentOp, iRequestedOp, iFlushPrimary ) );
+	if (iMigrateState==ENotMigrating)
+		{
+		DoCancelClientOp();
+		}
+	else
+		{
+		switch (iMigrateState)
+			{
+			case ESuspendingForMigrate:
+				{
+				// Special handling for cancelling current operation to allow
+				// migration to occur.
+				DoCancelForMigrate();
+				break;
+				}
+			case EWaitingForOpToComplete:
+			case EWaitingForOpToStop:
+				{
+				// we have an outstanding request on the compound operation
+				// call the default DoCancelClientOp(). This will also
+				// complete the client's iStatus with KErrCancel
+				DoCancelClientOp();
+				break;
+				}
+			case EDisconnectingForMigrate:
+				{
+				// outstanding op is on the iMigrateCompound
+				iMigrateCompound->Cancel();
+				delete iMigrateCompound;
+				iMigrateCompound = NULL;
+				break;
+				}
+			case EConnectingAfterMigrate:
+				{
+				// This state represents re-connection of the primary session,
+				// it is safe to simply clear the imap session array.
+				iImapSessionManager->Cancel();
+				iImapSessionArray.ResetAndDestroy();
+				break;
+				}
+			case EWaitingForNewCarrier:
+			case EWaitingInitialCarrierRejected:
+				{
+				// in these states, we are in a self-induced active state
+				// Cancel it:
+				TRequestStatus* status = &iStatus;
+				User::RequestComplete(status, KErrCancel);
+				break;
+				}
+			case EStartingReconnect: // nothing to cancel
+			case EHandlingConnectError: // nothing to cancel
+			case ENotMigrating:		 // somethings gone wrong
+			default:
+				{
+				__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::EProtocolControllerCancelBadMigrateState));
+				}
+			} // switch (iMigrateState)
+		}
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::DoCancel() - END");
+	}
+void CImapProtocolController::DoCancelClientOp()
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::DoCancelClientOp() - START");
+	// Update the requested and current operations
+	// the implication is that a return to EIdle is required
+	// current op may be updated later if an async op is issued.
+	TImapProtocolOp cancelledOp = iCurrentOp;
+	iRequestedOp = iCurrentOp = EIdle;
+	switch (cancelledOp)
+		{
+		case EConnect:
+			{
+			__LOG_TEXT(KDefaultLog, "CImapProtocolController::DoCancelClientOp() - EConnect");
+			iImapSessionManager->Cancel();
+			// As this state represents connection of the primary session,
+			// it is safe to simply clear the imap session array.
+			iImapSessionArray.ResetAndDestroy();
+			// delete the background sync operation if it exists.
+			if (iBackgroundSyncOp != NULL)
+				{
+				iBackgroundSyncOp->Cancel();
+				delete iBackgroundSyncOp;
+				iBackgroundSyncOp=NULL;
+				}
+			// delete the sync manager
+			delete iImapSyncManager;
+			iImapSyncManager = NULL;
+			break;
+			}
+		case EConnectSecondary:
+			{
+	        __LOG_TEXT(KDefaultLog, "CImapProtocolController::DoCancelClientOp() - EConnectSecondary");
+			// Cancel the connect request
+			iImapSessionManager->Cancel();
+			iForegroundSession=0;
+			// Remove the session pointer from the array
+			// The session has already been deleted - see note above.
+			TInt numSessions = iImapSessionArray.Count();
+			iImapSessionArray.Remove(numSessions-1);
+			if (iImapCompound!=NULL)
+				{
+				// The requested op hasn't actually started yet
+				// so don't cancel on the compound operation..
+				// update last operation progress state
+				iImapCompound->Progress(iProgress);
+				delete iImapCompound;
+				iImapCompound = NULL;
+				}
+			// The progress will not report cancel at this stage - force it here.
+			iProgress.iGenericProgress.iState = TImap4GenericProgress::EIdle;
+			iProgress.iGenericProgress.iErrorCode = KErrCancel;
+			break;
+			}
+		case EDisconnect:
+			{
+	        __LOG_TEXT(KDefaultLog, "CImapProtocolController::DoCancelClientOp() - EDisconnect");
+			// Cancel the disconnect compound operation
+			iImapCompound->Cancel();
+			delete iImapCompound;
+			iImapCompound = NULL;
+			// A cancelled disconnect will leave the sessions disconnected
+			// but not deleted. Reset and destroy the session array.
+			iImapSessionArray.ResetAndDestroy();
+			break;
+			}
+		case EIdle:
+			{
+			// This is unexpected - in this state there should be no
+			// outstanding asynconous requests on the Protocol Controller.
+			// Protocol Controller has no outstanding requests in this state
+			// however a sync may be running in the background. This is
+			// cancelled when the background sync object's destructor is called.
+			// So.. Nothing to do.
+			break;
+			}
+		case EStopIdle:
+			{
+			if (iImapCompound!=NULL)
+				{
+				// The requested op hasn't actually started yet
+				// so don't cancel on the compound operation..
+				// update last operation progress state
+				iImapCompound->Progress(iProgress);
+				delete iImapCompound;
+				iImapCompound = NULL;
+				}
+			// The progress will not report cancel at this stage - force it here.
+			iProgress.iGenericProgress.iState = TImap4GenericProgress::EIdle;
+			iProgress.iGenericProgress.iErrorCode = KErrCancel;
+			// Cancel the idle controller.
+			iImapIdleController->Cancel();
+			// Cancelling the idle controller is likely to leave the IMAP Session
+			// with data left on the input stream to be dealt with. We need to
+			// flush the session if we wish to re-use it.
+			iFlushPrimary = ETrue;
+			break;
+			}
+		case ESync:
+		case ESelect:
+		case ECopyToLocal:
+		case ECopyWithinService:
+		case ECopyFromLocal:
+		case EMoveToLocal:
+		case EMoveWithinService:
+		case EMoveFromLocal:
+		case EPopulate:
+		case EDelete:
+		case EDeleteFolder:
+		case ECreate:
+		case ERename:
+	case EUpdateFlag:
+			{
+			__LOG_TEXT(KDefaultLog, "CImapProtocolController::DoCancelClientOp() - ESync/ESelect/ECopyToLocal/ECopyWithinService/ECopyFromLocal/EMoveToLocal/EMoveWithinService/EMoveFromLocal/EPopulate/EDelete/EDeleteFolder/ECreate/ERename/");
+			// This is the normal case, a requested operation is
+			// being performed by a compound operation object.
+			// First of all, check one exists.
+			if (iImapCompound!=NULL)
+				{
+				// Cancel the compound operation
+				__LOG_TEXT(KDefaultLog, "CImapProtocolController::DoCancelClientOp() - cancelling iImapCompound...");
+				iImapCompound->Cancel();
+				// update last operation progress state
+				__LOG_TEXT(KDefaultLog, "CImapProtocolController::DoCancelClientOp() - getting progres...");
+				iImapCompound->Progress(iProgress);
+				// Delete the compound object
+				__LOG_TEXT(KDefaultLog, "CImapProtocolController::DoCancelClientOp() - deleting compound...");
+				delete iImapCompound;
+				iImapCompound = NULL;
+				// Cancelling the compound operation is likely to leave
+				// the IMAP Session in an incomplete state. We need to
+				// flush the session if we wish to re-use it.
+				if (iForegroundSession==0)
+					{
+					__LOG_TEXT(KDefaultLog, "CImapProtocolController::DoCancelClientOp() - flush primary = ETrue...");
+					iFlushPrimary = ETrue;
+					}
+				else
+					{
+					__LOG_TEXT(KDefaultLog, "CImapProtocolController::DoCancelClientOp() - drop session...");
+					DropSession(iForegroundSession);
+					iForegroundSession=0;
+					}
+				__LOG_TEXT(KDefaultLog, "CImapProtocolController::DoCancelClientOp() - main iImapCompound handling complete...");
+				}
+			break;
+			}
+		case ECancelRecoverPrimary:
+			{
+			// The recover must be taking too long.
+			// cancel the recover request..
+			(iImapSessionArray[0])->Cancel();
+			// Delete all sessions, go offline etc.
+			DisconnectAll();
+			break;
+			}
+		default:
+			{
+			// nothing to do..
+			break;
+			}
+		} // end of switch (cancelledOp)
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::DoCancelClientOp() - about to call CMsgActive::DoCancel()...");
+	CMsgActive::DoCancel();
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::DoCancelClientOp() - END");
+	}
+/**
+Performs a fast disconnect on all sessions
+Ensures that the compound, background sync and sync manager objects are
+deleted following the disconnect.
+@param aMarkOffline - indicates if the service is to be marked offline.
+*/
+void CImapProtocolController::DisconnectAll()
+	{
+__LOG_TEXT(KDefaultLog, "CImapProtocolController::DisconnectAll() - START");
+	// Delete the background sync op
+__LOG_TEXT(KDefaultLog, "CImapProtocolController::DisconnectAll() - deleting iBackgroundSyncOp");
+	delete iBackgroundSyncOp;
+	iBackgroundSyncOp=NULL;
+	// Delete the imap compound operation
+__LOG_TEXT(KDefaultLog, "CImapProtocolController::DisconnectAll() - deleting iImapCompound");
+	delete iImapCompound;
+	iImapCompound=NULL;
+	// Delete the migrate compound operation
+	delete iMigrateCompound;
+	iMigrateCompound = NULL;
+	// delete the sync manager
+__LOG_TEXT(KDefaultLog, "CImapProtocolController::DisconnectAll() - deleting iImapSyncManager");
+	delete iImapSyncManager;
+	iImapSyncManager = NULL;
+	// delete the mobility manager (de-register for mobility notifications)
+	delete iMobilityManager;
+	iMobilityManager = NULL;
+	// delete the imap idle controller
+	delete iImapIdleController;
+	iImapIdleController = NULL;
+	// Drop connection on each of the imap sessions
+	TInt numSessions = iImapSessionArray.Count();
+	for (TInt i=0; i<numSessions; ++i)
+		{
+		if (iImapSessionArray[i])
+			{
+	        __LOG_FORMAT( (KDefaultLog, "CImapProtocolController::DisconnectAll() - disconnecting session: %d/%d", i, numSessions ) );
+			iImapSessionManager->Disconnect(*(iImapSessionArray[i]));
+			}
+		}
+	// The current network connection will be closed
+	iImapSessionManager->CloseNetworkConnection();
+	// empty the session array
+__LOG_TEXT(KDefaultLog, "CImapProtocolController::DisconnectAll() - resetting and destroying sessions...");
+	iImapSessionArray.ResetAndDestroy();
+	// force the state to IDLE
+	iRequestedOp = EIdle;
+	iCurrentOp = EIdle;
+	// Clear serviceid and mark the service as offline
+__LOG_TEXT(KDefaultLog, "CImapProtocolController::DisconnectAll() - about to MarkOnOrOffline...");
+	TRAP_IGNORE(MarkOnOrOfflineL(EFalse));
+	iServiceId=0;
+__LOG_TEXT(KDefaultLog, "CImapProtocolController::DisconnectAll() - END");
+	}
+/**
+Performs an immediate disconnect of specifed session and removes it from
+the session array.
+@param sessionId - the index in the session array of the session to drop.
+*/
+void CImapProtocolController::DropSession(TInt sessionId)
+	{
+	if (sessionId < iImapSessionArray.Count())
+		{
+		CImapSession* tempSession = iImapSessionArray[sessionId];
+		if (tempSession)
+			{
+			iImapSessionManager->Disconnect(*tempSession);
+			delete tempSession;
+			}
+		iImapSessionArray.Remove(sessionId);
+		}
+	}
+/**
+Private method to select session from the session array for use for operations
+that are supported while background operations are in progress.
+Issues a request to connect a secondary session if the primary session is busy
+and a secondary session is not already available. In this case the requested op
+is updated to show a secondary connect request, and the original requested op
+is saved.
+@param  aIndexToUse updated to indicate the index of the session to be used
+@return ETrue if the session is connected and ready to use immediately.
+		EFalse if a request to connect a secondary session has been issued.
+*/
+TBool CImapProtocolController::SelectSessionL(TInt& aIndexToUse)
+	{
+	__ASSERT_DEBUG(iCurrentOp != ECancelRecoverPrimary, TImapServerPanic::ImapPanic(TImapServerPanic::EProtocolControllerUnexpectedCurrentOp));
+	aIndexToUse = 0; // default to primary session.
+	TBool sessionReady = ETrue;
+	if (iBackgroundSyncOp != NULL)
+		{
+		TInt sessionCount = iImapSessionArray.Count();
+		if (sessionCount>=2)
+			{
+			// already a secondary session available - use this
+			aIndexToUse = sessionCount-1;
+			}
+		else
+			{
+			// Create a new session and get it connected.
+			iCurrentOp = EConnectSecondary;
+			CImapSession* imapSession = NULL;
+			iImapSessionArray.AppendL(imapSession);
+			iImapSessionManager->GetSessionL(iStatus, iImapSessionArray[sessionCount]);
+			aIndexToUse = sessionCount;
+			sessionReady = EFalse;
+			}
+		}
+	return sessionReady;
+	}
+/**
+Called to kick off a foreground operation, ie a user requested
+operation that is being performed on the primary IMAP session.
+If the session is in IMAP IDLE, a request is issued to stop this
+and the requested operation is started when the stop-idle operation
+has completed. Otherwise the operation is started immediately.
+*/
+void CImapProtocolController::StartPrimaryOperation()
+	{
+	// Make sure the foreground session id is correct
+	iForegroundSession = 0;
+	// imap idle controller is active in any state after
+	// idle has been requested.
+	if (iImapIdleController->IsActive())
+		{
+		iCurrentOp = EStopIdle;
+		iImapIdleController->StopIdle(iStatus);
+		}
+	else
+		{
+		iCurrentOp = iRequestedOp;
+		iImapCompound->StartOperation(iStatus, *iImapSessionArray[iForegroundSession]);
+		}
+	}
+/**
+Starts the background IDLE process.
+If IDLE is not supported by the server, or if IDLE is disabled via the
+account settings, a "dummy read" is issued, to manage any unsolicited
+server messages.
+This is called when user-requested compound operations have completed
+to return the primary session to IDLE state. Note that some operations
+require that IDLE is not re-issued, eg "select". It is also called
+when a background sync operation has completed, if there is no foreground
+operation currently in progress
+Idle is only issued on the primary session.
+Idle is not started if there is a background operation in progress
+*/
+void CImapProtocolController::StartIdle()
+	{
+	iCurrentOp = EIdle;
+	if (iBackgroundSyncOp==NULL)
+		{
+		iImapIdleController->StartIdle();
+		}
+	}
+/**
+Called by the CImapIdleController in the case of an error being observed
+while in IDLE state.
+@param aError - the observed error
+*/
+void CImapProtocolController::OnIdleError(TInt aError)
+	{
+	__LOG_FORMAT((KDefaultLog, "CImapProtocolController::OnIdleError(aError = %d)", aError));
+	if (aError>0)
+		{
+		aError = KErrImapServerFail;
+		}
+	iProgress.iGenericProgress.iErrorCode = aError;
+	iProgress.iGenericProgress.iState=TImap4GenericProgress::EDisconnected;
+	DisconnectAll();
+	// Nothing to complete.
+	}
+/**
+Returns the progress information for the outstanding command.
+@return progress information
+*/
+EXPORT_C TImap4CompoundProgress CImapProtocolController::Progress()
+	{
+	// Progress of foreground operation is returned	over that of a
+	// background sync operation.
+	// Do not refresh the progress while migrating.
+	if (iCurrentOp!=EIdle && iMigrateState == ENotMigrating)
+		{
+		// do not update if IDLEing - return the stored progress object
+		// this should have been populated correctly on completion of
+		// requested operation, whether successful or otherwise.
+		switch (iCurrentOp)
+			{
+		case EConnect:
+			{
+			iImapSessionManager->Progress(iProgress.iGenericProgress);
+			break;
+			}
+		case EStopIdle:
+		case ESync:
+		case ESelect:
+		case ECopyToLocal:
+		case ECopyWithinService:
+		case ECopyFromLocal:
+		case EMoveToLocal:
+		case EMoveWithinService:
+		case EMoveFromLocal:
+		case EPopulate:
+		case EDelete:
+		case EDeleteFolder:
+		case ECreate:
+		case ERename:
+		case EDisconnect:
+		case EUpdateFlag:
+			{
+			// Obtain progress from compound object if it exists
+			// Otherwise the last progress obtained on completion
+			// of the compound object is returned.
+			if (iImapCompound!=NULL)
+				{
+				iImapCompound->Progress(iProgress);
+				}
+			break;
+			}
+		case EIdle:
+		default:
+			break;
+			}
+		}
+		else if (iBackgroundSyncOp!=NULL)
+		{
+		// update sync progress if background sync is being performed.
+		iBackgroundSyncOp->Progress(iProgress);
+		}
+	return iProgress;
+	}
+/**
+changes local subscription flag on a folder immediately.
+If unsubscribing, the folder is marked as invisible, and the invisible
+flag is propagated to any parent folders that are not themselves subscribed
+or contain subscribed folders.
+@param aFolder
+@param aSubscribed
+@return Error code
+*/
+EXPORT_C TInt CImapProtocolController::SetLocalSubscription(const TMsvId aFolder,
+															TBool aSubscribed)
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::SetLocalSubscription()");
+	TInt err;
+	// Move to the entry
+	if ((err=iEntry.SetEntry(aFolder))!=KErrNone)
+		return(err);
+	// Check it's a folder
+	if (iEntry.Entry().iType!=KUidMsvFolderEntry)
+		return(KErrNotSupported);
+	// update subscription flag
+	TMsvEmailEntry entry=iEntry.Entry();
+	entry.SetLocalSubscription(aSubscribed);
+	entry.SetVisible(aSubscribed);
+	err = iEntry.ChangeEntry(entry);
+	// Return if error or if setting subscribed
+	if (err!=KErrNone || !aSubscribed)
+		{
+		TRAP(err, PropagateUnsubscribeL(aFolder));
+		return err;
+		}
+	else
+		{
+		return KErrNone;
+		}
+	}
+/**
+Marks aFolder as invisible and propagates the invisible flag to parent folder.
+@param aFolder the unsubscribed folder.
+*/
+void CImapProtocolController::PropagateUnsubscribeL(const TMsvId aFolder)
+	{
+	// Settings may not yet be loaded.
+	if (iImapSettings->SettingsLoaded()==EFalse)
+		{
+		iImapSettings->LoadSettingsL(aFolder);
+		}
+	// if synchronisation setting is not remote only then
+	// update the invisibility flags
+	if (iImapSettings->Synchronise() != EUseRemote)
+		{
+		PropagateInvisibleFlagL(aFolder);
+		ChangeVisibilityL(aFolder,ETrue,EFalse,KUidMsvMessageEntry);
+		}
+	}
+// Mark service as on or offline
+void CImapProtocolController::MarkOnOrOfflineL( const TBool aOnline )
+	{
+	// Mark service entry as on/offline
+	User::LeaveIfError( iEntry.SetEntry( iServiceId ) );
+	TMsvEntry entry=iEntry.Entry();
+	entry.SetConnected( aOnline );
+	User::LeaveIfError( iEntry.ChangeEntry( entry ) );
+	// Release the service entry
+	User::LeaveIfError( iEntry.SetEntry( KMsvNullIndexEntryId ) );
+	// Going offline?
+	if ( !aOnline && iImapSettings->DisconnectedUserMode() )
+		{
+		// We're an expert user going offline: don't touch anything
+		return;
+		}
+	// Mark all immediate children of the service as invisible
+	if ( !aOnline )
+		ChangeVisibilityL( iServiceId, !aOnline );
+	}
+void CImapProtocolController::ChangeVisibilityL(TMsvId aParent, TBool aInvisible)
+	{
+	ChangeVisibilityL(aParent, aInvisible, ETrue, KUidMsvFolderEntry);
+	}
+void CImapProtocolController::ChangeVisibilityL(TMsvId aParent, TBool aInvisible, TBool aRecurse, TUid aType)
+	{
+	// Get children at this level
+	CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;
+	CleanupStack::PushL( selection );
+	CMsvEntrySelection* folders = new (ELeave) CMsvEntrySelection;
+	CleanupStack::PushL( folders );
+	User::LeaveIfError( iEntry.SetEntry( aParent ) );
+	User::LeaveIfError( iEntry.GetChildren( *selection ) );
+	if ( selection->Count() )
+		{
+		for( TInt child=0; child < selection->Count(); child++ )
+			{
+			// Move to this child
+			User::LeaveIfError( iEntry.SetEntry( (*selection)[child] ) );
+			TMsvEntry message=iEntry.Entry();
+			// Is this the type we want to change?
+			if (message.iType==aType)
+				{
+				// Add to selection to do bulk change on, if necessary
+				if ((message.Visible() && aInvisible) ||
+					(!message.Visible() && !aInvisible))
+					{
+					folders->AppendL(message.Id());
+					}
+				}
+			// Recurse downwards
+			if (aRecurse && message.iType==KUidMsvFolderEntry)
+				ChangeVisibilityL(message.Id(),aInvisible,aRecurse,aType);
+			}
+		// Change its visibility off all children if necessary
+		if (folders->Count())
+			{
+			// Do the change to the invisible flag (actual constant for the
+			// flag we want is private:()
+			User::LeaveIfError( iEntry.SetEntry( aParent ) );
+			User::LeaveIfError( iEntry.ChangeAttributes(*folders,
+								aInvisible?0:KMsvVisibilityAttribute,
+								aInvisible?KMsvVisibilityAttribute:0));
+			}
+		}
+	// Release the service entry
+	User::LeaveIfError( iEntry.SetEntry( KMsvNullIndexEntryId ) );
+	// Get rid of selection
+	CleanupStack::PopAndDestroy(2);
+	}
+/**
+Propagates invisible flag for unsubscribed folders.
+aId has been unsubscribed. If it has no visible child folders then
+it is made invisible and its parent checked with the same test
+@param aId the folder that has been unsubscribed
+*/
+void CImapProtocolController::PropagateInvisibleFlagL(TMsvId aId)
+	{
+	__LOG_FORMAT((KDefaultLog, "PropagateInvisibleFlagL: 0x%x", aId));
+	// finish if we've reached the top
+	if (aId == KMsvRootIndexEntryId)
+		{
+		return;
+		}
+	User::LeaveIfError(iEntry.SetEntry(aId));
+	// finish if we've reached a service
+	if (iEntry.Entry().iType == KUidMsvServiceEntry)
+		{
+		return;
+		}
+	// return if we've found a subscribed folder since we can't make
+	// it invisible
+	if (((TMsvEmailEntry)iEntry.Entry()).LocalSubscription())
+		{
+		return;
+		}
+	// check the children of this unsubscribed folder
+	CMsvEntrySelection* selection=new (ELeave) CMsvEntrySelection;
+	CleanupStack::PushL(selection);
+	User::LeaveIfError(iEntry.GetChildren(*selection));
+	TBool visible=EFalse;
+	TInt count = selection->Count();
+	for (TInt i=0; i < count; ++i)
+		{
+		User::LeaveIfError(iEntry.SetEntry((*selection)[i]));
+		// look for a visible folder
+		TMsvEmailEntry entry = (TMsvEmailEntry)iEntry.Entry();
+		if (entry.iType == KUidMsvFolderEntry && entry.Visible())
+			{
+			visible=ETrue;
+			break;
+			}
+		}
+	CleanupStack::PopAndDestroy(selection);
+	// if no child folders were visible then make this folder
+	// invisible and continue up
+	if (!visible)
+		{
+		User::LeaveIfError(iEntry.SetEntry(aId));
+		// make this invisible
+		TMsvEntry entry = iEntry.Entry();
+		entry.SetVisible(EFalse);
+		User::LeaveIfError(iEntry.ChangeEntry(entry));
+		// go up
+		PropagateInvisibleFlagL(entry.Parent());
+		}
+	}
+/**
+Is this id in the local service?
+@param  aId   the id of the entry to check
+@return true, if the message id belongs to the local service.
+*/
+TBool CImapProtocolController::IdIsLocalL(TMsvId aId)
+	{
+	return ServiceOfL(aId) == KMsvLocalServiceIndexEntryIdValue;
+	}
+/**
+Returns the id of the service containing this id
+@param  aId   the id of the entry to check
+@return       the id of the containing service
+*/
+TMsvId CImapProtocolController::ServiceOfL(TMsvId aId)
+	{
+	TMsvId current=aId;
+	while(current!=KMsvRootIndexEntryIdValue)
+		{
+		// Visit this entry
+		User::LeaveIfError(iEntry.SetEntry(current));
+		TMsvEmailEntry entry = iEntry.Entry();
+		// if service then searched far enough
+		if (entry.iType==KUidMsvServiceEntry)
+			break;
+		// Go upwards
+		current=entry.Parent();
+		}
+	return current;
+	}
+/**
+Processes positive error codes returned by asynchronous service requests.
+Specifically, these will be error codes returned by the CImapSession,
+indicating error conditions in communication with the remote server.
+See cimapsessionconsts.h for full definition of error codes, summarised here:
+KErrImapNo 		 	 IMAP server returned a tagged NO response
+KErrImapBad 	 	 IMAP server returned a tagged BAD response
+KErrImapClosed		 indicates one of the streams has closed
+KErrImapFlushTimeout an attempt to flush a cancelled command has timed out
+KErrImapCorrupt		 corrupt data was enountered during parsing of IMAP server data
+@param  aError - the positive error code received on completion
+of an asynchronous service
+@return ETrue  - if this function has called Complete() due to a fatal error.
+		EFalse - otherwise
+*/
+TBool CImapProtocolController::ProcessError(TInt aError)
+	{
+	__LOG_FORMAT((KDefaultLog, "CImapProtocolController::ProcessError(iCurrentOp = %d, aError = %d)", iCurrentOp, aError));
+	// Bearer mobility support for initially connect failure
+	if (iMobilityManager && aError == KErrImapConnectError && iImapSessionManager->HasConnection())
+		{
+		// Change migration state, so the connect error can be dealt with,
+		// using the migration state machine.
+		iMigrateState = EHandlingConnectError;
+		SetActive();
+		TRequestStatus* status = &iStatus;
+		User::RequestComplete(status, KErrNone);
+		return ETrue;
+		}
+	// weed out non-fatal server errors
+	ThranslateSessionError(aError);
+	if (aError == KErrNone)
+		{
+		return EFalse;
+		}
+	if (iForegroundSession>0)
+		{
+		// error has occurred on a secondary session.
+		// This is not fatal to the whole protocol controller's
+		// existance, but it is fatal to the requested operation
+		// get final progress state...
+		if (iCurrentOp==EConnectSecondary)
+			{
+			iImapSessionManager->Progress(iProgress.iGenericProgress);
+			}
+		else
+			{
+			iImapCompound->Progress(iProgress);
+			}
+		//... and update reported error code
+		iProgress.iGenericProgress.iErrorCode=aError;
+		// delete the compound operation object
+		delete iImapCompound;
+		iImapCompound = NULL;
+		// drop the secondary session
+		DropSession(iForegroundSession);
+		// complete the user request with KErrNone..
+		Complete(KErrNone);
+		}
+	else
+		{
+		// DoComplete normally handles the session tidyup, but
+		// is not called if the error has occurred during a background
+		// operation, for example ECancelRecoverPrimary
+		if (iCurrentOp==ECancelRecoverPrimary)
+			{
+			// Non-fatal errors should have been handled prior to this.
+			DisconnectAll();
+			// Save error code in progress and flag the disconnect
+			// this is defensive as the client should not be watching progress
+			iProgress.iGenericProgress.iState=TImap4GenericProgress::EDisconnected;
+			iProgress.iGenericProgress.iErrorCode=aError;
+			}
+		Complete(aError);
+		}
+	return ETrue;
+	}
+/**
+Translates session error codes for reporting to the Server MTM.
+KErrImapNo and KErrImapBad are non-fatal to the session, and
+should have been fielded by the compound operation, sync manager
+or session manager (during session connect), however they are
+translated to KErrNone here.
+All other session errors are fatal to the connection. If an
+error occurs on the primary session, all connected sessions
+should be disconnected and the client completed.
+*/
+void CImapProtocolController::ThranslateSessionError(TInt& errCode)
+	{
+	if ( errCode == KErrNone
+	  || errCode == KErrImapNo
+	  || errCode == KErrImapBad )
+		{
+		// No and bad should have been handled by the compound
+		// operation and are non-fatal to the connection.
+		errCode = KErrNone;
+		}
+	else
+		{
+		errCode = KErrImapServerFail;
+		}
+	}
+/**
+Resets the progress object
+*/
+void CImapProtocolController::ResetProgress()
+	{
+	//initialise the TImap4SyncProgress part
+	iProgress.iSyncProgress.iFoldersToDo = 0;
+	iProgress.iSyncProgress.iFoldersDone = 0;
+	iProgress.iSyncProgress.iMsgsToDo = 0;
+	iProgress.iSyncProgress.iMsgsDone = 0;
+	iProgress.iSyncProgress.iHeadersFetched = 0;
+	iProgress.iSyncProgress.iOrphanedFolders = 0;
+	iProgress.iSyncProgress.iNewFolders = 0;
+	iProgress.iSyncProgress.iOrphanedMessages = 0;
+	iProgress.iSyncProgress.iRemoteMessagesDeleteTagged = 0;
+	iProgress.iSyncProgress.iMessagesFetchedOK = 0;
+	iProgress.iSyncProgress.iMessagePartsFetchedOK = 0;
+	iProgress.iSyncProgress.iMessagePartsNotFound = 0;
+	iProgress.iSyncProgress.iFoldersNotFound = 0;
+	iProgress.iSyncProgress.iErrorCode = KErrNone;
+	iProgress.iSyncProgress.iType = EImap4SyncProgressType;
+	//initialise the TImap4GenericProgress part
+	iProgress.iGenericProgress.iMsgsToDo = 0;
+	iProgress.iGenericProgress.iMsgsDone = 0;
+	iProgress.iGenericProgress.iPartsToDo = 0;
+	iProgress.iGenericProgress.iPartsDone = 0;
+	iProgress.iGenericProgress.iBytesToDo = 0;
+	iProgress.iGenericProgress.iBytesDone = 0;
+	iProgress.iGenericProgress.iReturnedMsvId = 0;
+	iProgress.iGenericProgress.iTotalSize = 0;
+	iProgress.iGenericProgress.iErrorCode = KErrNone;
+	iProgress.iGenericProgress.iType = EImap4GenericProgressType;
+	}
+/**
+Notice that a preferred carrier has become available, and migration to that bearer has been accepted.
+The protocol controller shall either pause or allow any current operation to complete
+according to the action specified in parameter aAction. Once the current operation
+is paused or complete, the protocol controller shall close any existing sockets
+and finally notify the mobility framework that it is ready to migrate to the new
+carrier.
+@param aAction      - indicates the action that should be taken re: current operations
+@param aIsSeamless  - indicates if the
+*/
+void CImapProtocolController::PrepareForNewCarrier(TImMobilityAction aAction, TBool /*aIsSeamless*/)
+	{
+	__LOG_FORMAT((KDefaultLog, "CImapProtocolController::PrepareForNewCarrier(iMigrateState=%d, aAction = %d)", iMigrateState, aAction));
+	// Handle being called in an already-migrating state before handling usual case
+	if (iMigrateState!=ENotMigrating)
+		{
+		switch (iMigrateState)
+			{
+			case EDisconnectingForMigrate:
+			case EWaitingForOpToStop:
+				{
+				// Do not allow change from EWaitingForOpToStop to EWaitingForOpToComplete
+				// but do allow an operation to be stopped suddenly if necessary.
+				if (aAction==KAcceptImmediately)
+					{
+					CarrierLost();
+					iMigrateState = EWaitingForNewCarrier;
+					iMobilityManager->MigrateToNewCarrier();
+					// do not set waiting if NewCarrierActive has been called synchronously.
+					if (iMigrateState == EWaitingForNewCarrier)
+						{
+						// Now in a waiting state, set self active
+						iStatus = KRequestPending;
+						SetActive();
+						}
+					}
+				// else already preparing for new carrier, nothing to do.
+				return;
+				}
+			case EWaitingForOpToComplete:	// async wait on compound op/bground op/idle controller
+				{
+				// Allow change from EWaitingForOpToComplete to EWaitingForOpToStop
+				// also allow an operation to be stopped suddenly if necessary.
+				if (aAction==KAcceptImmediately)
+					{
+					CarrierLost();
+					iMigrateState = EWaitingForNewCarrier;
+					iMobilityManager->MigrateToNewCarrier();
+					// do not set waiting if NewCarrierActive has been called synchronously.
+					if (iMigrateState == EWaitingForNewCarrier)
+						{
+						// Now in a waiting state, set self active
+						iStatus = KRequestPending;
+						SetActive();
+						}
+					}
+				else if (aAction==KAcceptStopCurrent)
+					{
+					// change from EWaitingForOpToComplete to EWaitingForOpToStop
+					StopCurrentForMigrate();
+					}
+				// else already preparing for new carrier, nothing to do.
+				return;
+				}
+			case EHandlingConnectError:
+				{
+				// We have a Connect Error, from previous connect attempt
+				// We are ready to (migrate) reconnect
+				iMigrateState = EWaitingForNewCarrier;
+				iMobilityManager->MigrateToNewCarrier();
+				// do not set waiting if NewCarrierActive has been called synchronously.
+				if (iMigrateState == EWaitingForNewCarrier)
+					{
+					// Now in a waiting state, set self active
+					iStatus = KRequestPending;
+					SetActive();
+					}
+				break;
+				}
+			case EConnectingAfterMigrate:	// async wait on session manager
+				{
+				// cancelling in this state tidies up the session array, so
+				// nothing extra to do here - now ready for migration.
+				Cancel();
+				iMigrateState = EWaitingForNewCarrier;
+				iMobilityManager->MigrateToNewCarrier();
+				// do not set waiting if NewCarrierActive has been called synchronously.
+				if (iMigrateState == EWaitingForNewCarrier)
+					{
+					// Now in a waiting state, set self active
+					iStatus = KRequestPending;
+					SetActive();
+					}
+				return;
+				}
+			case EWaitingInitialCarrierRejected:	// async wait state on mobility engine
+			case EWaitingForNewCarrier:		// async wait state on mobility engine
+			case EStartingReconnect:		// intermediate state
+				{
+				// already ready and waiting for a new carrier - Cancel dummy request
+				// and tell the Mobility framework we are ready
+				Cancel();
+				iMigrateState = EWaitingForNewCarrier;
+				iMobilityManager->MigrateToNewCarrier();
+				// do not set waiting if NewCarrierActive has been called synchronously.
+				if (iMigrateState == EWaitingForNewCarrier)
+					{
+					// Now in a waiting state, set self active
+					iStatus = KRequestPending;
+					SetActive();
+					}
+				return;
+				}
+			case ESuspendingForMigrate:     // intermediate state
+			case ENotMigrating:				// already checked this isn't true
+			default:
+				{
+				__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::EProConPreForNewCarBadMigrateState));
+				}
+			}
+		}
+	// Do the requested action...
+	switch (aAction)
+		{
+		case KAcceptCompleteCurrent:
+			{
+			// Any current operation shall be allowed to complete prior
+			// to indicating that the server MTM is ready to migrate to
+			// the new bearer.
+			CompleteCurrentForMigrate();
+			break;
+			}
+		case KAcceptStopCurrent:
+			{
+			// Any current operation shall be allowed to continue until
+			// such a point that it may be resumed without re-sending or
+			// re-receiveing a significant amount to data prior to
+			// indicating that the server MTM is ready to migrate to the
+			// new bearer.
+			StopCurrentForMigrate();
+			break;
+			}
+		case KAcceptImmediately:
+		default:
+			{
+			// accept immediately is an instruction to immediately suspend any
+			// current operation (cancel any outstanding server communication)
+			// and close any open sockets. This is the same behaviour as required
+			// for a downgrade situation.
+			CarrierLost();
+			iMigrateState = EWaitingForNewCarrier;
+			iMobilityManager->MigrateToNewCarrier();
+			// do not set waiting if NewCarrierActive has been called synchronously.
+			if (iMigrateState == EWaitingForNewCarrier)
+				{
+				// Now in a waiting state, set self active
+				iStatus = KRequestPending;
+				SetActive();
+				}
+			break;
+			}
+		} // end switch (aAction)
+	}
+/**
+Configures the protocol controller (PC) to allow any current operation in progress
+to complete prior to indicating to the mobility framework that it is ready to
+migrate to the new carrier.
+Note the protocol controller may be in any of the following states
+- IDLE (only one session exists)
+- background sync in progress only (only one session exists)
+- foreground op in progress only (only one session exists)
+- background sync and foreground operation in progress (2 sessions exist)
+- background sync in progress and connecting second session for foreground op
+*/
+void CImapProtocolController::CompleteCurrentForMigrate()
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::CompleteCurrentForMigrate()");
+	// set the migrating flag
+	iMigrateState = EWaitingForOpToComplete;
+	if (BackgroundSyncInProgress())
+		{
+		// 2-phase background sync is always delayed till after migration
+		iBackgroundSyncOp->StopForMigrate();
+		}
+	// If no operation in progress, stop the IDLE
+	if (iCurrentOp == EIdle && iImapIdleController->IsActive())
+		{
+		iCurrentOp = EStopIdle;
+		iImapIdleController->StopIdle(iStatus);
+		SetActive();
+		return;
+		}
+	// cancel a secondary session connect
+	if (iCurrentOp == EConnectSecondary)
+		{
+		CancelForMigrate();
+		iMigrateState = EWaitingForOpToComplete;
+		// defensive: it is possible that the background sync has completed
+		// while the secondary connect is still in progress. In this case
+		// neither DoRunL() nor BackgroundSyncComplete() will not be called.
+		if (!BackgroundSyncInProgress())
+			{
+			// fake a stop-idle op
+			iCurrentOp = EStopIdle;
+			SetActive();
+			TRequestStatus* status = &iStatus;
+			User::RequestComplete(status, KErrNone);
+			}
+		}
+	}
+/**
+CancelForMigrate() - cancels any outstanding service without deleting the
+compound operation or completing the user request.
+This does not cancel a background sync.
+iMigrateState must be set to a new state immediately after calling this.
+*/
+void CImapProtocolController::CancelForMigrate()
+	{
+	iMigrateState = ESuspendingForMigrate;
+	Cancel();
+	}
+/**
+*/
+void CImapProtocolController::DoCancelForMigrate()
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::DoCancelForMigrate()");
+	switch (iCurrentOp)
+		{
+		case EConnectSecondary:
+			{
+			// Cancel the connect request
+			iImapSessionManager->Cancel();
+			// Remove the session pointer from the array
+			// The session has already been deleted - see note above.
+			TInt numSessions = iImapSessionArray.Count();
+			iImapSessionArray.Remove(numSessions-1);
+			break;
+			}
+		case EIdle:
+		case EStopIdle:
+			{
+			// Cancel the IDLE controller.
+			iImapIdleController->Cancel();
+			break;
+			}
+		case ESync:
+		case ESelect:
+		case ECopyToLocal:
+		case ECopyWithinService:
+		case ECopyFromLocal:
+		case EMoveToLocal:
+		case EMoveWithinService:
+		case EMoveFromLocal:
+		case EPopulate:
+		case EDelete:
+		case EDeleteFolder:
+		case ECreate:
+		case ERename:
+			{
+			// Cancel the compound operation
+			iImapCompound->CancelForMigrate();
+			break;
+			}
+		case ECancelRecoverPrimary:
+			{
+			// Cancel the session recovery.
+			(iImapSessionArray[0])->Cancel();
+			}
+		case EConnect:
+//		case EConnectAndSync:
+		case EDisconnect:
+		default:
+			{
+			// nothing to do..
+			break;
+			}
+		} // end of switch (iCurrentOp)
+	// Do NOT call CMsgActive::DoCancel()
+	// - the client requested operation is not being cancelled
+	}
+/**
+Configures the protocol controller (PC) to stop any current operation in
+progress at the next convenient point - the meaning of this depends on the
+specific compound operations. For example, for simple operations such as
+creating a folder, this will be when the operation has completed but for
+operations for which multiple messages are processed in sequence (eg
+fetching several messages), it shall be once the current message has been
+processed (eg fetched). At this point the operation shall complete the
+protocol controller's iStatus
+Note the protocol controller may be in any of the following states
+- IDLE (only one session exists)
+- background sync in progress only (only one session exists)
+- foreground op in progress only (only one session exists)
+- background sync and foreground operation in progress (2 sessions exist)
+- background sync in progress and connecting second session for foreground op
+*/
+void CImapProtocolController::StopCurrentForMigrate()
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::StopCurrentForMigrate()");
+	// set the migrating flag
+	iMigrateState = EWaitingForOpToStop;
+	if (BackgroundSyncInProgress())
+		{
+		iBackgroundSyncOp->StopForMigrate();
+		}
+	if (iCurrentOp == EIdle && iImapIdleController->IsActive())
+		{
+		// If no operation in progress, stop the IDLE
+		iCurrentOp = EStopIdle;
+		iImapIdleController->StopIdle(iStatus);
+		SetActive();
+		return;
+		}
+	else if (iCurrentOp == EConnectSecondary)
+		{
+		// cancel a secondary session connect
+		Cancel();
+		// defensive: it is possible that the background sync has completed
+		// while the secondary connect is still in progress. In this case
+		// neither DoRunL() nor BackgroundSyncComplete() will not be called.
+		if (!BackgroundSyncInProgress())
+			{
+			// fake a stop-idle op
+			iCurrentOp = EStopIdle;
+			SetActive();
+			TRequestStatus* status = &iStatus;
+			User::RequestComplete(status, KErrNone);
+			}
+		}
+	else if (iCurrentOp != ECancelRecoverPrimary)
+		{
+		// nothing to do for ECancelRecoverPrimary - just wait for the
+		// session to flush.
+		// all other operations are told to stop:
+		iImapCompound->StopForMigrate();
+		}
+	}
+/**
+This API is called by the Bearer Mobility Manager. It is typically called in the
+case that a downgrade is occuring, and the original sockets are no longer valid
+for use. It may also be called if an immediate migration to an preferred bearer is
+required, without graceful closing of the original sockets.
+Any operations are cancelled immediately using the CancelForMigrate() API. This
+cancels the operations in such a way that they may be restarted following migration
+to a new carrier.
+*/
+void CImapProtocolController::CarrierLost()
+	{
+	__LOG_FORMAT((KDefaultLog, "CImapProtocolController::CarrierLost(iMigrateState=%d)", iMigrateState));
+	// Handle being called in an already-migrating state before handling usual case
+	if (iMigrateState!=ENotMigrating)
+		{
+		switch (iMigrateState)
+			{
+			case EWaitingForOpToStop:
+			case EWaitingForOpToComplete:
+				{
+				// break to default behaviour
+				break;
+				}
+			case EStartingReconnect:		// intermediate state
+			case EDisconnectingForMigrate:
+			case EConnectingAfterMigrate:
+				{
+				// cancel the disconnect/connect, then break to default behaviour
+				// (calling CancelForMigrate() shouldn't do anything as any compound
+				// operations will not themselves be active)
+				Cancel();
+				break;
+				}
+			case EHandlingConnectError:
+				{
+				// empty the session array
+				TInt numSessions = iImapSessionArray.Count();
+				for (TInt i=0; i<numSessions; ++i)
+					{
+					if (iImapSessionArray[i])
+						{
+						iImapSessionManager->Disconnect(*(iImapSessionArray[i]));
+						}
+					}
+				iImapSessionArray.ResetAndDestroy();
+				// Set the migration state:
+				iMigrateState = EWaitingForNewCarrier;
+				// Now in an waiting state, set self active
+				iStatus = KRequestPending;
+				SetActive();
+				return;
+				}
+			case EWaitingInitialCarrierRejected:
+			case EWaitingForNewCarrier:
+				{
+				// already ready and waiting for a new carrier - nothing to do.
+				return;
+				}
+			case ESuspendingForMigrate:     // intermediate state
+			case ENotMigrating:				// normal state
+			default:
+				{
+				__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::EProConKillCurrentBadMigrateState));
+				break;
+				}
+			}
+		}
+	// stop any background operation
+	if (iBackgroundSyncOp)
+		{
+		iBackgroundSyncOp->CancelForMigrate();
+		}
+	// Cancel foreground operations
+	CancelForMigrate();
+	// delete the imap idle controller - this will be re-created on reconnect.
+	delete iImapIdleController;
+	iImapIdleController=NULL;
+	// Drop connection on each of the imap sessions
+	TInt numSessions = iImapSessionArray.Count();
+	for (TInt i=0; i<numSessions; ++i)
+		{
+		if (iImapSessionArray[i])
+			{
+			iImapSessionManager->Disconnect(*(iImapSessionArray[i]));
+			}
+		}
+	// empty the session array
+	iImapSessionArray.ResetAndDestroy();
+	// Set the migration state:
+	iMigrateState = EWaitingForNewCarrier;
+	// Now in an waiting state, set self active
+	iStatus = KRequestPending;
+	SetActive();
+	}
+/**
+Called to indicate the migration has completed and the RConnection is ready to
+provide new sockets via the new bearer.
+Initiates the creation of a new IMAP session, following which any suspended
+operation shall be restarted.
+*/
+void CImapProtocolController::NewCarrierActive(TAccessPointInfo /*aNewAp*/, TBool /*aIsSeamless*/)
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::NewCarrierActive()");
+	__ASSERT_DEBUG((iMigrateState == EWaitingForNewCarrier || iMigrateState == EWaitingInitialCarrierRejected),
+	               TImapServerPanic::ImapPanic(TImapServerPanic::ENewCarrierActiveUnexpectedMigrateState));
+	// Cancel the dummy active state
+	Cancel();
+	// set the new migration state
+	iMigrateState = EStartingReconnect;
+	// complete self - this requires some memory allocation, do it within the RunL.
+	TRequestStatus* status = &iStatus;
+	User::RequestComplete(status, KErrNone);
+	SetActive();
+	}
+void CImapProtocolController::NewPrimarySessionL()
+	{
+	// Create the primary session pointer
+	CImapSession* imapSession = NULL;
+	iImapSessionArray.AppendL(imapSession);
+	// Request the session manager to connect the session
+	iImapSessionManager->GetSessionL(iStatus, iImapSessionArray[0]);
+	iMigrateState = EConnectingAfterMigrate;
+	SetActive();
+	}
+/**
+Indicates that the RConnection is no longer valid.
+Therefore disconnect and mark the service as offline.
+*/
+#ifdef __IMAP_LOGGING
+void CImapProtocolController::MobilityError(TUint aError)
+#else //__IMAP_LOGGING
+void CImapProtocolController::MobilityError(TUint /*aError*/)
+#endif //__IMAP_LOGGING
+	{
+	__LOG_FORMAT((KDefaultLog, "CImapProtocolController::MobilityError(iMigrateState=%d, aError=%d)", iMigrateState, aError));
+	// Cancel any async request
+	Cancel();
+	if (iRequestedOp != EIdle)
+		{
+		// Complete the user request - calls DisconnectAll()
+		Complete(KErrDisconnected);
+		}
+	else
+		{
+		// Disconnect all sessions and mark the service as offline
+		DisconnectAll();
+		}
+	// the RConnection is no longer valid - delete the session manager
+	// (will be recreated on ConnectL())
+	delete iImapSessionManager;
+	iImapSessionManager = NULL;
+	// no longer migrating...
+	iMigrateState = ENotMigrating;
+	// Save error code in progress and flag the disconnect
+	// this is defensive as the client should not be watching progress
+	iProgress.iGenericProgress.iState=TImap4GenericProgress::EDisconnected;
+	iProgress.iGenericProgress.iErrorCode=KErrDisconnected;
+	}
+void CImapProtocolController::ProcessOpCompleteForMigrate()
+	{
+	// Any tidying up to do for the current user-requested operation
+	switch (iCurrentOp)
+		{
+		case ECancelRecoverPrimary:
+		case EIdle:
+		case EStopIdle:
+			{
+			// engine was IDLE or recovering from a cancel when the
+			// migrate notice arrived... nothing to do before disconnecting.
+			break;
+			}
+		case ESync:
+		case ESelect:
+		case ECopyToLocal:
+		case ECopyWithinService:
+		case ECopyFromLocal:
+		case EMoveToLocal:
+		case EMoveWithinService:
+		case EMoveFromLocal:
+		case EPopulate:
+		case EDelete:
+		case EDeleteFolder:
+		case ECreate:
+		case ERename:
+			{
+			// update last operation progress state
+			iImapCompound->Progress(iProgress);
+			// if the user requested operation has finished,
+			// tidyup and inform the client
+			if (iProgress.iGenericProgress.iState == TImap4GenericProgress::EIdle)
+				{
+				delete iImapCompound;
+				iImapCompound = NULL;
+				// Complete the server mtm request.
+				Complete(iStatus.Int());
+				}
+			break;
+			}
+		case EConnect:
+		case EDisconnect:
+		case EConnectSecondary:
+		default:
+			{
+			__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::EProcessOpCompleteForMigrateUnexpectedState));
+			}
+		} // end of switch (iCurrentOp)
+	}
+/**
+Logs out and disconnects all connected sessions with the remote server.
+*/
+void CImapProtocolController::DisconnectForMigrateL()
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::DisconnectForMigrateL()");
+	__ASSERT_DEBUG(iMigrateCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::EMigrateCompoundIsNotNull));
+	// Background operations will have been taken care of already - just disconnect.
+	// Do not perform the late-delete offline operations.
+	delete iMigrateCompound;
+	iMigrateCompound = NULL;
+	iMigrateCompound = CImapCompoundDisconnect::NewL( *iImapSyncManager,
+												      iEntry,
+												      *iImapSettings,
+												      *iImapSessionManager,
+												      *iImapMailStore,
+												      iImapSessionArray,
+												      iImapOfflineControl,
+												      EFalse );
+	iMigrateState = EDisconnectingForMigrate;
+	iMigrateCompound->StartOperation(iStatus, *iImapSessionArray[0]);
+	SetActive();
+	}
+/**
+Resumes operations that were stopped to allow migration to occur,
+or operations that were requested while migration was in progress.
+*/
+void CImapProtocolController::RestartAfterMigrateL()
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::RestartAfterMigrateL()");
+	// The migration has completed. Restart anything that was going on
+	// before the migration started, or has been requested in the meantime.
+	iMigrateState = ENotMigrating;
+	// was the initial carrier rejected during the connect operation?
+	// if so, mark as online and get the final connection progress info.
+	if (iCurrentOp == EConnect)
+		{
+		TRAP_IGNORE(MarkOnOrOfflineL(ETrue));
+		// Collect the final connect progress information
+		iImapSessionManager->Progress(iProgress.iGenericProgress);
+		// Set last socket activity timeout to iMtmData1. This is used by Imcm.
+		User::LeaveIfError( iEntry.SetEntry( iServiceId ) );
+		TMsvEntry entry=iEntry.Entry();
+		entry.SetMtmData1(iImapSessionManager->LastSocketActivityTimeout());
+		User::LeaveIfError( iEntry.ChangeEntry( entry ) );
+		// complete the connect request
+		Complete(iStatus.Int());
+		}
+	// Create a new IDLE controller - the old one was deleted.
+	delete iImapIdleController;
+	iImapIdleController=NULL;
+	iImapIdleController = CImapIdleController::NewL(*this, iImapSessionArray[0], *iImapSyncManager, iEntry, *iImapSettings, *iImapMailStore);
+	//	was there a background sync in progress prior to migration?
+	if (iBackgroundSyncOp)
+		{
+		// restart any background operation, using the new primary session.
+		iBackgroundSyncOp->ResumeOperationL(*iImapSessionArray[0]);
+		// was there a forground operation paused as well?
+		if (iImapCompound)
+			{
+			// Create a second connected session.
+			iCurrentOp = EConnectSecondary;
+			// iRequestedOp should not have been changed...
+			CImapSession* imapSession = NULL;
+			iImapSessionArray.AppendL(imapSession);
+			TInt sessionCount = iImapSessionArray.Count();
+			iImapSessionManager->GetSessionL(iStatus, iImapSessionArray[sessionCount-1]);
+			SetActive();
+			}
+		else
+			{
+			iCurrentOp = EIdle;
+			}
+		return;
+		}
+	if (iImapCompound)
+		{
+		// Idle has not been restarted after the migration, so the requested
+		// operation can be re-started without calling StopIdle()
+		// resume the suspended operation
+		iCurrentOp = iRequestedOp;
+		iImapCompound->ResumeOperationL(iStatus, *iImapSessionArray[0]);
+		SetActive();
+		}
+	else
+		{
+		// otherwise just start Idle
+		iCurrentOp = EIdle;
+		iRequestedOp = EIdle;
+		StartIdle();
+		}
+	}
+/**
+Returns a packaged copy of the current progress for passing to the
+mobility policy plugin when a preferred carrier available notice
+is received.
+*/
+const TDesC8& CImapProtocolController::MobilityProgress()
+	{
+	Progress();
+	iProgressBuffer = TImap4ProgressBuf(iProgress);
+	return iProgressBuffer;
+	}
+/**
+Updates  the specified messages read/unread status from the remote server.
+@param aStatus
+*/
+EXPORT_C void CImapProtocolController::UpdateFlagL( TRequestStatus& aStatus)
+	{
+	__LOG_TEXT(KDefaultLog, "CImapProtocolController::UpdateFlagL()");
+	__ASSERT_DEBUG(iImapCompound==NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ECreateCompoundIsNotNull));
+	ResetProgress();
+	if (!CompleteIfBackgroundOpInProgress(aStatus))
+		{
+		iImapCompound = CImapUpdateFlagOperation::NewL(*iImapSyncManager,
+												   iEntry,
+												   *iImapSettings
+												   );
+		iRequestedOp = EUpdateFlag;
+		StartPrimaryOperation();
+		Queue(aStatus);
+		SetActive();
+		}
+	}

changeset 31	ebfee66fde93
child 47	5b14749788d7
child 72	6f657153cbc5