diff -r 000000000000 -r 876b1a06bc25 plugins/contacts/symbian/contactsmodel/cntsrv/src/ccntrequest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/plugins/contacts/symbian/contactsmodel/cntsrv/src/ccntrequest.cpp Wed Aug 25 15:49:42 2010 +0300 @@ -0,0 +1,1198 @@ +/* +* 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: +* +*/ + + +/** + @file + @internalTechnology + @released +*/ + +#include "ccntrequest.h" +#include "ccntstatemachine.h" +#include "ccntpackager.h" +#include + +// CCntRequest +// CCntRequest is the base class for all Request classes that handle external +// requests (requests that originate from the CContactDatabase). Internal requests +// derive from the CReqInternal class. +// Note 1: All unpacking of objects should be done within Construction. +// Note 2: The destruction of request objects is a little unusual. +// The destruction of requests objects is usually the responsibility of the CStatemachine or in the CRequestStore class. +// The destruction of requests is usually performed using the CCntRequest::CompletePD method. See below +// Note 3: Each request has a timeout member - the time for which the request remains valid - and a timeouterror member variable. +// The iTimeOutError is the error that will be returned to the client in the event of the request timing out. The default +// timeout value is KErrNotReady but the CStateMachine can reset this depending on the last action the statemachine attempted +// to perform before the request timedout. +// Timeouts work as follows - the statemachine returns TDeferred indicating it could not process the request in the current state +// The request is added to the request store, CRequestStore, and the timeout is activated via the CCntRequest::ActivateTimeOutL +// method. There are two possible outcomes: +// 1. The state changes, or a contact item is unlocked, and the request is activated and processed by the CStateMachine +// 2. The request times out, CCntRequestTimer::RunL is called and the request is completed with the iTimeOutError error code. + +/** + Base CCntRequest constructor + @param aSessionId The session from which the request originated + @param aMessage The RMessage from the client + @param aTimeOut The lenght of time in milliseconds for which the request remains valid +*/ + +CCntRequest::CCntRequest(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + :iMessage(aMessage), + iSessionId(aSessionId), + iTimeOut(aTimeOut), + iTimeOutError(KErrNotReady) + { + ASSERT(aSessionId); // Should never be NULL + // All internal requests do not have a session ID, such requests derive from the CReqInternal + // and NOT from CCntRequest. + } + +/** + Complete the requests internal iMessage + + @param aErrCode The error code with which the message will be completed +*/ +void CCntRequest::Complete(TInt aErrCode) + { + iMessage.Complete(aErrCode); + } + +CCntRequest::~CCntRequest() + { + delete iTimer; + } + +/** + Start the timeout + A timer is only ever added when it does not exist and a non-zero timeout value has + been specified, because the request may be activated, processed and deferred more than once. + The result of request processing could be to add the request to the request queue again. + + @param aReqStore When a times out, the timer access the store to complete the request with + a timeout error. + */ +void CCntRequest::ActivateTimeOutL(CRequestStore& aReqStore) + { + if ((iTimer == NULL) && (iTimeOut != 0)) + { + iTimer = CCntRequestTimer::NewL(*this, aReqStore); + iTimer->Start(); + } + } + +/** + Stop the timeout + */ +void CCntRequest::DeActivateTimeOut() + { + if (iTimer) + { + iTimer->Stop(); + } + + delete iTimer; + iTimer = NULL; + } + +/** + Set the timeout error code + Inorder to assure binary compatibility with the original Contacts Model, + which did not retry processing client requests, the error code - reason + why an request can not be processed - needs to be stored and returned to + to the client if a subsequest/retry to process the request fails. + For example if a contact item has been locked by one session, a request + to open the contact item by a second session should complete with KErrInUse + however if the server has been put into a transaction state by one session, + the seconds session request should complete with KErrNotReady + KErrNotReady is the default error timeout value set by the base state CState + it is also be set the CCntRequest constructor + + @param aError The error code with which the message will be completed if it times out + + */ +void CCntRequest::SetTimeOutError(TInt aError) + { + iTimeOutError = aError; + } + +/** + Get the timeout error code + @return The timeout error code +*/ +TInt CCntRequest::TimeOutError()const + { + return iTimeOutError; + } + + +/** + Does not complete a RMessage - Internal Request do not contain a RMessage + as they don't originate from the client. Do nothing. + @param aErrorCode Not used +*/ +void CReqInternal::Complete(TInt /* aErrorCode*/) + { + } + + +// Request Helper classes +// ----------------------- +// CCntRequestTimer +// CRequestStore + +/** + CCntRequestTimer constructor + CCntRequestTimer is an active object derived from CTimer + @param aRequest The request which will timeout + @param aReqStore The array that holds the deferred request + The request must be removed from the request store after + it is completed with an error code. +*/ +CCntRequestTimer* CCntRequestTimer::NewL(CCntRequest& aRequest, CRequestStore& aReqStore) + { + CCntRequestTimer* self = new (ELeave) CCntRequestTimer(aRequest, aReqStore); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + + +CCntRequestTimer::~CCntRequestTimer() + { + CTimer::Cancel(); + } + + +CCntRequestTimer::CCntRequestTimer(CCntRequest& aRequest, CRequestStore& aReqStore) + : CTimer(CActive::EPriorityIdle), + iRequest(aRequest), + iReqStore(aReqStore) + { + } + + +void CCntRequestTimer::ConstructL() + { + CTimer::ConstructL(); + CActiveScheduler::Add(this); + } + +void CCntRequestTimer::RunL() + { + // Complete the contact with the timeout error + iRequest.Complete(iRequest.TimeOutError()); + CTimer::Cancel(); + iReqStore.RemoveD(&iRequest); + } + +void CCntRequestTimer::Start() + { + CTimer::After(iRequest.TimeOut()); + } + +void CCntRequestTimer::Stop() + { + CTimer::Cancel(); + } + + + + +/** + Object are added when the session requests a Transaction to begin + but the database is already in a transaction state for another session + There can only ever handle one transaction request - no concurrency! + + @param aStateMachine The request store calls the statemachine to process the + request. +*/ +CRequestStore* CRequestStore::NewL(CCntStateMachine& aStateMachine) + { + CRequestStore* self = new (ELeave) CRequestStore(aStateMachine); + return self; + } + +CRequestStore::CRequestStore(CCntStateMachine& aStateMachine): + iStateMachine(aStateMachine) + { + } + +CRequestStore::~CRequestStore() + { + iStore.ResetAndDestroy(); + delete iActive; + } + +/** + Remove the request from the store and delete the request + + @param aRequest The request that should be removed from the store and deleted + The Request Store takes ownership of this object +*/ +void CRequestStore::RemoveD(CCntRequest* aRequest) + { + TInt index = iStore.Find(aRequest); + if (index > KErrNotFound) + { + iStore.Remove(index); + } + delete aRequest; + aRequest = NULL; + } + + +/** + Append a request to the request store + + @param aRequest The request that is to be appended to the store +*/ +void CRequestStore::AppendL(CCntRequest* aRequest) + { + // The heap is safe since the request is appended to the contained store. + // Pop as the stack will be out of sync when the statemachine processes + // the request. + User::LeaveIfError(iStore.Append(aRequest)); + } + +/** + Get the first request from the store + + @return The request a the beginning of the stores array + Ownership of the request is given to the calling method +*/ +CCntRequest* CRequestStore::Request() + { + CCntRequest* request = iStore[KFirstRequest]; + iStore.Remove(KFirstRequest); + + return request; // Return ownership + } + +/** + Is there requests in the store + + @return ETrue if there are no request, EFalse otherwise +*/ +TBool CRequestStore::IsEmpty() + { + if (iStore.Count() > 0) + return EFalse; + + return ETrue; + } + +/** + Activate the store. + The request store uses the CActiveLoop for callbacks on each iteration + of the CActiveLoop only one request is processed until all + requests have been processed. + */ +void CRequestStore::ActivateRequestsL() + { + if (!iActive) + { + iActive = CActiveLoop::NewL(); + } + + // Only process the requests in the store when it has been activated. + // Don't process any requests added to the store after it has been activated. + // Requests may be readded to the store & should not be processed twice + // in the same batch. + // The store may already have been activated. + if ((!iActive->IsActive()) && (iNoOfRequests == 0)) + { + iActive->Register(*this); + iNoOfRequests = iStore.Count(); + } + } + +/** + Process the next request in the store. + If the request has timed out return an error + otherwise process the request as normal. + + @ return ETrue if another step is required, EFalse if this is the last step + */ +TBool CRequestStore::DoStepL() + { + ASSERT(iCurrentRequest == NULL); + + iCurrentRequest = Request(); + iStateMachine.ProcessRequestL(iCurrentRequest); // ownership transferred + + // ProcessRequestL received ownership of the request, iCurrentRequest can be + // reset to NULL + iCurrentRequest = NULL; + + --iNoOfRequests; + + if (iNoOfRequests == 0) + { + return EFalse; // The store has tried to process all requests it holds + } + + return ETrue; + } + +/** + Error callback from the CActiveLoop class. + + @ param aError The error to complete the current request (the request that is + being processed) +*/ +void CRequestStore::DoError(TInt aError) + { + // there should always be a current request + ASSERT(iCurrentRequest); + if (iCurrentRequest) + { + iCurrentRequest->Complete(aError); + delete iCurrentRequest; + + iCurrentRequest = NULL; + } + } + + +/** + CReqAsyncOpen constructor + Request to open the database asyncronously + + @see CCntRequest constructor +*/ +CReqAsyncOpen* CReqAsyncOpen::NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + { + CReqAsyncOpen* self = new (ELeave) CReqAsyncOpen(aSessionId, aMessage, aTimeOut); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +CReqAsyncOpen::CReqAsyncOpen(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut ) +: CCntRequest(aSessionId, aMessage, aTimeOut) + { + } + +void CReqAsyncOpen::ConstructL() + { + iMessage.ReadL(0,iFilename); + } + +/** + Get the name of the file that is to be opened + The DBManager may change this name. If no name has been passed by the client + then the default is set by the manager + + @return The name of the file that should be opened +*/ +TDes& CReqAsyncOpen::FileName() + { + return iFilename; + } + +TAccept CReqAsyncOpen::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + +/** + CReqCloseTables constructor + Close the database tables + + @see CCntRequest constructor +*/ +CReqCloseTables* CReqCloseTables::NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + { + CReqCloseTables* self = new (ELeave) CReqCloseTables(aSessionId, aMessage, aTimeOut); + CleanupStack::PushL(self); + return self; + }; + +CReqCloseTables::CReqCloseTables(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + :CCntRequest(aSessionId, aMessage, aTimeOut) + { + } + + +TAccept CReqCloseTables::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + + +/** + CReqReOpen + Re Open the database + + @see CCntRequest constructor +*/ +CReqReOpen* CReqReOpen::NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + { + CReqReOpen* self = new (ELeave) CReqReOpen(aSessionId, aMessage, aTimeOut); + CleanupStack::PushL(self); + return self; + } + +CReqReOpen::CReqReOpen(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) +:CCntRequest(aSessionId, aMessage, aTimeOut) + { + } + +TAccept CReqReOpen::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + + +/** + CReqCancelAsyncOpen + Cancel an asyncronous open request + + @see CCntRequest constructor +*/ +CReqCancelAsyncOpen* CReqCancelAsyncOpen::NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + { + CReqCancelAsyncOpen* self = new (ELeave) CReqCancelAsyncOpen(aSessionId, aMessage, aTimeOut); + CleanupStack::PushL(self); + return self; + } + +CReqCancelAsyncOpen::CReqCancelAsyncOpen(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) +:CCntRequest(aSessionId, aMessage, aTimeOut) + { + } + +TAccept CReqCancelAsyncOpen::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + + + +/** + CReqUpdate + Parent Class for CReqUpdateCnt & CReqCommitCnt + + @see CCntRequest constructor +*/ +void CReqUpdate::ConstructL(CCntPackager& aPackager) + { + aPackager.SetBufferFromMessageL(iMessage); + iCntItem = aPackager.UnpackCntItemLC(); + CleanupStack::Pop(iCntItem); + } + +CReqUpdate::~CReqUpdate() + { + delete iCntItem; + } + +CReqUpdate::CReqUpdate(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) +:CCntRequest(aSessionId, aMessage, aTimeOut) + { + } + + + +/** CReqUpdateCnt constructor + Update a contact item - derived from CReqUpdate. Used in conjunction with CReqReadCnt. + Note: CReqCommitCnt is very similar to CReqUpdateCnt, but CReqCommitCnt is used with CReqOpenCnt + and locks the contact. CReqUpdateCnt does not perform locking. + + @see CCntRequest constructor +*/ +CReqUpdateCnt* CReqUpdateCnt::NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut, CCntPackager& aPackager) + { + CReqUpdateCnt* self = new (ELeave) CReqUpdateCnt(aSessionId, aMessage, aTimeOut); + CleanupStack::PushL(self); + self->ConstructL(aPackager); + return self; + } + +CReqUpdateCnt::CReqUpdateCnt(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) +:CReqUpdate(aSessionId, aMessage, aTimeOut) + { + } + +TAccept CReqUpdateCnt::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + + +/** + CReqSetSpeedDial constructor + Set a speed dial key + + @see CCntRequest constructor +*/ +CReqSetSpeedDial* CReqSetSpeedDial::NewLC( const TUint aSessionId, + const RMessage2& aMessage, + const TInt aTimeOut, + CContactItemViewDef& aItemViewDef, + CCntServerSpeedDialManager& aSpeedDialManager, + const CCntServerSpeedDialTable& aTable, + MIniFileManager& aIniFileManager) + { + CReqSetSpeedDial* self = new (ELeave) CReqSetSpeedDial( aSessionId, + aMessage, + aTimeOut, + aItemViewDef, + aSpeedDialManager, + aTable, + aIniFileManager); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +CReqSetSpeedDial::CReqSetSpeedDial( const TUint aSessionId, + const RMessage2& aMessage, + const TInt aTimeOut, + CContactItemViewDef& aItemViewDef, + CCntServerSpeedDialManager& aSpeedDialManager, + const CCntServerSpeedDialTable& aTable, + MIniFileManager& aIniFileManager) +:CCntRequest(aSessionId, aMessage, aTimeOut), iItemViewDef(&aItemViewDef), iSpeedDialManager(aSpeedDialManager), iTable(aTable), iIniFileManager(aIniFileManager) + { + } + +void CReqSetSpeedDial::ConstructL() + { + // Read the message + // Read position + iSpeedDialIndex = iMessage.Int0(); + // Read contact id + iContactId = static_cast (iMessage.Int1()); + // Read Field Index + iTheFieldIndex = iMessage.Int2(); + } + +TAccept CReqSetSpeedDial::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + +TInt CReqSetSpeedDial::SpeedDialIndex() + { + return iSpeedDialIndex; + } + +TContactItemId CReqSetSpeedDial::TheContactId() + { + return iContactId; + } + +TInt CReqSetSpeedDial::TheFieldIndex() + { + return iTheFieldIndex; + } + +const CContactItemViewDef& CReqSetSpeedDial::ItemViewDef() + { + return *iItemViewDef; + } + +CCntServerSpeedDialManager& CReqSetSpeedDial::SpeedDialManager() + { + return iSpeedDialManager; + } + +const CCntServerSpeedDialTable& CReqSetSpeedDial::SpeedDialTable() + { + return iTable; + } + +MIniFileManager& CReqSetSpeedDial::IniFileManager() + { + return iIniFileManager; + } + +/** + CReqSetOwnCard constructor + Set the own card + + @see CCntRequest constructor +*/ +CReqSetOwnCard* CReqSetOwnCard::NewLC( const TUint aSessionId, + const RMessage2& aMessage, + const TInt aTimeOut, + CCntPackager& aPackager, + CContactItemViewDef& aItemViewDef, + MIniFileManager& aIniFileManager) + { + CReqSetOwnCard* self = new (ELeave) CReqSetOwnCard( aSessionId, + aMessage, + aTimeOut, + aItemViewDef, + aIniFileManager); + CleanupStack::PushL(self); + self->ConstructL(aPackager); + return self; + } + +CReqSetOwnCard::CReqSetOwnCard( const TUint aSessionId, + const RMessage2& aMessage, + const TInt aTimeOut, + CContactItemViewDef& aItemViewDef, + MIniFileManager& aIniFileManager) +:CReqUpdate(aSessionId, aMessage, aTimeOut), iItemViewDef(&aItemViewDef), iIniFileManager(aIniFileManager) + { + } + + + +TAccept CReqSetOwnCard::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + +TContactItemId CReqSetOwnCard::TheContactId() + { + return iContactId; + } + +const CContactItemViewDef& CReqSetOwnCard::ItemViewDef() + { + return *iItemViewDef; + } + + +MIniFileManager& CReqSetOwnCard::IniFileManager() + { + return iIniFileManager; + } + +/** + CReqCommitCnt constructor + Commit a contact item - used in conjunction with CReqOpenCnt + Derived from CReqUpdate, and is very similar to CReqUpdateCnt but also locks the contact item + so no other session can modify it. + + @see CCntRequest constructor +*/ +CReqCommitCnt* CReqCommitCnt::NewLC(const TUint aSessionId, + const RMessage2& aMessage, + const TInt aTimeOut, + CCntPackager& aPackager) + { + CReqCommitCnt* self = new (ELeave) CReqCommitCnt(aSessionId, aMessage, aTimeOut); + CleanupStack::PushL(self); + self->ConstructL(aPackager); + return self; + } + +CReqCommitCnt::CReqCommitCnt(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) +:CReqUpdate(aSessionId, aMessage, aTimeOut) + { + } + +TAccept CReqCommitCnt::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + + + + + +/** CReqRead constructor + Parent class of CReqReadCnt & CReqOpenCnt + CReqOpenCnt and CReqReadCnt are very similar + CReqOpenCnt results in the contact item being locked by the session, so no other session + can modify the contact item. + CReqReadCnt results in no locking. + Note: The CRequest::CompleteL method is overridden in this class + + @see CCntRequest constructor +*/ +CReqRead::CReqRead(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut, CCntPackager& aPackager, CContactItemViewDef& aItemViewDef) + :CCntRequest(aSessionId, aMessage, aTimeOut), + iPackager(aPackager), + iItemViewDef(&aItemViewDef), + iViewDefCreated(EFalse) + { + } + +void CReqRead::ConstructL() + { + if (iMessage.Int3()) + { + iPackager.SetBufferFromMessageL(iMessage); + iItemViewDef = iPackager.UnpackCntItemViewDefLC(); + iViewDefCreated = ETrue; + iPackager.Clear(); + CleanupStack::Pop(iItemViewDef); + } + } + +CReqRead::~CReqRead() + { + if (iViewDefCreated) // Required - determine CntItemViewdef was extracted from iMessage + { // encapsulates ItemViewDef nicely. + delete iItemViewDef; + } + } + +const CContactItemViewDef& CReqRead::ItemViewDef() + { + return *iItemViewDef; + } + +/** Overridden CompleteL method + Completes the request item by packing the contact item into the RMessage slot + and returning it to the client + + @param aCntItem The contact item that is returned to the client. +*/ +void CReqRead::CompleteL(const CContactItem& aCntItem) + { + TInt size(0); + TPtr8 cntItemBuff = iPackager.PackL(aCntItem, size); + // Write data if client buffer is large enough + // otherwise return the required buffer size. + if(iMessage.GetDesMaxLength(1) >= size) + { + iMessage.WriteL(1, cntItemBuff); + Complete(KErrNone); + } + else + { + Complete(size); + } + } + + +/** CReqOpenCnt constructor + Open a Contact Item - derived from CReqRead. + Very similar to CReqReadCnt but also results in the contact item being locked + + @see CReqRead constructor +*/ +CReqOpenCnt* CReqOpenCnt::NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut, CCntPackager& aPackager, CContactItemViewDef& aItemViewDef) + { + CReqOpenCnt* self = new (ELeave) CReqOpenCnt(aSessionId, aMessage, aTimeOut, aPackager, aItemViewDef); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +CReqOpenCnt::CReqOpenCnt(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut, CCntPackager& aPackager, CContactItemViewDef& aItemViewDef) + :CReqRead(aSessionId, aMessage, aTimeOut, aPackager, aItemViewDef) + { + } + +CReqOpenCnt::~CReqOpenCnt() + { + } + + +TAccept CReqOpenCnt::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + + +/** + CReqReadCnt constructor + Read a contact item - derived from CReqRead + Very similar to CReqOpenCnt but does not result in locking the contact item + + @see CReqRead constructor + +*/ +CReqReadCnt* CReqReadCnt::NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut, CCntPackager& aPackager, CContactItemViewDef& aItemViewDef) + { + CReqReadCnt* self = new (ELeave) CReqReadCnt(aSessionId, aMessage, aTimeOut, aPackager, aItemViewDef); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +CReqReadCnt::CReqReadCnt(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut, CCntPackager& aPackager, CContactItemViewDef& aItemViewDef) + :CReqRead(aSessionId, aMessage, aTimeOut, aPackager, aItemViewDef) + { + } + +CReqReadCnt::~CReqReadCnt() + { + } + + +TAccept CReqReadCnt::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + + + +/** + CReqDeleteCnt constructor + Delete a contact Item + + @see CCntRequest constructor +*/ +CReqDeleteCnt* CReqDeleteCnt::NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + { + CReqDeleteCnt* self = new (ELeave) CReqDeleteCnt(aSessionId, aMessage, aTimeOut); + CleanupStack::PushL(self); + return self; + } + +CReqDeleteCnt::CReqDeleteCnt(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) +:CCntRequest(aSessionId, aMessage, aTimeOut) + { + } + +CReqDeleteCnt::~CReqDeleteCnt() + { + } + +TAccept CReqDeleteCnt::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + + + + +/** CReqCloseCnt + Close a contact Item - Used in conjunction with CReqOpenCnt to remove the lock on the contact item + without committing. + + @see CCntRequest constructor +*/ +CReqCloseCnt* CReqCloseCnt::NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + { + CReqCloseCnt* self = new (ELeave) CReqCloseCnt(aSessionId, aMessage, aTimeOut); + CleanupStack::PushL(self); + return self; + } + +CReqCloseCnt::CReqCloseCnt(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) +:CCntRequest(aSessionId, aMessage, aTimeOut) + { + } + +CReqCloseCnt::~CReqCloseCnt() + { + } + +TAccept CReqCloseCnt::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + +/** + CReqCreateCnt constructor + Create a contact item, this request is completed with the new contact item id or an error code. + + @see CCntRequest constructor +*/ +CReqCreateCnt* CReqCreateCnt::NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut, CCntPackager& aPackager) + { + CReqCreateCnt* self = new (ELeave) CReqCreateCnt(aSessionId, aMessage, aTimeOut); + CleanupStack::PushL(self); + self->ConstructL(aPackager); + return self; + } + +CReqCreateCnt::CReqCreateCnt(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) +:CCntRequest(aSessionId, aMessage, aTimeOut) + { + } + +CReqCreateCnt::~CReqCreateCnt() + { + delete iCntItem; + } + +TAccept CReqCreateCnt::VisitStateL(CState& aState) + { + #if defined(__PROFILE_DEBUG__) + RDebug::Print(_L("[CNTMODEL] MTD: CCntStateMachine::ProcessRequestL")); + #endif + + return aState.AcceptRequestL(this); + } + +void CReqCreateCnt::ConstructL(CCntPackager& aPackager) + { + aPackager.SetBufferFromMessageL(iMessage); + iCntItem = aPackager.UnpackCntItemLC(); + CleanupStack::Pop(iCntItem); + } + + + + +///////////////// Database Transactin Request Class implemenations //////////// + + +/** + CReqDbBeginTrans constructor + Request to begin a transaction - moves the state machine into a transaction state + + @see CCntRequest constructor +*/ +CReqDbBeginTrans* CReqDbBeginTrans::NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + { + CReqDbBeginTrans* self = new (ELeave) CReqDbBeginTrans(aSessionId, aMessage, aTimeOut); + CleanupStack::PushL(self); + return self; + } + +TAccept CReqDbBeginTrans::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + + + +CReqDbBeginTrans::CReqDbBeginTrans(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + :CCntRequest(aSessionId, aMessage, aTimeOut) + { + } + +/** + CReqDbCommitTrans constructor + Request to Commit a transaction + Moves the database out of a transaction state and (usually) into a writable state + + @see CCntRequest constructor + */ +CReqDbCommitTrans* CReqDbCommitTrans::NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + { + CReqDbCommitTrans* self = new (ELeave) CReqDbCommitTrans(aSessionId, aMessage, aTimeOut); + CleanupStack::PushL(self); + return self; + } + +TAccept CReqDbCommitTrans::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + +CReqDbCommitTrans::CReqDbCommitTrans(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + :CCntRequest(aSessionId, aMessage, aTimeOut) + + { + } + + +/** + CReqDbRollbackTrans constructor + Request to Rollback a transaction - results in a database recovery + so it closes and re-opens the database if it has been damaged + + @see CCntRequest constructor +*/ +CReqDbRollbackTrans* CReqDbRollbackTrans::NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + { + CReqDbRollbackTrans* self = new (ELeave) CReqDbRollbackTrans(aSessionId, aMessage, aTimeOut); + CleanupStack::PushL(self); + return self; + } + +TAccept CReqDbRollbackTrans::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + +CReqDbRollbackTrans::CReqDbRollbackTrans(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + :CCntRequest(aSessionId, aMessage, aTimeOut) + { + } + + +/** + CReqBackupRestoreBegin constructor + Notifys the state machine that a backup/restore is beginning + + @see CCntRequest constructor +*/ +CReqBackupRestoreBegin* CReqBackupRestoreBegin::NewLC() + { + CReqBackupRestoreBegin* self = new (ELeave) CReqBackupRestoreBegin(); + CleanupStack::PushL(self); + return self; + } + +TAccept CReqBackupRestoreBegin::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + +/** + CReqBackupRestoreEnd constructor + Notifys the state machine that a restore has ended + + @see CCntRequest constructor + */ +CReqBackupRestoreEnd* CReqBackupRestoreEnd::NewLC() + { + CReqBackupRestoreEnd* self = new (ELeave) CReqBackupRestoreEnd(); + CleanupStack::PushL(self); + return self; + } + +TAccept CReqBackupRestoreEnd::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + + +/** + CReqDiskSpaceLow constructor + @see CCntRequest constructor + */ +CReqDiskSpaceLow* CReqDiskSpaceLow::NewLC() + { + CReqDiskSpaceLow* self = new (ELeave) CReqDiskSpaceLow(); + CleanupStack::PushL(self); + return self; + } + +TAccept CReqDiskSpaceLow::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + + +/** + CReqDiskSpaceNormal constructor + @see CCntRequest constructor +*/ +CReqDiskSpaceNormal* CReqDiskSpaceNormal::NewLC() + { + CReqDiskSpaceNormal* self = new (ELeave) CReqDiskSpaceNormal(); + CleanupStack::PushL(self); + return self; + } + +TAccept CReqDiskSpaceNormal::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + + +/** + CReqAsyncActivity constructor + @see CCntRequest constructor + */ +CReqAsyncActivity* CReqAsyncActivity::NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + { + CReqAsyncActivity* self = new (ELeave) CReqAsyncActivity(aSessionId, aMessage, aTimeOut); + CleanupStack::PushL(self); + return self; + } + +CReqAsyncActivity::CReqAsyncActivity(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut ) +: CCntRequest(aSessionId, aMessage, aTimeOut) + { + } + +TAccept CReqAsyncActivity::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + + +/** + CReqNoAsyncActivity constructor + @see CCntRequest constructor +*/ +CReqNoAsyncActivity* CReqNoAsyncActivity::NewLC(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut) + { + CReqNoAsyncActivity* self = new (ELeave) CReqNoAsyncActivity(aSessionId, aMessage, aTimeOut); + CleanupStack::PushL(self); + return self; + } + +CReqNoAsyncActivity::CReqNoAsyncActivity(const TUint aSessionId, const RMessage2& aMessage, const TInt aTimeOut ) +: CCntRequest(aSessionId, aMessage, aTimeOut) + { + } + +TAccept CReqNoAsyncActivity::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + +/** + CReqInternalSessionUnlock constructor + CReqInternalSessionUnlock unlocks all remaining locked contact items when + a session closes. It is called from the session class destructor + + @see CCntReqInternal constructor +*/ +CReqInternalSessionUnlock* CReqInternalSessionUnlock::NewLC(TInt aSessionId) + { + CReqInternalSessionUnlock* self = new (ELeave) CReqInternalSessionUnlock(aSessionId); + CleanupStack::PushL(self); + return self; + } + +TAccept CReqInternalSessionUnlock::VisitStateL(CState& aState) + { + return aState.AcceptRequestL(this); + } + + +/////////////////////////CReqInternalAsyncOpen //////////////////// +// Similar to CReqAsyncOpen but the request originates from inside the server. +CReqInternalAsyncOpen* CReqInternalAsyncOpen::NewLC(const TUint aSessionId, const TDesC& aFileName, TRequestStatus& aStatus) + { + CReqInternalAsyncOpen* self = new (ELeave) CReqInternalAsyncOpen(aSessionId, aFileName, aStatus); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +CReqInternalAsyncOpen::CReqInternalAsyncOpen(const TUint aSessionId, const TDesC& aFileName, TRequestStatus& aStatus) + : CReqAsyncOpen(aSessionId), iStatus(&aStatus) + { + iFilename = aFileName; + } + +void CReqInternalAsyncOpen::ConstructL() + { + *iStatus = KRequestPending; + } + +void CReqInternalAsyncOpen::Complete(TInt aErrorCode) + { + User::RequestComplete(iStatus, aErrorCode); + } + +/////////////////////////CReqCancelInternalAsyncOpen //////////////////// +// Similar to CReqCancelAsyncOpen but the request originates from inside the server, +// so there is no need to signal a RMessage that the request has completed +CReqCancelInternalAsyncOpen* CReqCancelInternalAsyncOpen::NewLC(const TUint aSessionId) + { + CReqCancelInternalAsyncOpen* self = new (ELeave) CReqCancelInternalAsyncOpen(aSessionId); + CleanupStack::PushL(self); + return self; + } + +void CReqCancelInternalAsyncOpen::Complete(TInt /*errorCode*/) + { + } +