// Copyright (c) 1997-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:
//

#ifndef __CONSYNC_H__
#define __CONSYNC_H__

#include <e32base.h>
#include <msvapi.h>

#include "ImapConnectCompletionStates.H"

class CClientMtmRegistry;
class CBaseMtm;
class CMtmUiRegistry;
class CBaseMtmUi;
class CImapConnectAndSyncOp;
class MMsvImapConnectionObserver;


class CProgressTimer : public CTimer
/**
@internalComponent
@released
*/
	{
public:
	static CProgressTimer* NewL(CImapConnectAndSyncOp& aOperation);

private:	// methods from CActive, via CTimer
	virtual void RunL();
	virtual TInt RunError(TInt /*aError*/);
private:
	CProgressTimer(CImapConnectAndSyncOp& aOperation);
private:
	CImapConnectAndSyncOp& iOperation;

	};

class CRefreshTimer : public CTimer
	{
public:
	static CRefreshTimer* NewL(CImapConnectAndSyncOp& aOperation);
private:	// methods from CActive, via CTimer
	virtual void RunL();
	virtual TInt RunError(TInt /*aError*/);
private:
	CRefreshTimer(CImapConnectAndSyncOp& aOperation);
private:
	CImapConnectAndSyncOp& iOperation;
	};


class CImapConnectAndSyncOp : public CMsvOperation, public MMsvEntryObserver
/**
	The CImapConnectAndSyncOp is an operation handles connection and 
	synchronisation to an IMAP account.

	The operation has three different completion stages. After connection has 
	occurred with the IMAP server, after the full sync has completed, or after 
	disconnecting from the IMAP server. With the last option the operation does 
	intermitent refreshes until connection timeout is exceeded. The sync is done
	as a background task.

	The refresh rate is set by the CImImap4Settings class. It is obtained from 
	the settings on creation of the object and that will persist for the lifetime
	of the object. The timeout value is provided by iMtmData1 component of the 
	IMAP service entry index. 

	NOTE - this value is obtained from the commdb by the server MTM.

	This class contains two timers - a refresh and a progress timer. The refresh
	timer is used to refresh the inbox as described earlier. The progress timer
	has two roles. Whilst the sync takes place the progress timer is fired every
	KImapDefaultProgressRate microseconds - this is currently set to approx 1sec.
	When fired it calls the ProgressL() function. This updates the state and the
	operation observer as necessary. Once the sync has completed the progress 
	timer acts as the timeout timer. If the timeout value is zero or negative 
	then no timeout actually occurs even though the timer is used.

	This class sets itself as an observer to the store entry for the IMAP service.
	It uses the notification of changes to the entry to push the state machine 
	through the sync states. These sync states are concerned with the first
	sync to the IMAP acconut and NOT any subsequent inbox refresh syncs. The 
	first sync is broken into three stages - syncing the inbox then the folder
	list and finally the folders themselves.

	The state machine starts in the NotStarted state. Here it invokes an async 
	command on the server MTM - KIMAP4MTMConnectAndSynchronise. The class sets
	itself active and moves to the Connecting state.

	In the Connecting state, the RunL() checks the completion criteria. If 
	completion is when the connection to the IMAP server is established then the
	observer is notified (completed) and the operation ends. The sync continues
	in the background. If the completion criteria is for the other options then 
	the state moves to the FirstSyncingUpdatingInbox state. The progress timer is
	reset. 

	NOTE - the class is SetActive() even though no async request has been made. 
	In order for the scheduler not to call its RunL() the iStatus is set to
	KRequestPending. This is done in order to make the operation appear as if it
	is not complete. Therefore care must be taken when changing code not to call
	SetActive() again.

	During the first sync to the IMAP account the state machine is driven by 
	calls to ProgressL(). This may be either by the progress timer or by the 
	owner/observer of this operation.

	In state FirstSyncingUpdatingInbox the sync progress is obtained from the 
	server MTM. If the progress has moved on from ESyncInbox then the state is
	changed to FirstSyncingUpdatingFolderList. The observer is notified and the 
	state machine moves onto handling this next state.

	In state FirstSyncingUpdatingFolderList the sync progress is again obtained
	from the server MTM. If the progress has moved on from ESyncFolderTree then
	the state is changed to FirstSyncingUpdatingFolders. The observer is notified
	and the state machine moves onto handling this next state.
	
	In state FirstSyncingUpdatingFolders the sync progress is again obtained
	from the server MTM. If the progress is not Idle then nothing happens. 
	Otherwise if the completion criteria is for after sync with the IMAP server
	then the state moves to CompletingSelf and the active object self-completes.
	This ensures that its RunL() is called asap. If the completion criteria is
	for when disconnection from the IMAP server occurs then the state moves to 
	Waiting and the refresh timer is started and the observer is notified.

	The behaviour in the Waiting state depends on which function has been called.
	In ProgressL() the progress timer changes its role to the idle timeoout timer.
	If the timeout time has not been set then it is set, although if the interval
	is zero or negative it cannot be set. If the timeout time has been set then
	a check is made to see if the current time has passed it. If so the class
	invokes the async function KIMAP4MTMDisconnect on the server MTM and the state
	moves to DisconnectingOnTimeout. The observer is notified. If the current time
	has not exceeded the timeout time or the timeout time has been set then the 
	progress timer is started - the value depending on whether a timeout time
	exists or not.

	When the refresh timer fires the DoRefreshInboxL() function is called. The state
	will be Waiting. If the server MTM is active then the refresh timer is re-started.
	If the server MTM is not active then the async function KIMAP4MTMInboxNewSync 
	is called and the state moves to the ForcedSyncing state.

	In the ForcedSyncing state the RunL() re-starts the refresh timer and the
	state is moved back to Waiting. 

	NOTE - the active object is SetActive() again as described before.

	In the DisconnectingOnTimeout state the RunL() completes the observer. The
	operation is finished and the final progress value is set to KErrTimeOut.

	In the CompletingSelf state the RunL() completes the observer. The operation
	is finished.

	@internalComponent
	@released
*/
	{
public:
	static CImapConnectAndSyncOp* NewL(
									  CMsvSession&						aSession, 
									  const CMsvEntrySelection&			aSelection, 
									  CBaseMtm& 						aBaseMtm, 
									  TInt 								aPriority, 
									  TRequestStatus&					aStatus, 
									  TImapConnectionCompletionState	aCompletionState, 
	                                  TInt                              aFunctionId,
									  MMsvImapConnectionObserver* 		aConnectionObserver=NULL
									  );

	virtual ~CImapConnectAndSyncOp();

	void DoRefreshInboxL();

public:	// methods from CMsvOperation

	virtual const TDesC8& ProgressL();
	
public:	// methods from MMsvEntryObserver

	void HandleEntryEventL(TMsvEntryEvent aEvent, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/);

private:	// methods from CActive

	virtual void RunL();
	virtual void DoCancel();
	virtual TInt RunError(TInt aError);

private:
	CImapConnectAndSyncOp(
						 CMsvSession& aSession,
						 const CMsvEntrySelection& aSelection,
						 CBaseMtm& aBaseMtm, 
						 TInt aPriority, 
						 TRequestStatus& aStatus, 
						 TImapConnectionCompletionState aCompletionState,
						 MMsvImapConnectionObserver* aConnectionObserver
						 );
	void ConstructL(const CMsvEntrySelection& aSelection, TInt aFunctionId);

	void Completed(TInt aError);
	TInt GetServiceProgress();
	void UpdateObserver() const;
	void ResetProgressTimer();
	void ResetRefreshTimer();

private:
	enum TImapConnState 
		{
		ENotStarted=0, 
		EConnecting, 
		EFirstSyncingUpdatingInbox,
		EFirstSyncingUpdatingFolderList,
		EFirstSyncingUpdatingFolders,
		EWaiting, 
		EForcedSyncing, 
		EDisconnectingOnTimeout, 
		ECompletingSelf,
		ECompleted
		};

	TImapConnState iState;
	CBaseMtm& iBaseMtm;
	CMsvOperation* iOperation;
	CMsvEntrySelection* iSelection;
	TPckgBuf<TImap4CompoundProgress> iProgress;
	TPckgBuf<TImap4SyncProgress> iSyncProgress;
	CRefreshTimer* 	iRefreshTimer;
	CProgressTimer* iProgressTimer;
	MMsvImapConnectionObserver*		iConnectionObserver;
	TBool 							iForcedCancel;
	TImapConnectionCompletionState	iCompletionState;
	CMsvEntry* iServiceEntry;
	
	//	Following member used for timeout and refresh functionality
	TBool				 	iTimeout;
	TTime				 	iTimeoutAt;
	TTimeIntervalSeconds	iIdleTimeout;
	TTimeIntervalSeconds	iRefreshRate;
	};

#endif	// __CONSYNC_H__