--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/phonebookengines/contactsmodel/cntsrv/inc/CCntRequest.h Tue Feb 02 10:12:17 2010 +0200
@@ -0,0 +1,796 @@
+/**
+* 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.
+*/
+class CReqDiskSpaceLow : public CReqInternal
+ {
+public:
+ static CReqDiskSpaceLow* NewLC();
+ inline ~CReqDiskSpaceLow();
+ TAccept VisitStateL(CState& aState);
+
+private:
+ inline CReqDiskSpaceLow();
+ };
+
+
+/** Normal (i.e. not low) disk space request.
+*/
+class CReqDiskSpaceNormal : public CReqInternal
+ {
+public:
+ static CReqDiskSpaceNormal* NewLC();
+ inline ~CReqDiskSpaceNormal();
+ TAccept VisitStateL(CState& aState);
+
+private:
+ inline CReqDiskSpaceNormal();
+ };
+
+
+/** Async activity requests.*/
+
+
+/** Indicate async activity request.
+*/
+class CReqAsyncActivity : public CCntRequest
+ {
+public:
+ static CReqAsyncActivity* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);
+ TAccept VisitStateL(CState& aState);
+
+private:
+ CReqAsyncActivity(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);
+ };
+
+
+/** Indicate no async activity request.
+*/
+class CReqNoAsyncActivity : public CCntRequest
+ {
+public:
+ static CReqNoAsyncActivity* NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);
+ TAccept VisitStateL(CState& aState);
+
+private:
+ CReqNoAsyncActivity(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut);
+ };
+
+
+/* The CReqInternalSessionUnlock is created when a session closes. Any locked contact
+ items that the session left locked are removed by this internal request.
+ The CReqInternalSessionUnlock is called from the session destructor
+*/
+class CReqInternalSessionUnlock : public CReqInternal
+ {
+public:
+ static CReqInternalSessionUnlock* NewLC(TInt aSessionId);
+ TAccept VisitStateL(CState& aState);
+ inline ~CReqInternalSessionUnlock();
+
+private:
+ inline CReqInternalSessionUnlock(TInt aSessionId);
+ };
+
+/* Open a file asyncronously - this one is used within the server,
+ so it does not need to hold a RMessage to Complete().
+*/
+class CReqInternalAsyncOpen : public CReqAsyncOpen
+ {
+public:
+ static CReqInternalAsyncOpen* NewLC(const TUint aSessionId, const TDesC& aFileName, TRequestStatus& aStatus);
+
+ // Override these methods so that they do not refer to iMessage which does
+ // not exist for this internal request.
+ void Complete(TInt aErrorCode = KErrNone);
+
+private:
+ CReqInternalAsyncOpen(const TUint aSessionId, const TDesC& aFileName, TRequestStatus& aStatus);
+ void ConstructL();
+
+private:
+ TRequestStatus* iStatus;
+ };
+
+// Stop opening the database - this version is used internal to the server
+class CReqCancelInternalAsyncOpen : public CReqCancelAsyncOpen
+ {
+public:
+ static CReqCancelInternalAsyncOpen* NewLC(const TUint aSessionId);
+
+ // Override these methods so that they do not refer to iMessage which does
+ // not exist for this internal request.
+ void Complete(TInt aErrorCode = KErrNone);
+
+private:
+ inline CReqCancelInternalAsyncOpen(const TUint aSessionId);
+ };
+
+
+
+/**
+ Store for deferred requests, which could not be processed by the state machine.
+*/
+class CRequestStore : public CBase, public MActiveLoopCallBack
+ {
+public:
+ static CRequestStore* NewL(CCntStateMachine& aStateMachine);
+ ~CRequestStore();
+ void AppendL (CCntRequest* aRequest);
+ TBool IsEmpty ();
+ void ActivateRequestsL();
+ TBool DoStepL();
+ void DoError(TInt aError);
+ void RemoveD(CCntRequest* aRequest);
+
+private:
+ CRequestStore(CCntStateMachine& aStateMachine);
+ CCntRequest* Request();
+
+private:
+ CCntStateMachine& iStateMachine;
+ RPointerArray<CCntRequest> iStore;
+ CActiveLoop* iActive;
+ CCntRequest* iCurrentRequest;
+ TInt iNoOfRequests;
+ };
+
+
+
+
+inline const TUint CCntRequest::SessionId()
+ {
+ return iSessionId;
+ }
+
+
+inline const TInt CCntRequest::TimeOut()
+ {
+ return iTimeOut;
+ }
+
+
+/**
+ This base constructor is used by derived request classes that represent requests
+ originating outside the server - from the client session
+*/
+inline CCntRequest::CCntRequest(const TUint aSessionId):iSessionId(aSessionId), iTimeOut(0)
+ {
+ }
+
+/**
+ This base constructor is used by derived request class that represent requests
+ originating FROM WITHIN the server
+*/
+inline CCntRequest::CCntRequest():iSessionId(0), iTimeOut(0)
+ {
+ }
+
+/**
+ The constructor for the parent class of all requests originating within the server
+*/
+inline CReqInternal::CReqInternal()
+ {
+ };
+
+inline CReqInternal::CReqInternal(const TUint aSessionId) :
+ CCntRequest(aSessionId)
+ {
+ };
+
+inline CReqInternal::~CReqInternal()
+ {
+ };
+
+inline CContactItem& CReqUpdate::Item()
+ {
+ return *iCntItem;
+ }
+
+/**
+ Get the contact ID
+*/
+inline TContactItemId CReqRead::CntItemId() const
+ {
+ return iMessage.Int2();
+ }
+
+inline TContactItemId CReqDeleteCnt::CntItemId()const
+ {
+ return iMessage.Int0();
+ }
+
+inline TCntSendEventAction CReqDeleteCnt::NotificationEventAction() const
+ {
+ return static_cast<TCntSendEventAction>(iMessage.Int1());
+ }
+
+inline TContactItemId CReqCloseCnt::CntItemId()const
+ {
+ return iMessage.Int0();
+ }
+
+/**
+ Get the Contact Item
+*/
+inline CContactItem& CReqCreateCnt::Item() const
+ {
+ return *iCntItem;
+ }
+
+inline CReqBackupRestoreBegin::CReqBackupRestoreBegin()
+ {
+ }
+
+inline CReqBackupRestoreEnd::CReqBackupRestoreEnd()
+ {
+ }
+
+inline CReqDiskSpaceLow::CReqDiskSpaceLow()
+ {
+ }
+
+inline CReqDiskSpaceNormal::CReqDiskSpaceNormal()
+ {
+ }
+
+inline CReqInternalSessionUnlock::~CReqInternalSessionUnlock()
+ {
+ }
+
+inline CReqInternalSessionUnlock::CReqInternalSessionUnlock(TInt aSessionId) : CReqInternal (aSessionId)
+ {
+ }
+
+inline CReqDiskSpaceNormal::~CReqDiskSpaceNormal()
+ {
+ }
+
+inline CReqDiskSpaceLow::~CReqDiskSpaceLow()
+ {
+ }
+
+inline CReqBackupRestoreEnd::~CReqBackupRestoreEnd()
+ {
+ }
+
+inline CReqBackupRestoreBegin::~CReqBackupRestoreBegin()
+ {
+ }
+
+inline CReqAsyncOpen::CReqAsyncOpen(const TUint aSessionId) : CCntRequest(aSessionId)
+ {
+ }
+
+inline CReqCancelAsyncOpen::CReqCancelAsyncOpen(const TUint aSessionId) : CCntRequest(aSessionId)
+ {
+ }
+
+inline CReqCancelInternalAsyncOpen::CReqCancelInternalAsyncOpen(const TUint aSessionId) : CReqCancelAsyncOpen(aSessionId)
+ {
+ }
+
+#endif //CCNTREQUEST_H