// 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 <cntitem.h>

// 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)

	{

	}