sl@0: // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: /**
sl@0:  @file
sl@0: */
sl@0: 
sl@0: #include "burstate.h"
sl@0: #include <babackup.h>
sl@0: #include "featmgrdebug.h"
sl@0: #include "featmgrserver.h"
sl@0: 
sl@0: CBurState::CBurState()
sl@0: 	{
sl@0: 	return;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  * The Backup and Restore state machine.
sl@0:  * This state machine has two state tables. The first table defines the correct modes of operation
sl@0:  * and the second describe the pathways arrising from error conditions. By seperating the normal
sl@0:  * pathways from the error pathways we can simplify the state machine into two parts. The function 
sl@0:  * SetUpBurStruct() will define the pathways for both these tables.
sl@0:  * Each table has three items per row: a current state, an ending state, and a pointer to a function 
sl@0:  * that transforms between these two states safely. 
sl@0:  * Given that we already know where we are, and where we are told to goto, the state machine
sl@0:  * function BUR_StateMachine() will search the normal operation table for a match, and then apply
sl@0:  * the function through the pointer. If no match is found, then the goto state is set to Error, and
sl@0:  * the error table is searched and applied. Because all the state are covered within the error table
sl@0:  * we can always return to a normal more of operation through the application of the error
sl@0:  * functions.
sl@0:  */ 
sl@0: CBurState::CBurState(CFeatMgrServer* aServer) : iCurrentBURStatus( EFeatMgrBURState_None ), iServer( aServer )
sl@0: 	{
sl@0: 	SetUpBurStruct();
sl@0: 	return;
sl@0: 	}
sl@0: 
sl@0: CBurState::~CBurState()
sl@0: 	{
sl@0: 	return;
sl@0: 	}
sl@0: 
sl@0: CBurState* CBurState::NewLC()
sl@0: 	{
sl@0: 	CBurState* self = new (ELeave)CBurState();
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->ConstructL();
sl@0: 	return self;
sl@0: 	}
sl@0: 
sl@0: CBurState* CBurState::NewL()
sl@0: 	{
sl@0: 	CBurState* self=CBurState::NewLC();
sl@0: 	CleanupStack::Pop(); // self;
sl@0: 	return self;
sl@0: 	}
sl@0: 
sl@0: void CBurState::ConstructL()
sl@0: 	{
sl@0: 	return;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  * This function checks the arguments that are passed into HandleBackupOperationEventL. 
sl@0:  * The TBackupOperationAttributes are checked against known values and an error is returned if
sl@0:  * the Feature Manager doesn't recognise the events.
sl@0:  */ 
sl@0: TInt CBurState::CheckBURArguments(  const TBackupOperationAttributes& aBackupOperationAttributes )
sl@0: 	{
sl@0: 	TInt error( KErrNone );
sl@0:     iBURLockFlag = aBackupOperationAttributes.iFileFlag;
sl@0:     iBUROpType   = aBackupOperationAttributes.iOperation;
sl@0:     
sl@0: 	// determine the operation type (backup or restore)
sl@0: 	switch( iBURLockFlag )	
sl@0: 		{
sl@0: 		case MBackupObserver::EReleaseLockReadOnly:
sl@0: 			INFO_LOG( "MBackupObserver::EReleaseLockReadOnly" );
sl@0: 			break;
sl@0: 		case MBackupObserver::EReleaseLockNoAccess:
sl@0: 			INFO_LOG( "MBackupObserver::EReleaseLockNoAccess" );
sl@0: 			break;
sl@0: 		case MBackupObserver::ETakeLock:
sl@0: 			INFO_LOG( "MBackupObserver::ETakeLock" );
sl@0: 			break;
sl@0: 		default:
sl@0: 			INFO_LOG( "CheckBURArguments iBURLockFlag default" );
sl@0: 			error = KErrNotFound;
sl@0: 			break;
sl@0: 		}
sl@0: 		
sl@0: 	// determine the operation status (e.g. starting, ending)
sl@0: 	switch( iBUROpType )
sl@0: 		{
sl@0: 		case MBackupOperationObserver::ENone:
sl@0: 			INFO_LOG( "ENone" );
sl@0: 			break;
sl@0: 		case MBackupOperationObserver::EStart:
sl@0: 			INFO_LOG( "EStart" );
sl@0: 			break;
sl@0: 		case MBackupOperationObserver::EEnd:
sl@0: 			INFO_LOG( "EEnd" );
sl@0: 			break;
sl@0: 		case MBackupOperationObserver::EAbort:
sl@0: 			INFO_LOG( "EAbort" );	
sl@0: 			break;
sl@0: 		default:
sl@0: 			INFO_LOG( "CheckBURArguments iOperation default" );	
sl@0: 			error = KErrNotFound;
sl@0: 			break;
sl@0: 		}
sl@0: 
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  * Sets up the array entries for the possible backup/restore state vectors. 
sl@0:  *               from           -> to             : function
sl@0:  * State vector: None           -> BackupStarted  : Goto_StartBackupState
sl@0:  * State vector: BackupStarted  -> BackupEnded    : EndBackupState
sl@0:  * State vector: BackupEnded    -> None           : Goto_NormalState
sl@0:  * State vector: None           -> RestoreStarted : Goto_StartRestoreState
sl@0:  * State vector: RestoreStarted -> RestoreEnded   : Goto_EndRestoreState
sl@0:  * State vector: RestoreEnded   -> None           : Goto_NormalState
sl@0:  */
sl@0: void CBurState::SetUpBurStruct()
sl@0: 	{
sl@0: 	BURStruct bStruct;
sl@0: 
sl@0: 	// Backup states
sl@0: 
sl@0: 	// State vector: None -> BackupStarted : Goto_StartBackupState
sl@0: 	bStruct.iCurrent = EFeatMgrBURState_None;
sl@0: 	bStruct.iGoto = EFeatMgrBURState_BackupStarted;
sl@0: 	bStruct.iFunc = &CFeatMgrServer::Goto_StartBackupState;
sl@0: 	iBURStructArray[0] = bStruct;
sl@0: 
sl@0: 	// State vector: BackupStarted -> BackupEnded : EndBackupState
sl@0: 	bStruct.iCurrent = EFeatMgrBURState_BackupStarted;
sl@0: 	bStruct.iGoto = EFeatMgrBURState_BackupEnded;
sl@0: 	bStruct.iFunc = &CFeatMgrServer::Goto_EndBackupState;
sl@0: 	iBURStructArray[1] = bStruct;
sl@0: 
sl@0: 	// State vector: BackupEnded -> None : Goto_NormalState
sl@0: 	bStruct.iCurrent = EFeatMgrBURState_BackupEnded;
sl@0: 	bStruct.iGoto = EFeatMgrBURState_None;
sl@0: 	bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;
sl@0: 	iBURStructArray[2] = bStruct;
sl@0: 
sl@0: 	// Valid restore states
sl@0: 	
sl@0: 	// State vector: None -> RestoreStarted : Goto_StartRestoreState
sl@0: 	bStruct.iCurrent = EFeatMgrBURState_None;
sl@0: 	bStruct.iGoto = EFeatMgrBURState_RestoreStarted;
sl@0: 	bStruct.iFunc = &CFeatMgrServer::Goto_StartRestoreState;
sl@0: 	iBURStructArray[3] = bStruct;
sl@0: 
sl@0: 	// State vector: RestoreStarted -> RestoreEnded : Goto_EndRestoreState
sl@0: 	bStruct.iCurrent = EFeatMgrBURState_RestoreStarted;
sl@0: 	bStruct.iGoto = EFeatMgrBURState_RestoreEnded;
sl@0: 	bStruct.iFunc = &CFeatMgrServer::Goto_EndRestoreState;
sl@0: 	iBURStructArray[4] = bStruct;
sl@0: 
sl@0: 	// State vector: RestoreEnded -> None : Goto_NormalState
sl@0: 	bStruct.iCurrent = EFeatMgrBURState_RestoreEnded;
sl@0: 	bStruct.iGoto = EFeatMgrBURState_None;
sl@0: 	bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;
sl@0: 	iBURStructArray[6] = bStruct;
sl@0: 
sl@0: 	// State vector: None -> None : Goto_NormalState
sl@0: 	bStruct.iCurrent = EFeatMgrBURState_None;
sl@0: 	bStruct.iGoto = EFeatMgrBURState_None;
sl@0: 	bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;
sl@0: 	iBURStructArray[5] = bStruct;
sl@0: 
sl@0: 	
sl@0: 	//
sl@0: 	// Error states
sl@0: 
sl@0: 	// State vector: RestoreStarted -> Error : Goto_ErrorState
sl@0: 	bStruct.iCurrent = EFeatMgrBURState_RestoreStarted;
sl@0: 	bStruct.iGoto = EFeatMgrBURState_Error;
sl@0: 	bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;
sl@0: 	iBURStructErrorArray[0] = bStruct;
sl@0: 
sl@0: 	// State vector: RestoreEnded -> Error : Goto_ErrorState
sl@0: 	bStruct.iCurrent = EFeatMgrBURState_RestoreEnded;
sl@0: 	bStruct.iGoto = EFeatMgrBURState_Error;
sl@0: 	bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;
sl@0: 	iBURStructErrorArray[1] = bStruct;
sl@0: 
sl@0: 	// State vector: BackupStarted -> None : Goto_ErrorState
sl@0: 	bStruct.iCurrent = EFeatMgrBURState_BackupStarted;
sl@0: 	bStruct.iGoto = EFeatMgrBURState_Error;
sl@0: 	bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;
sl@0: 	iBURStructErrorArray[2] = bStruct;
sl@0: 	
sl@0: 	// State vector: BackupEnded -> None : Goto_ErrorState
sl@0: 	bStruct.iCurrent = EFeatMgrBURState_BackupEnded;
sl@0: 	bStruct.iGoto = EFeatMgrBURState_Error;
sl@0: 	bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;
sl@0: 	iBURStructErrorArray[3] = bStruct;
sl@0: 	
sl@0: 	// State vector: Error -> None : Goto_NormalState
sl@0: 	bStruct.iCurrent = EFeatMgrBURState_Error;
sl@0: 	bStruct.iGoto = EFeatMgrBURState_None;
sl@0: 	bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;
sl@0: 	iBURStructErrorArray[4] = bStruct;
sl@0: 	
sl@0: 	return;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  * Convert from the type provided in TBackupOperationAttributes into more sensible BUR types that
sl@0:  * can be handles by the BUR_StateMachine. This step is necessary for two reasons, the first is
sl@0:  * simplification and the second is a lexical check for invalid type MBackupObserver::TFileLockFlags.
sl@0:  */
sl@0: BURStatus CBurState::ConvertToBURState(  const TBackupOperationAttributes& aBackupOperationAttributes )
sl@0: 	{
sl@0: 	BURStatus status = EFeatMgrBURState_Error;
sl@0:     iBURLockFlag = aBackupOperationAttributes.iFileFlag;
sl@0:     iBUROpType   = aBackupOperationAttributes.iOperation;
sl@0: 	// we ignore the iOperation state
sl@0:     
sl@0: 	if( iBURLockFlag == MBackupObserver::ETakeLock )
sl@0: 		{
sl@0: 		// ending (this doesn't define whether it was a backup
sl@0: 		// or a restore ending, just that file writing can now start 
sl@0: 		// again).
sl@0: 		INFO_LOG("ChangeFileLockL() BUR ending");
sl@0: 		switch( iCurrentBURStatus )
sl@0: 			{
sl@0: 			case( EFeatMgrBURState_BackupStarted ):
sl@0: 				status = EFeatMgrBURState_BackupEnded;
sl@0: 				break;
sl@0: 			case( EFeatMgrBURState_RestoreStarted ):
sl@0: 				status = EFeatMgrBURState_RestoreEnded;
sl@0: 				break;
sl@0: 			case( EFeatMgrBURState_None ):
sl@0: 				status = EFeatMgrBURState_None;
sl@0: 				break;
sl@0: 			default:
sl@0: 				status = EFeatMgrBURState_Error;
sl@0: 				break;
sl@0: 			}
sl@0: 		}
sl@0: 	else if( (iBURLockFlag & MBackupObserver::EReleaseLockReadOnly) &&
sl@0: 		(iBURLockFlag & ~MBackupObserver::EReleaseLockNoAccess) )
sl@0: 		{
sl@0: 		// starting (making the file read-only is a sign that we are
sl@0: 		// in "backup" mode).
sl@0: 		INFO_LOG("ChangeFileLockL() backup starting");
sl@0: 		status = EFeatMgrBURState_BackupStarted;
sl@0: 		}
sl@0: 	else if( iBURLockFlag & MBackupObserver::EReleaseLockNoAccess )
sl@0: 		{
sl@0: 		// starting (now read/write access is used to signify that a
sl@0: 		// restore has been started).
sl@0: 		INFO_LOG("ChangeFileLockL() restore starting");
sl@0: 		status = EFeatMgrBURState_RestoreStarted;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		// unhandled flag states
sl@0: 		INFO_LOG("ChangeFileLockL() error state");
sl@0: 		status = EFeatMgrBURState_Error;
sl@0: 		}
sl@0: 	
sl@0: 	return status;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  * This function is called from within featmgr server when a backup event occurs
sl@0:  * There are two state variables coming into Feature Manager as types MBackupObserver::TFileLockFlags 
sl@0:  * and TOperationType. Only certain combinations of these two state variables are valid for Feature
sl@0:  * Manager and if the combination is not valid (because there is no way of returning an error) 
sl@0:  * it will just set the internal state machine into an "error" state.
sl@0:  * Given our current state and our goto state (i.e. where we are at the moment and where we want to goto)
sl@0:  * the state machine checks that this is a valid path in our state machine and then perform the correct 
sl@0:  * operations to get us to the next valid state.
sl@0:  */
sl@0: void CBurState::BUROperationL( const TBackupOperationAttributes& aBackupOperationAttributes )
sl@0: 	{
sl@0: 	BURStatus gotoState    = EFeatMgrBURState_Error;  // fail safe
sl@0: 	BURStatus currentState = iCurrentBURStatus;       // where in the state machine we are at the moment
sl@0: 	
sl@0: 	// Check that the arguments are within valid limits
sl@0: 	if( KErrNone == CheckBURArguments( aBackupOperationAttributes ) )
sl@0: 		{
sl@0: 		// Now convert into states that the Feature Manager understands.
sl@0: 		gotoState = ConvertToBURState( aBackupOperationAttributes );
sl@0: 		}
sl@0: 	
sl@0: 	// Check that this is a valid path and then perform the correct operations to get to the next valid state
sl@0: 	iCurrentBURStatus = BUR_StateMachine( currentState, gotoState );
sl@0: 	
sl@0: 	return;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  * The state machine for the backup and restore of the featmgr 
sl@0:  * The logic that goes into changing states in the state machine.
sl@0:  */
sl@0: BURStatus CBurState::BUR_StateMachine( BURStatus aCurrent, BURStatus aGoto )
sl@0: 	{
sl@0: 	TInt count = 0;
sl@0: 	TBool found = EFalse;
sl@0: 
sl@0: 	// Fail safe default state values
sl@0: 	BURStatus newState			= EFeatMgrBURState_Error;
sl@0: 	BURStatus stateTableGoto    = EFeatMgrBURState_Error;
sl@0: 	BURStatus stateTableCurrent = EFeatMgrBURState_Error;
sl@0: 	
sl@0: 	// Normal operation
sl@0: 	//
sl@0: 	do
sl@0: 		{
sl@0: 		// Get the n-th state table [current,goto] state vector
sl@0: 		stateTableCurrent = iBURStructArray[count].iCurrent;
sl@0: 		stateTableGoto    = iBURStructArray[count].iGoto;
sl@0: 		
sl@0: 		// if the state table matches what we are given
sl@0: 		if( (aCurrent == stateTableCurrent) && 
sl@0: 			(aGoto    == stateTableGoto) )
sl@0: 			{
sl@0: 			// process the relevant state function
sl@0: 			if( NULL != iBURStructArray[count].iFunc )
sl@0: 				{
sl@0: 				newState = (iServer->*iBURStructArray[count].iFunc)( aCurrent );
sl@0: 
sl@0: 				// check result: when from the state machine is not what we expected from the state table
sl@0: 				if( newState != stateTableGoto )
sl@0: 					{
sl@0: 					// put state machine into an error state and break "normal" loop
sl@0: 					aCurrent = newState;
sl@0: 					aGoto    = EFeatMgrBURState_Error;
sl@0: 					break;
sl@0: 					}
sl@0: 				else
sl@0: 					{
sl@0: 					found = ETrue;
sl@0: 					}
sl@0: 				}
sl@0: 			
sl@0: 			// self-perpetuate in certain cases
sl@0: 			if( (EFeatMgrBURState_BackupEnded == newState) || 
sl@0: 				(EFeatMgrBURState_RestoreEnded == newState) )
sl@0: 				{
sl@0: 				aCurrent = newState;
sl@0: 				aGoto = EFeatMgrBURState_None;
sl@0: 				found = EFalse;
sl@0: 				count = 0;
sl@0: 				}
sl@0: 			}
sl@0: 		count++;
sl@0: 		}
sl@0: 	while( (!found) && count < KBURArrayLength );
sl@0: 	
sl@0: 
sl@0: 	// Error recovery
sl@0: 	//
sl@0: 	if( EFeatMgrBURState_Error == aGoto ||
sl@0: 		EFalse == found )
sl@0: 		{
sl@0: 		// reset 
sl@0: 		aGoto = EFeatMgrBURState_Error;
sl@0: 		count = 0;
sl@0: 		found = EFalse;
sl@0: 
sl@0: 		do
sl@0: 			{
sl@0: 			// Get the n-th state table [current,goto] state vector in the error array
sl@0: 			stateTableCurrent = iBURStructErrorArray[count].iCurrent;
sl@0: 			stateTableGoto    = iBURStructErrorArray[count].iGoto;
sl@0: 			
sl@0: 			// if the state table matches what we are given
sl@0: 			if( ((aCurrent == stateTableCurrent) && (aGoto == stateTableGoto))  )
sl@0: 				{
sl@0: 				// process the relevant state function
sl@0: 				if( NULL != iBURStructErrorArray[count].iFunc )
sl@0: 					{
sl@0: 					newState = (iServer->*iBURStructErrorArray[count].iFunc)( aCurrent );
sl@0: 					// there is no error recovery from error recovery.
sl@0: 					found = ETrue;
sl@0: 					}
sl@0: 				
sl@0: 				// self-perpetuate in certain cases
sl@0: 				if( EFeatMgrBURState_Error == newState )
sl@0: 					{
sl@0: 					aCurrent = newState;
sl@0: 					aGoto = EFeatMgrBURState_None;
sl@0: 					found = EFalse;
sl@0: 					count = 0;
sl@0: 					}
sl@0: 				}
sl@0: 			count++;
sl@0: 			}
sl@0: 		while( (!found) && count < KBURErrorArrayLength );
sl@0: 		
sl@0: 		}
sl@0: 	
sl@0: 	return newState;
sl@0: 	}
sl@0: