// Copyright (c) 2006-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 "cimapcompoundsyncfolder.h"
#include "cimapfolder.h"
#include "cimapfolderinfo.h"
#include "cimapsession.h"
#include "cimapsessionconsts.h"
#include "cimaplogger.h"
#include "imappaniccodes.h"
#include "cimapcompoundcopytolocal.h"
#include "mobilitytestmtmapi.h"
CImapCompoundSyncFolder::CImapCompoundSyncFolder(CImapSyncManager& aSyncManager, CMsvServerEntry& aServerEntry, CImapSettings& aImapSettings, CImapMailStore& aImapMailStore, TBool aNewOnly, TMsvId aFolderId)
: CImapCompoundBase(aSyncManager, aServerEntry, aImapSettings),
iImapMailStore(aImapMailStore), iNewOnly(aNewOnly), iFolderId(aFolderId)
{
// Set default progress values here so that any progress request before
// the operation is started returns valid information.
iSyncProgressState=TImap4SyncProgress::ESyncOther;
}
CImapCompoundSyncFolder::~CImapCompoundSyncFolder()
{
delete iImapCompound;
}
/**
Static constructor for Sync Folder operations
@param aSession The IMAP Session to use
@param aSyncManager IMAP Sync Manager
@param aServerEntry CMsvServerEntry for messaging server operations
@param aImapSettings The IMAP account service settings
@param aNewOnly ETrue if only newly-received mail should be synchronised
@param aFolderId Folder to synchronise (default KMsvNullIndexEntryId
indicates the currently selected folder should be synchronised)
*/
CImapCompoundSyncFolder* CImapCompoundSyncFolder::NewL(CImapSyncManager& aSyncManager, CMsvServerEntry& aServerEntry, CImapSettings& aImapSettings, CImapMailStore& aImapMailStore, TBool aNewOnly, TMsvId aFolderId/* = KMsvNullIndexEntryId */)
{
CImapCompoundSyncFolder* self = new (ELeave) CImapCompoundSyncFolder(aSyncManager, aServerEntry, aImapSettings, aImapMailStore, aNewOnly, aFolderId);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
void CImapCompoundSyncFolder::ConstructL()
{
CActiveScheduler::Add(this);
}
void CImapCompoundSyncFolder::StartOperation(TRequestStatus& aStatus, CImapSession& aSession)
{
iSession = &aSession;
__LOG_TEXT(iSession->LogId(), "CImapCompoundSyncFolder::StartOperation()");
iNextStep = ESelectSourceMailboxRW;
Queue(aStatus);
CompleteSelf();
}
/**
Handles the compound operation state machine
@return ETrue if compound operation is completed,
EFalse otherwise (will be called again, unless active)
*/
TBool CImapCompoundSyncFolder::DoRunLoopL()
{
SetCurrentStep();
switch (iCurrentStep)
{
case ESelectSourceMailboxRW:
{
MOBILITY_TEST_MTM_STATE(iImapSettings.ServiceId(), KMobilityTestMtmStateImapSyncFolder1);
if(iFolderId==KMsvNullIndexEntryId)
{
// Get the selected folder
if(iSession->SelectedFolderInfo())
{
iFolderId = iSession->SelectedFolderInfo()->MsvId();
}
else
{
Complete(KErrArgument);
return ETrue;
}
}
iSyncFolder=iSyncManager.GetFolderL(iFolderId);
if (iSyncFolder==NULL)
{
Complete(KErrNotSupported);
return ETrue;
}
iSyncFolder->SelectL(iStatus, *iSession);
iProgressState = TImap4GenericProgress::ESelecting;
iNextStep=ESyncFolder;
SetActive();
break;
}
case ESyncFolder:
{
// suspend operation if stop for migrate has been requested
if (iStopForMigrate)
{
__LOG_TEXT(iSession->LogId(), "CImapCompoundDelete::Stopped for migrate");
iCurrentStep = ESuspendedForMigrate;
iNextStep = ESelectSourceMailboxRW;
Complete(KErrNone);
return ETrue;
}
MOBILITY_TEST_MTM_STATE(iImapSettings.ServiceId(), KMobilityTestMtmStateImapSyncFolder2);
// Synchronise the folder
iSyncFolder->SynchroniseL(iStatus, *iSession, iNewOnly, ETrue);
iProgressState = TImap4GenericProgress::ESyncing;
// update next step according to download rule usage.
iNextStep = EFinished;
if (iImapSettings.UseSyncDownloadRules())
{
iNextStep = ESyncFolderAutoFetch;
}
SetActive();
break;
}
case ESyncFolderAutoFetch:
{
// suspend operation if stop for migrate has been requested
if (iStopForMigrate)
{
__LOG_TEXT(iSession->LogId(), "CImapCompoundDelete::Stopped for migrate");
iCurrentStep = ESuspendedForMigrate;
iNextStep = ESyncFolderAutoFetch;
// delete the compound fetch operation - we will create a new one on resume,
// using the download rules for the new bearer.
delete iImapCompound;
iImapCompound = NULL;
Complete(KErrNone);
return ETrue;
}
// Set the next step, which is always EFinished
iNextStep = EFinished;
// Get download rules defined for this folder type/bearer type
TInt ruleId=0;
TImImap4GetPartialMailInfo mailInfo;
if (iFolderId == (iSyncManager.Inbox())->MailboxId())
{
ruleId = iImapSettings.GetSyncDownloadRuleL(CImapSyncDownloadRules::EInboxRulesType, mailInfo);
}
else
{
ruleId = iImapSettings.GetSyncDownloadRuleL(CImapSyncDownloadRules::EFolderRulesType, mailInfo);
}
// finish now if no download rules configured for this folder type/bearer type
if (ruleId == KErrNotFound)
{
return EFalse;
}
// build a list of messages to be fetched...
CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;
CleanupStack::PushL(selection);
TInt msgsToFetch = iSyncFolder->GetFetchMessageChildrenL(*selection);
__LOG_FORMAT((iSession->LogId(), "CImapCompoundSyncFolder::Fetching %d messages in folder %d.", msgsToFetch, iSyncFolder->MailboxId()));
if (msgsToFetch>0)
{
delete iImapCompound;
iImapCompound = NULL;
// Create the compound operation object
iImapCompound = CImapCompoundCopyToLocal::NewL(iSyncManager,
iServerEntry,
iImapSettings,
iImapMailStore,
EFalse,
*selection,
KMsvNullIndexEntryId,
mailInfo);
iImapCompound->StartOperation(iStatus, *iSession);
SetActive();
}
CleanupStack::PopAndDestroy(selection);
return EFalse; // If not active, will re-loop.
}
case EFinished:
{
__LOG_TEXT(iSession->LogId(), "CImapCompoundSyncFolder::Completing OK");
iProgressState = TImap4GenericProgress::EIdle;
iSyncProgressState = TImap4SyncProgress::EIdle;
iSyncFolder = NULL;
Complete(KErrNone);
return ETrue;
}
default:
{
__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::ESyncFolderCompoundUnexpectedState));
// unexpected state - complete the request
iProgressState = TImap4GenericProgress::EIdle;
iSyncProgressState = TImap4SyncProgress::EIdle;
return ETrue;
}
} // end of switch (iState)
return EFalse;
}
/**
May be called in case of a genuine cancel or a cancel for migrate.
Following a genuine cancel, the compound operation will be deleted.
If a second stage sync/auto fetch is in progress, this is cancelled
and the iImapCompound deleted. This will be re-created on resume,
using the download rules appropriate to the new bearer.
iNextState is updated here to ensure the operation is
correctly restarted.
In either case, CMsgActive::DoCancel() is called to complete the
user request with KErrCancel.
Note that if the default CMsgActive::DoComplete() is overridden,
then that must also be modified to handle either case described above.
*/
void CImapCompoundSyncFolder::DoCancel()
{
switch (iCurrentStep)
{
case ESelectSourceMailboxRW:
{
// Outstanding request on session.
// Note that although select operations are performed on a folder they
// actually pass our iStatus to the session, so that is why we cancel
// the session for them.
iNextStep = ESelectSourceMailboxRW;
iSession->Cancel();
break;
}
case ESyncFolder:
{
// outstanding request on folder
if (iSyncFolder != NULL)
{
iSyncFolder->Cancel();
}
iNextStep = ESelectSourceMailboxRW;
break;
}
case ESyncFolderAutoFetch:
{
if (iImapCompound)
{
iImapCompound->Cancel();
delete iImapCompound;
iImapCompound = NULL;
}
// resume the autofetch with new bearer's download rules on reconnect.
iNextStep = ESyncFolderAutoFetch;
break;
}
case EFinished:
{
// self-completed or no outstanding request.
iNextStep = EFinished;
break;
}
case ESuspendedForMigrate:
default:
{
__ASSERT_DEBUG(EFalse, TImapServerPanic::ImapPanic(TImapServerPanic::ESyncFolderCompoundCancelUnexpectedState));
iNextStep = EFinished;
break;
}
} // end of switch (iCurrentStep)
if (!iCancelForMigrate)
{
// genuine cancel - update progress
iProgressErrorCode = KErrCancel;
}
CMsgActive::DoCancel();
}
void CImapCompoundSyncFolder::Progress(TImap4CompoundProgress& aCompoundProgress)
{
aCompoundProgress.iGenericProgress.iOperation = TImap4GenericProgress::ESync;
aCompoundProgress.iGenericProgress.iState = iProgressState;
//if currently syncing then get the latest progress
if((iSyncProgressState!=TImap4SyncProgress::EIdle) && (iSyncFolder != NULL))
{
iSyncFolder->Progress(aCompoundProgress.iSyncProgress);
}
aCompoundProgress.iSyncProgress.iState = iSyncProgressState;
// Put error into progress buffer
if( aCompoundProgress.iGenericProgress.iErrorCode == KErrNone )
{
aCompoundProgress.iGenericProgress.iErrorCode = iProgressErrorCode;
}
}
/**
Handles NO/BAD responses according to current step.
Negative server responses are not fatal - the error is saved in
the message currently being operated on and the state machine pushed
on to process the next message in the requested selection.
@return KErrNone if the error has been handled
Completion error code otherwise.
*/
TInt CImapCompoundSyncFolder::ProcessNegativeServerResponse()
{
TInt err = iStatus.Int();
switch (iCurrentStep)
{
case ESelectSourceMailboxRW:
{
if (err == KErrImapNo)
{
err = KErrNotFound;
iNextStep = EFinished;
}
break;
}
case ESyncFolder:
case ESyncFolderAutoFetch:
{
// Just store the error code in the progress response.
break;
}
case ESuspendedForMigrate:
case EFinished:
default:
{
// positive error code not expected,
// self-completed states or no outstanding request.
TImapServerPanic::ImapPanic(TImapServerPanic::ESyncFolderCompoundUnexpectedState);
break;
}
} // end of switch (iCurrentStep)
iProgressErrorCode = err;
return KErrNone;
}
/**
Called when operation has completed and we are about to complete the caller.
@param aErr Error code that we will complete with.
*/
void CImapCompoundSyncFolder::DoComplete(TInt& aErr)
{
// call base class for logging
CImapCompoundBase::DoComplete(aErr);
// Reset the flags which show if the new flags should be cleared on the
// next sync.
if (!iCancelForMigrate)
{
iSyncManager.ResetInboxClearNewFlags();
iSyncManager.ResetNonInboxClearNewFlags();
}
}
/**
Resumes the operation following a migration.
*/
void CImapCompoundSyncFolder::ResumeOperationL(TRequestStatus& aStatus, CImapSession& aSession)
{
iSession = &aSession;
__LOG_TEXT(iSession->LogId(), "CImapCompoundSyncFolder::Resuming");
__ASSERT_DEBUG(iCurrentStep==ESuspendedForMigrate, TImapServerPanic::ImapPanic(TImapServerPanic::ESyncFolderCompoundUnexpectedState));
iStopForMigrate = EFalse;
Queue(aStatus);
CompleteSelf();
}
/**
Indicates that the compound operation should complete as soon as it is possible
for the operation to be re-started without requiring a significant amount of
repeated communication.
The operation will be restarted by a call to ResumeOperationL()
Overrides the base-class implementation.
*/
void CImapCompoundSyncFolder::StopForMigrate()
{
__LOG_TEXT(iSession->LogId(), "CImapCompoundSyncFolder::StopForMigrate()");
if (iCurrentStep==ESyncFolderAutoFetch && iImapCompound)
{
// if doing a download-rules based fetch, instruct it to stop.
iImapCompound->StopForMigrate();
}
iStopForMigrate = ETrue;
}