// Copyright (c) 2006-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 "CCntStateMachine.h"

#include "CCntRequest.h"

#include "CCntDbManager.h"

#include "CCntBackupRestoreAgent.h"

#include "persistencelayer.h"

#include "CntSpeedDials.h"

#include <cntfldst.h> 		// for ccontacttextfield

#include <cntfield.h> 		// for ccontacttextfield

#include "CNTSTD.H"   		// for Panic codes

// Event related headers

#include <cntdbobs.h> 	    // for ccontactdbobserver

#include "CCntServer.h"     // for KCntNullConnectionId.

#include "CCntEventQueue.h" // for KMaxNumberOfEventsInEventQueue, KCntEventGranularity

#include "CCntLogger.h"  

// Require SQL header for leave code checking

#include <sqldb.h>

/** 

CState - Base state destructor, default implementataion

*/

CState::~CState() 

	{}

/**

 CState constructor. 

 The main purpose of the CState class is to define the state transition table.

 The CState class implements the most common state behaviour for each request object, 

 in the overridden AcceptRequestL method.

 Note there is no NewL method on the CState class. It is not meant to be instantiated.

 @param aStateMachine The statemachine object that is used for state transitions

 @param aPersistenceLayer The persistence layer that allows provides database access

*/	

CState::CState(CCntStateMachine& aStateMachine, CPersistenceLayer&	aPersistenceLayer)

:iStateMachine(aStateMachine), iPersistenceLayer(aPersistenceLayer)

	{}

/**

 TransactionStartLC is called from many derived states. The session that started the

 transaction is remembered in order to only allow that session perform database operations

 during the transaction. 

 Transaction rollback is pushed onto the clean up stack in case of a leave should occur before the

 transaction is committed. If the transaction can not be committed in full, then none of

 the transaction should be committed.

 @param aSessionId The unique ID of session that is moving the state machine into a transaction state.

*/

void CState::TransactionStartLC(TUint aSessionId)

	{

	iCurrentTransactionSessionId = aSessionId;

	iPersistenceLayer.FactoryL().GetCollectorL().Reset();

	iPersistenceLayer.TransactionManager().StartTransactionL();

	CleanupStack::PushL(TCleanupItem(CState::CleanupTransactionRollback, this));

	}

/** 

 Rollback a transaction after an leave has occured.

 None of the transaction is committed to the database

 @param aState The state in which the leave occured

*/

void CState::CleanupTransactionRollback(TAny* aState)

  	{

  	TRAP_IGNORE(static_cast<CState*>(aState)->RollbackTransAndRecoverL(EFalse));

  	}

/**

 Commit the current transaction.

*/

void CState::TransactionCommitLP()

	{

	iPersistenceLayer.TransactionManager().CommitCurrentTransactionL(iCurrentTransactionSessionId);

	iCurrentTransactionSessionId = 0;

	CleanupStack::Pop(); // CleanupTransactionRollback

	}

/**

 Clean up the transaction after a leave occurs. 

*/

void CState::RollbackTransAndRecoverL(const TBool aNotification)

	{

  	// Some operation has left before a commit could be called.

  	iPersistenceLayer.TransactionManager().RollbackCurrentTransactionL(iCurrentTransactionSessionId);

	iCurrentTransactionSessionId = 0;

	iPersistenceLayer.ContactsFileL().CloseTablesL(!aNotification);

	iPersistenceLayer.ContactsFileL().OpenTablesL(!aNotification);

	iStateMachine.SetCurrentStateL(iStateMachine.StateWritable());			

	}

/* Note: The following methods implement default 

   AcceptRequestL behaviour for all states derived 

   from Parent Class CState

*/

/* 

 Default behaviour: The file has already been opened 

 so complete KErrNone.

 @param aRequest Open database request object

 @return TAccept EProcessed - finished processing request

*/ 

TAccept CState::AcceptRequestL(CReqAsyncOpen* aRequest)

	{

	aRequest->Complete();

	return EProcessed;

	}

