// Copyright (c) 2008-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

*/

#include "burstate.h"

#include <babackup.h>

#include "featmgrdebug.h"

#include "featmgrserver.h"

CBurState::CBurState()

	{

	return;

	}

/**

 * The Backup and Restore state machine.

 * This state machine has two state tables. The first table defines the correct modes of operation

 * and the second describe the pathways arrising from error conditions. By seperating the normal

 * pathways from the error pathways we can simplify the state machine into two parts. The function 

 * SetUpBurStruct() will define the pathways for both these tables.

 * Each table has three items per row: a current state, an ending state, and a pointer to a function 

 * that transforms between these two states safely. 

 * Given that we already know where we are, and where we are told to goto, the state machine

 * function BUR_StateMachine() will search the normal operation table for a match, and then apply

 * the function through the pointer. If no match is found, then the goto state is set to Error, and

 * the error table is searched and applied. Because all the state are covered within the error table

 * we can always return to a normal more of operation through the application of the error

 * functions.

 */ 

CBurState::CBurState(CFeatMgrServer* aServer) : iCurrentBURStatus( EFeatMgrBURState_None ), iServer( aServer )

	{

	SetUpBurStruct();

	return;

	}

CBurState::~CBurState()

	{

	return;

	}

CBurState* CBurState::NewLC()

	{

	CBurState* self = new (ELeave)CBurState();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CBurState* CBurState::NewL()

	{

	CBurState* self=CBurState::NewLC();

	CleanupStack::Pop(); // self;

	return self;

	}

void CBurState::ConstructL()

	{

	return;

	}

/**

 * This function checks the arguments that are passed into HandleBackupOperationEventL. 

 * The TBackupOperationAttributes are checked against known values and an error is returned if

 * the Feature Manager doesn't recognise the events.

 */ 

TInt CBurState::CheckBURArguments(  const TBackupOperationAttributes& aBackupOperationAttributes )

	{

	TInt error( KErrNone );

    iBURLockFlag = aBackupOperationAttributes.iFileFlag;

    iBUROpType   = aBackupOperationAttributes.iOperation;

	// determine the operation type (backup or restore)

	switch( iBURLockFlag )	

		{

		case MBackupObserver::EReleaseLockReadOnly:

			INFO_LOG( "MBackupObserver::EReleaseLockReadOnly" );

			break;

		case MBackupObserver::EReleaseLockNoAccess:

			INFO_LOG( "MBackupObserver::EReleaseLockNoAccess" );

			break;

		case MBackupObserver::ETakeLock:

			INFO_LOG( "MBackupObserver::ETakeLock" );

			break;

		default:

			INFO_LOG( "CheckBURArguments iBURLockFlag default" );

			error = KErrNotFound;

			break;

		}

	// determine the operation status (e.g. starting, ending)

	switch( iBUROpType )

		{

		case MBackupOperationObserver::ENone:

			INFO_LOG( "ENone" );

			break;

		case MBackupOperationObserver::EStart:

			INFO_LOG( "EStart" );

			break;

		case MBackupOperationObserver::EEnd:

			INFO_LOG( "EEnd" );

			break;

		case MBackupOperationObserver::EAbort:

			INFO_LOG( "EAbort" );	

			break;

		default:

			INFO_LOG( "CheckBURArguments iOperation default" );	

			error = KErrNotFound;

			break;

		}

	return error;

	}

/**

 * Sets up the array entries for the possible backup/restore state vectors. 

 *               from           -> to             : function

 * State vector: None           -> BackupStarted  : Goto_StartBackupState

 * State vector: BackupStarted  -> BackupEnded    : EndBackupState

 * State vector: BackupEnded    -> None           : Goto_NormalState

 * State vector: None           -> RestoreStarted : Goto_StartRestoreState

 * State vector: RestoreStarted -> RestoreEnded   : Goto_EndRestoreState

 * State vector: RestoreEnded   -> None           : Goto_NormalState

 */

void CBurState::SetUpBurStruct()

	{

	BURStruct bStruct;

	// Backup states

	// State vector: None -> BackupStarted : Goto_StartBackupState

	bStruct.iCurrent = EFeatMgrBURState_None;

	bStruct.iGoto = EFeatMgrBURState_BackupStarted;

	bStruct.iFunc = &CFeatMgrServer::Goto_StartBackupState;

	iBURStructArray[0] = bStruct;

	// State vector: BackupStarted -> BackupEnded : EndBackupState

	bStruct.iCurrent = EFeatMgrBURState_BackupStarted;

	bStruct.iGoto = EFeatMgrBURState_BackupEnded;

	bStruct.iFunc = &CFeatMgrServer::Goto_EndBackupState;

	iBURStructArray[1] = bStruct;

	// State vector: BackupEnded -> None : Goto_NormalState

	bStruct.iCurrent = EFeatMgrBURState_BackupEnded;

	bStruct.iGoto = EFeatMgrBURState_None;

	bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;

	iBURStructArray[2] = bStruct;

	// Valid restore states

	// State vector: None -> RestoreStarted : Goto_StartRestoreState

	bStruct.iCurrent = EFeatMgrBURState_None;

	bStruct.iGoto = EFeatMgrBURState_RestoreStarted;

	bStruct.iFunc = &CFeatMgrServer::Goto_StartRestoreState;

	iBURStructArray[3] = bStruct;

	// State vector: RestoreStarted -> RestoreEnded : Goto_EndRestoreState

	bStruct.iCurrent = EFeatMgrBURState_RestoreStarted;

	bStruct.iGoto = EFeatMgrBURState_RestoreEnded;

	bStruct.iFunc = &CFeatMgrServer::Goto_EndRestoreState;

	iBURStructArray[4] = bStruct;

	// State vector: RestoreEnded -> None : Goto_NormalState

	bStruct.iCurrent = EFeatMgrBURState_RestoreEnded;

	bStruct.iGoto = EFeatMgrBURState_None;

	bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;

	iBURStructArray[6] = bStruct;

	// State vector: None -> None : Goto_NormalState

	bStruct.iCurrent = EFeatMgrBURState_None;

	bStruct.iGoto = EFeatMgrBURState_None;

	bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;

	iBURStructArray[5] = bStruct;

	//

	// Error states

	// State vector: RestoreStarted -> Error : Goto_ErrorState

	bStruct.iCurrent = EFeatMgrBURState_RestoreStarted;

	bStruct.iGoto = EFeatMgrBURState_Error;

	bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;

	iBURStructErrorArray[0] = bStruct;

	// State vector: RestoreEnded -> Error : Goto_ErrorState

	bStruct.iCurrent = EFeatMgrBURState_RestoreEnded;

	bStruct.iGoto = EFeatMgrBURState_Error;

	bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;

	iBURStructErrorArray[1] = bStruct;

	// State vector: BackupStarted -> None : Goto_ErrorState

	bStruct.iCurrent = EFeatMgrBURState_BackupStarted;

	bStruct.iGoto = EFeatMgrBURState_Error;

	bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;

	iBURStructErrorArray[2] = bStruct;

	// State vector: BackupEnded -> None : Goto_ErrorState

	bStruct.iCurrent = EFeatMgrBURState_BackupEnded;

	bStruct.iGoto = EFeatMgrBURState_Error;

	bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;

	iBURStructErrorArray[3] = bStruct;

	// State vector: Error -> None : Goto_NormalState

	bStruct.iCurrent = EFeatMgrBURState_Error;

	bStruct.iGoto = EFeatMgrBURState_None;

	bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;

	iBURStructErrorArray[4] = bStruct;

	return;

	}

/**

 * Convert from the type provided in TBackupOperationAttributes into more sensible BUR types that

 * can be handles by the BUR_StateMachine. This step is necessary for two reasons, the first is

 * simplification and the second is a lexical check for invalid type MBackupObserver::TFileLockFlags.

 */

BURStatus CBurState::ConvertToBURState(  const TBackupOperationAttributes& aBackupOperationAttributes )

	{

	BURStatus status = EFeatMgrBURState_Error;

    iBURLockFlag = aBackupOperationAttributes.iFileFlag;

    iBUROpType   = aBackupOperationAttributes.iOperation;

	// we ignore the iOperation state

	if( iBURLockFlag == MBackupObserver::ETakeLock )

		{

		// ending (this doesn't define whether it was a backup

		// or a restore ending, just that file writing can now start 

		// again).

		INFO_LOG("ChangeFileLockL() BUR ending");

		switch( iCurrentBURStatus )

			{

			case( EFeatMgrBURState_BackupStarted ):

				status = EFeatMgrBURState_BackupEnded;

				break;

			case( EFeatMgrBURState_RestoreStarted ):

				status = EFeatMgrBURState_RestoreEnded;

				break;

			case( EFeatMgrBURState_None ):

				status = EFeatMgrBURState_None;

				break;

			default:

				status = EFeatMgrBURState_Error;

				break;

			}

		}

	else if( (iBURLockFlag & MBackupObserver::EReleaseLockReadOnly) &&

		(iBURLockFlag & ~MBackupObserver::EReleaseLockNoAccess) )

		{

		// starting (making the file read-only is a sign that we are

		// in "backup" mode).

		INFO_LOG("ChangeFileLockL() backup starting");

		status = EFeatMgrBURState_BackupStarted;

		}

	else if( iBURLockFlag & MBackupObserver::EReleaseLockNoAccess )

		{

		// starting (now read/write access is used to signify that a

		// restore has been started).

		INFO_LOG("ChangeFileLockL() restore starting");

		status = EFeatMgrBURState_RestoreStarted;

		}

	else

		{

		// unhandled flag states

		INFO_LOG("ChangeFileLockL() error state");

		status = EFeatMgrBURState_Error;

		}

	return status;

	}

/**

 * This function is called from within featmgr server when a backup event occurs

 * There are two state variables coming into Feature Manager as types MBackupObserver::TFileLockFlags 

 * and TOperationType. Only certain combinations of these two state variables are valid for Feature

 * Manager and if the combination is not valid (because there is no way of returning an error) 

 * it will just set the internal state machine into an "error" state.

 * Given our current state and our goto state (i.e. where we are at the moment and where we want to goto)

 * the state machine checks that this is a valid path in our state machine and then perform the correct 

 * operations to get us to the next valid state.

 */

void CBurState::BUROperationL( const TBackupOperationAttributes& aBackupOperationAttributes )

	{

	BURStatus gotoState    = EFeatMgrBURState_Error;  // fail safe

	BURStatus currentState = iCurrentBURStatus;       // where in the state machine we are at the moment

	// Check that the arguments are within valid limits

	if( KErrNone == CheckBURArguments( aBackupOperationAttributes ) )

		{

		// Now convert into states that the Feature Manager understands.

		gotoState = ConvertToBURState( aBackupOperationAttributes );

		}

	// Check that this is a valid path and then perform the correct operations to get to the next valid state

	iCurrentBURStatus = BUR_StateMachine( currentState, gotoState );

	return;

	}

/**

 * The state machine for the backup and restore of the featmgr 

 * The logic that goes into changing states in the state machine.

 */

BURStatus CBurState::BUR_StateMachine( BURStatus aCurrent, BURStatus aGoto )

	{

	TInt count = 0;

	TBool found = EFalse;

	// Fail safe default state values

	BURStatus newState			= EFeatMgrBURState_Error;

	BURStatus stateTableGoto    = EFeatMgrBURState_Error;

	BURStatus stateTableCurrent = EFeatMgrBURState_Error;

	// Normal operation

	//

	do

		{

		// Get the n-th state table [current,goto] state vector

		stateTableCurrent = iBURStructArray[count].iCurrent;

		stateTableGoto    = iBURStructArray[count].iGoto;

		// if the state table matches what we are given

		if( (aCurrent == stateTableCurrent) && 

			(aGoto    == stateTableGoto) )

			{

			// process the relevant state function

			if( NULL != iBURStructArray[count].iFunc )

				{

				newState = (iServer->*iBURStructArray[count].iFunc)( aCurrent );

				// check result: when from the state machine is not what we expected from the state table

				if( newState != stateTableGoto )

					{

					// put state machine into an error state and break "normal" loop

					aCurrent = newState;

					aGoto    = EFeatMgrBURState_Error;

					break;

					}

				else

					{

					found = ETrue;

					}

				}

			// self-perpetuate in certain cases

			if( (EFeatMgrBURState_BackupEnded == newState) || 

				(EFeatMgrBURState_RestoreEnded == newState) )

				{

				aCurrent = newState;

				aGoto = EFeatMgrBURState_None;

				found = EFalse;

				count = 0;

				}

			}

		count++;

		}

	while( (!found) && count < KBURArrayLength );

	// Error recovery

	//

	if( EFeatMgrBURState_Error == aGoto ||

		EFalse == found )

		{

		// reset 

		aGoto = EFeatMgrBURState_Error;

		count = 0;

		found = EFalse;

		do

			{

			// Get the n-th state table [current,goto] state vector in the error array

			stateTableCurrent = iBURStructErrorArray[count].iCurrent;

			stateTableGoto    = iBURStructErrorArray[count].iGoto;

			// if the state table matches what we are given

			if( ((aCurrent == stateTableCurrent) && (aGoto == stateTableGoto))  )

				{

				// process the relevant state function

				if( NULL != iBURStructErrorArray[count].iFunc )

					{

					newState = (iServer->*iBURStructErrorArray[count].iFunc)( aCurrent );

					// there is no error recovery from error recovery.

					found = ETrue;

					}

				// self-perpetuate in certain cases

				if( EFeatMgrBURState_Error == newState )

					{

					aCurrent = newState;

					aGoto = EFeatMgrBURState_None;

					found = EFalse;

					count = 0;

					}

				}

			count++;

			}

		while( (!found) && count < KBURErrorArrayLength );

		}

	return newState;

	}