/*

* Copyright (c) 2005-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 __CCNTREQUEST_H__

#define __CCNTREQUEST_H__

#include <e32base.h>

#include <cntdb.h>

#include "cactiveloop.h"

enum TAccept		// TAccept is the return value for CState::AcceptRequestL methods

	{

	EProcessed = 0,	    // The State object has processed the request

	EDeferred,		    // The State object cannot processed the request at this moment and wish to defer processing

	EOwnershipPassed    // The State object has seized the request from its owner

	};

const TInt KFirstRequest = 0;

const TInt KOneSecond 	 = 1000000;

const TInt KSixtySeconds = 60000000;

class CState;

class CCntPackager;

class CContactItem;

class CCntStateMachine;

class CCntRequestTimer;

class CCntServerSpeedDialManager;

class CCntServerSpeedDialTable;

class MIniFileManager;

class CRequestStore;

/**

 These request classes are based on the Command Pattern

 All request class derive from the base class CCntRequest and implement

 a VisitStateL method. The VisitStateL method is called by the 

 CStateMachine class. When invoking the VisitStateL on a request object, 

 the CStateMachine provides the current active state class (a class derived from CState).

*/

class CCntRequest : public CBase

	{

public:

	// Complete the RMessage

	virtual void Complete(TInt aErrorCode = KErrNone);

	// Base declaration of the visitor pattern method.

	virtual TAccept VisitStateL(CState& aState) = 0; 

	virtual ~CCntRequest();

	inline const TUint SessionId();

	inline const TInt  TimeOut();

	// Request timeout methods - requests timeout when the 

	// statemachine is not able to process the request.

	void ActivateTimeOutL (CRequestStore& aReqStore);	

	void DeActivateTimeOut();	

	void SetTimeOutError  (TInt aError);

	TInt TimeOutError() const;

protected:

	CCntRequest(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	inline CCntRequest(const TUint aSessionId);

	inline CCntRequest();

protected:

	RMessage2 	iMessage;

	const TUint iSessionId;

private:

	// A request is only valid for a set period of time.

	// if not completed within this given time, the request object

	// should be completed and destroyed.

	const TInt  		iTimeOut;

	TInt				iTimeOutError;

	CCntRequestTimer*	iTimer;

	};

/**

   The CReqInternal class is the parent class for a group of special request classes.

   These classes are internal classes, they are NOT created in response to a Contact Model

   client proxy request. That is, classes derived from CReqInternal don't originate 

   in the Session. They contain neither a message nor a session ID.

*/

class CReqInternal : public CCntRequest

	{

public:

	// Override these methods so that they do not refer to iMessage which does

	// not exist for internal requests.

	void Complete(TInt aErrorCode = KErrNone);

protected:	

	~CReqInternal();

	CReqInternal();

	CReqInternal(const TUint aSessionId);

	};

/**

 When a request is deferred by the state machine it can only live for a give time

 The CCntRequestTimer monitors the life of a deferred request.

*/ 

class CCntRequestTimer : CTimer

	{

public:

	static CCntRequestTimer* NewL(CCntRequest& aRequest, CRequestStore& aReqStore);

	~CCntRequestTimer();

	void Start();

	void Stop ();

private:

	CCntRequestTimer(CCntRequest& aRequest, CRequestStore& aReqStore);

	void RunL();

	void ConstructL();

private:

	CCntRequest& iRequest;		

	// After a request timeout it must be removed from the request store

	// refer to note 3 in the CCntRequest.cpp

	CRequestStore& iReqStore; 

	};

/**

 Open a file asyncronously - syncronous open works in the same manner as

 async open and also result in this request being created.

*/ 

class CReqAsyncOpen : public CCntRequest

	{

public:	

	static CReqAsyncOpen* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	TAccept VisitStateL(CState& aState);

	// The FileManagerController can modify the filename 

	// - it is responsible for setting the default name

	TDes& FileName(); 

protected:

	inline CReqAsyncOpen(const TUint aSessionId);

private:

	CReqAsyncOpen(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	void ConstructL();

protected:

	TFileName iFilename;	

	};

/** Reopen the database file - Note that unlike the CReqAsyncOpen class the CReqReOpen does not contain

    a filename. Reopen opens the last opened file and does not have a filename. 

*/ 

class CReqReOpen : public CCntRequest

	{

public:	

	static CReqReOpen* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	TAccept VisitStateL(CState& aState);

private:

	CReqReOpen(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	};

/**

  Close the database tables

*/ 

class CReqCloseTables : public CCntRequest

	{

public:	

 	static CReqCloseTables* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

  	TAccept VisitStateL(CState& aState);

private:

  	CReqCloseTables(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

  	};

// Database Transaction Request Classes	

/**

 Request to begin a transaction	

*/ 

class CReqDbBeginTrans : public CCntRequest

	{

public:	

	static CReqDbBeginTrans* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	TAccept VisitStateL(CState& aState);

private:

	CReqDbBeginTrans (const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	};	

/**

 Request to Commit a transaction	

*/ 

class CReqDbCommitTrans : public CCntRequest

	{

public:	

	static CReqDbCommitTrans* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	TAccept VisitStateL(CState& aState);

private:

	CReqDbCommitTrans(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	};

/**

 Request to Rollback a transaction

*/ 

class CReqDbRollbackTrans : public CCntRequest

	{

public:	

	static CReqDbRollbackTrans* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	TAccept VisitStateL(CState& aState);

private:

	CReqDbRollbackTrans(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	};

/** 

 Parent Class for CReqUpdateCnt & CReqCommitCnt

*/

class CReqUpdate : public CCntRequest

	{

public:	

	TAccept VisitStateL(CState& aState) = 0;

	~CReqUpdate();

	inline CContactItem& Item();

protected:

	CReqUpdate(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	void ConstructL(CCntPackager& aPackager);

private:

	CContactItem* iCntItem;

	};

/** 

 Update a contact item - used in conjunction with Read

*/

class CReqUpdateCnt : public CReqUpdate

	{

public:	

	static CReqUpdateCnt* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut, CCntPackager& aPackager);

	TAccept VisitStateL(CState& aState);

	~CReqUpdateCnt(){};

private:

	CReqUpdateCnt(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	};

class CReqSetSpeedDial : public CCntRequest

	{

public:	

	static CReqSetSpeedDial* NewLC(	const TUint aSessionId, 

									const RMessage2& aMessage, 

									const TInt aTimeOut, 

									CContactItemViewDef& aItemViewDef,

									CCntServerSpeedDialManager& aSpeedDialManager,

									const CCntServerSpeedDialTable& aTable,

									MIniFileManager& aIniFileManager);

	TAccept VisitStateL(CState& aState);

	~CReqSetSpeedDial(){};

	const CContactItemViewDef& ItemViewDef();

	TInt SpeedDialIndex();

	TContactItemId TheContactId();

	TInt TheFieldIndex();

	CCntServerSpeedDialManager& SpeedDialManager();

	const CCntServerSpeedDialTable& SpeedDialTable();

	MIniFileManager& IniFileManager();

private:

	CReqSetSpeedDial(	const TUint aSessionId, 

						const RMessage2& aMessage, 

						const TInt aTimeOut, 

						CContactItemViewDef& aItemViewDef,

						CCntServerSpeedDialManager& aSpeedDialManager,

						const CCntServerSpeedDialTable& aTable,

						MIniFileManager& aIniFileManager);

	void ConstructL();

	CContactItemViewDef* iItemViewDef;

	TInt iSpeedDialIndex;

	TContactItemId iContactId;

	TInt iTheFieldIndex;

	CCntServerSpeedDialManager& iSpeedDialManager;

	const CCntServerSpeedDialTable& iTable;

	MIniFileManager& iIniFileManager;

	};

class CReqSetOwnCard : public CReqUpdate

	{

public:	

	static CReqSetOwnCard* NewLC(	const TUint aSessionId, 

									const RMessage2& aMessage, 

									const TInt aTimeOut, 

									CCntPackager& aPackager,

									CContactItemViewDef& aItemViewDef,

									MIniFileManager& aIniFileManager);

	TAccept VisitStateL(CState& aState);

	~CReqSetOwnCard(){};

	const CContactItemViewDef& ItemViewDef();

	TContactItemId TheContactId();

	MIniFileManager& IniFileManager();

private:

	CReqSetOwnCard(	const TUint aSessionId, 

						const RMessage2& aMessage, 

						const TInt aTimeOut, 

						CContactItemViewDef& aItemViewDef,

						MIniFileManager& aIniFileManager);

	CContactItemViewDef* iItemViewDef;

	TContactItemId iContactId;

	MIniFileManager& iIniFileManager;

	};

/**

 Commit a contact item - used in conjunction with Open

*/ 

class CReqCommitCnt : public CReqUpdate

	{

public:	

	static CReqCommitCnt* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut, CCntPackager& aPackager);

	TAccept VisitStateL(CState& aState);

	~CReqCommitCnt(){};

private:

	CReqCommitCnt(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	};

/**

 Parent Class for CReqOpenCnt & CReqReadCnt

*/ 

class CReqRead : public CCntRequest

	{

public:	

	TAccept VisitStateL(CState& aState) = 0;

	~CReqRead();

	const CContactItemViewDef& ItemViewDef();

	inline TContactItemId CntItemId() const;

	void CompleteL(const CContactItem& aCntItem);

protected:

	CReqRead(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut, CCntPackager& aPackager, CContactItemViewDef& aItemViewDef);

	void ConstructL();

private:

	CCntPackager& iPackager;

	CContactItemViewDef* iItemViewDef;

	TBool iViewDefCreated;

	};

/**

 Stop opening the database 

*/ 

class CReqCancelAsyncOpen : public CCntRequest

	{

public:

	static CReqCancelAsyncOpen* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	TAccept VisitStateL(CState& aState);

protected:

	inline CReqCancelAsyncOpen(const TUint aSessionId);

private:

	CReqCancelAsyncOpen(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	};

/**

 Open a contact item

*/ 

class CReqOpenCnt : public CReqRead

	{

public:	

	static CReqOpenCnt* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut, CCntPackager& aPackager, CContactItemViewDef& aItemViewDef);

	TAccept VisitStateL(CState& aState);

	~CReqOpenCnt();

private:

	CReqOpenCnt(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut, CCntPackager& aPackager, CContactItemViewDef& aItemViewDef);

	};

/** 

 Read a contact item

*/

class CReqReadCnt : public CReqRead

	{

public:	

	static  CReqReadCnt* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut, CCntPackager& aPackager, CContactItemViewDef& aItemViewDef);

	TAccept VisitStateL(CState& aState);

	~CReqReadCnt();

private:

	CReqReadCnt(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut, CCntPackager& aPackager, CContactItemViewDef& aItemViewDef);

	};

/**

 Delete a contact item

*/ 

class CReqDeleteCnt : public CCntRequest

	{

public:	

	static CReqDeleteCnt* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	TAccept VisitStateL(CState& aState);

	~CReqDeleteCnt();

	inline TContactItemId CntItemId() const;

	inline TCntSendEventAction NotificationEventAction() const;

private:

	CReqDeleteCnt(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	};

// Close a contact item - Used in conjunction with open

class CReqCloseCnt : public CCntRequest

	{

public:	

	static CReqCloseCnt* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	TAccept VisitStateL(CState& aState);

	~CReqCloseCnt();

	inline TContactItemId CntItemId()const;

private:

	CReqCloseCnt(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

	};

// Create a contact item

class CReqCreateCnt : public CCntRequest

	{

public:	

	static CReqCreateCnt* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut, CCntPackager& aPackager);

	TAccept VisitStateL(CState& aState);

	~CReqCreateCnt();

	inline CContactItem& Item() const;

private:

	void ConstructL(CCntPackager& aPackager);

	CReqCreateCnt(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);

private:

	CContactItem* iCntItem;

	};

/** Backup and Restore requests.*/

/** Backup/restore beginning request.

*/

class CReqBackupRestoreBegin : public CReqInternal

	{

public:	

	static CReqBackupRestoreBegin* NewLC();

	inline ~CReqBackupRestoreBegin();

	TAccept VisitStateL(CState& aState);

private:

	inline CReqBackupRestoreBegin();

	};

/** Backup or restore completed request.

*/

class CReqBackupRestoreEnd : public CReqInternal

	{

public:	

	static CReqBackupRestoreEnd* NewLC();

	inline ~CReqBackupRestoreEnd();

	TAccept VisitStateL(CState& aState);

private:

	inline CReqBackupRestoreEnd();

	};

/** Low disk space requests.*/

/** Low disk space request.

*/