/**

 Default behaviour is to defer the request

 @param aRequest Update contact item request object

 @return EDeferred if the request is not processed, EProcessed if the request is

         completed with timeout error.

 @see CState::DeferRequest 

*/

TAccept CState::AcceptRequestL(CReqUpdateCnt* aRequest)

	{

	return DeferRequest(aRequest);

	}

/**

 Default behaviour is to defer the request

 @param aRequest Commit contact item request object

 @return EDeferred if the request is not processed, EProcessed if the request is

         completed with timeout error.

 @see CState::DeferRequest 

*/

TAccept CState::AcceptRequestL(CReqCommitCnt* aRequest)

	{

	return DeferRequest(aRequest);

	}

/** 

 Default behaviour is to allow read access on the database	

 Open is the same as read but with locking - does not change the database	

 @param aRequest Open contact item request object

 @return EProcessed if the request is completed or one of the values returned by 

         CState::DeferRequest if the database is currently locked.

 @see CState::DeferRequest 

*/

TAccept CState::AcceptRequestL(CReqOpenCnt* aRequest)

	{

	if (iStateMachine.TransactionLockL().LockLX(aRequest->SessionId(), aRequest->CntItemId()) == KErrInUse)

		{

		// The contact item has been locked by another session

		aRequest->SetTimeOutError(KErrInUse);

		return DeferRequest(aRequest);

		}

	CContactItem* cntItem = iPersistenceLayer.PersistenceBroker().ReadLC(aRequest->CntItemId(), aRequest->ItemViewDef(), EPlAllInfo, aRequest->SessionId(), ETrue);

	aRequest->CompleteL(*cntItem);

	CleanupStack::PopAndDestroy(cntItem); 

	CleanupStack::Pop(); // we do not destroy it since that would trigger the leave mechanism and unlock the record

	return EProcessed;

	}

/**

 Default behaviour is to allow read access on the database.

 Read Contact does not change the database

 @param aRequest Read contact item request object

 @return TAccept EProcessed - finished processing request

*/ 

TAccept CState::AcceptRequestL(CReqReadCnt* aRequest)

	{

	CContactItem* cntItem = iPersistenceLayer.PersistenceBroker().ReadLC(aRequest->CntItemId(), aRequest->ItemViewDef(), EPlAllInfo, aRequest->SessionId());

	aRequest->CompleteL(*cntItem);

	CleanupStack::PopAndDestroy(cntItem);

	return EProcessed;		

	}		

/**

 Default behaviour is to defer the request

 @param aRequest Delete contact item request object

 @return EDeferred if the request is not processed, EProcessed if the request is

         completed with timeout error.

 @see CState::DeferRequest 

*/

TAccept CState::AcceptRequestL(CReqDeleteCnt* aRequest)

	{

	return DeferRequest(aRequest);	

	}

/**

 Default behaviour is to close the contact item by removing the locking 

 The lock was added during from an Open Contact Request

 If the contact id is supplied, explicity unlock that contact item, otherwise

 unlock the last contact item locked by the session

 @param aRequest Close contact item request object

 @return TAccept EProcessed - finished processing request

*/  

TAccept CState::AcceptRequestL(CReqCloseCnt* aRequest)

	{

	if (aRequest->CntItemId() > KNullContactId)

		{

		aRequest->Complete(iStateMachine.TransactionLockL().UnLockL(aRequest->SessionId(), aRequest->CntItemId()));	

		}

	else

		{

		iStateMachine.TransactionLockL().UnlockLastLockedContactL(aRequest->SessionId());

		aRequest->Complete(KErrNone);

		}

	return EProcessed;		

	}

/**

 Default behaviour is to always allow a session to unlock any contact 

 items that remain locked for that session before the session is closed

 @param aRequest Unlock all contact items request object  

 @return TAccept EProcessed - finished processing request

*/  

TAccept CState::AcceptRequestL(CReqInternalSessionUnlock* aRequest)

	{

	iStateMachine.TransactionLockL().UnLockAllL(aRequest->SessionId());

	aRequest->Complete(KErrNone);

	return EProcessed;		

	}

/**

 Default behaviour is to defer the request

 @param Create contact item request object

 @return EDeferred if the request is not processed, EProcessed if the request is

         completed with timeout error.

 @see CState::DeferRequest 

*/

TAccept CState::AcceptRequestL(CReqCreateCnt* aRequest)

	{

	return DeferRequest(aRequest);	

	}

/**

 The default behaviour for Cancelling an Asyncronous Open database command

 is to accept the file has been opened.

 @param aRequest Cancel database open request object 

 @return TAccept EProcessed - finished processing request

*/ 

TAccept CState::AcceptRequestL(CReqCancelAsyncOpen* aRequest)

	{

	aRequest->Complete();

	return EProcessed;	

	}

/**

 Default behaviour is to defer the request

 @param aRequest Close contact database tables request object

 @return EDeferred if the request is not processed, EProcessed if the request is

         completed with timeout error.

 @see CState::DeferRequest 

*/

TAccept CState::AcceptRequestL(CReqCloseTables* aRequest)

  	{

 	return DeferRequest(aRequest);	

  	}

/**

 Default behaviour is to defer the request

 @param aRequest ReOpen contact database tables request object

 @return EDeferred if the request is not processed, EProcessed if the request is

         completed with timeout error.

 @see CState::DeferRequest 

*/

TAccept CState::AcceptRequestL(CReqReOpen* aRequest)

	{

	return DeferRequest(aRequest);	

	}

/**

 Default behaviour is to defer the request

 @param aRequest Begin transaction request object

 @return EDeferred if the request is not processed, EProcessed if the request is

         completed with timeout error.

 @see CState::DeferRequest 

*/

TAccept CState::AcceptRequestL(CReqDbBeginTrans* aRequest)

	{

	return DeferRequest(aRequest);	

	}

/**

 Default behaviour is to defer the request

 @param aRequest Commit transaction request object

 @return EDeferred if the request is not processed, EProcessed if the request is

         completed with timeout error.

 @see CState::DeferRequest 

*/

TAccept CState::AcceptRequestL(CReqDbCommitTrans* aRequest)

	{

	return DeferRequest(aRequest);	

	}

/**

 Default behaviour is to defer the request

 @param aRequest Rollback transaction request object

 @return EDeferred if the request is not processed, EProcessed if the request is

         completed with timeout error.

 @see CState::DeferRequest 

 */

TAccept CState::AcceptRequestL(CReqDbRollbackTrans* aRequest)

	{

	return DeferRequest(aRequest);	

	}

/**

 Default behaviour is to defer the request

 @param aRequest Notification of database backup/restore request object

 @return EDeferred if the request is not processed, EProcessed if the request is

         completed with timeout error.

 @see CState::DeferRequest 

*/

TAccept CState::AcceptRequestL(CReqBackupRestoreBegin* aRequest)

	{

	return DeferRequest(aRequest);	

	}

/**

 Default behaviour is to complete the request

 @param aRequest Notification that a backup/restore has finished request object

 @return TAccept EProcessed - finished processing request

*/

TAccept CState::AcceptRequestL(CReqBackupRestoreEnd* aRequest)

   	{

  	// In most cases no backup/restore will be in progress so by default

  	// complete this request.

  	aRequest->Complete();

  	return EProcessed;

  	}

/**

 Default behaviour is set an internal low disk flag to true

 @param aRequest Notification of low disk space request object

 @return TAccept EProcessed - finished processing request

*/  

TAccept CState::AcceptRequestL(CReqDiskSpaceLow* aRequest)

  	{

  	iStateMachine.SetLowDisk(ETrue);

  	aRequest->Complete();

  	return EProcessed;

  	}

/**

 Default behaviour is to set an internal low disk flag to false

 @param aRequest Notification disk space is normal request object

 @return TAccept EProcessed - finished processing request

*/

TAccept CState::AcceptRequestL(CReqDiskSpaceNormal* aRequest)

  	{

  	iStateMachine.SetLowDisk(EFalse);

  	aRequest->Complete();

  	return EProcessed;

  	}

/**

 Default behaviour is set an internal async activity flag to true

 @param aRequest Notification of async activity request object

 @return TAccept EProcessed - finished processing request

*/  

TAccept CState::AcceptRequestL(CReqAsyncActivity* aRequest)

  	{

  	iStateMachine.SetAsyncActivity(ETrue);

  	aRequest->Complete();

  	return EProcessed;

  	}

/**

 Default behaviour is to set an internal async activity flag to false

 @param aRequest Notification of no async activity request object

 @return TAccept EProcessed - finished processing request

*/

TAccept CState::AcceptRequestL(CReqNoAsyncActivity* aRequest)

  	{

  	iStateMachine.SetAsyncActivity(EFalse);

  	aRequest->Complete();

  	return EProcessed;

  	}

/**

 Default behaviour is to defer the request

 @param aRequest Speed dial request object

 @return EDeferred if the request is not processed, EProcessed if the request is

         completed with timeout error.

 @see CState::DeferRequest 

*/

TAccept CState::AcceptRequestL(CReqSetSpeedDial* aRequest)

	{

	return DeferRequest(aRequest);	

	}

/**

 Default behaviour is to defer the request

 @param aRequest Own card request object

 @return EDeferred if the request is not processed, EProcessed if the request is

         completed with timeout error.

 @see CState::DeferRequest 

*/

TAccept CState::AcceptRequestL(CReqSetOwnCard* aRequest)

	{

	return DeferRequest(aRequest);	

	}

/**

 Don't do anything with the event here. Simply propagate the event to the dbmanager

 Any state that wishes to handle the event implements it's own overwritten 

 HandleDatabaseEventL method. The only state

 that actually implements this is the Transaction State.

 @param aEvent Database event generated in the Persistence Layer

*/ 

void CState::HandleDatabaseEventL(TContactDbObserverEvent aEvent)

	{

	iStateMachine.DbManager().HandleDatabaseEventL(aEvent);

	}

/**

 Sets a timeout error code on the request. This error code is retrieved from the 

 derived state class via a call to TimeOutErrorCode() 

 if the derived state class does not implement a overridden TimeOutErrorCode(), 

 the CState::TimeOutErrorCode() is used.

 Calls CState::DeferRequest to determine if the request should be deferred or not

 depending on the request's timer status.

 @param aRequest The request on which the timeout error is set.

 @return EDeferred if the request is not processed, EProcessed if the request is

         completed with timeout error.

 @see CState::DeferRequest 

*/

TAccept CState::DeferWithTimeOutError(CCntRequest* aRequest)

	{

	// use the time out error code specified with the current state

	aRequest->SetTimeOutError(TimeOutErrorCode());

    return DeferRequest(aRequest);

	}

/**

 Determines if an un-processed request should be completed with timeout error or if it 

 should be re-tried again later, depending on the current status of the request's timer.  

 @param aRequest The request failed to be processed by the current state

 @return EDeferred - if the request's timer has not expired, the request can be processed again at the 

                     next opportunity.

         EProcessed - if the request's timer has expired and is completed with timeout 

                      error.

*/	

TAccept CState::DeferRequest(CCntRequest* aRequest)

    {

	// request still cannot be processed, check if the timer on the request

	// has expired yet

	if (aRequest->TimeOut() <= 0)

        {

        // timer expired, request should be completed with timeout error

    	aRequest->Complete(aRequest->TimeOutError());

    	return EProcessed;

        }

    // timer still valid, as request cannot be processed now, signal to re-try again later

    return EDeferred;	

    }

/** 

 Returns the default timeout - KErrNotReady

*/

TInt CState::TimeOutErrorCode()  	

	{

	return KErrNotReady;

	}

/** 

 CStateClosed Class NewL factory constructor

 @see CState constructor

*/

CStateClosed* CStateClosed::NewL(CCntStateMachine& aStateMachine, CPersistenceLayer& aPersistenceLayer)

	{

	CStateClosed* stateClosed = new (ELeave) CStateClosed(aStateMachine, aPersistenceLayer);

	return stateClosed;

	}

/** 

 CStateClosed Class constructor