/*
* Copyright (c) 2009 Aricent and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:
* Aricent - initial contribution.
*
* Contributors:
*
* Description:
* State machine for all video hwdevice plugins.
*
*/

//User includes
#include "aristatemachine.h"

//---------------------------------------------------------------------------
//Default Constrcutor.
//---------------------------------------------------------------------------
//
CStateMachine::CStateMachine():iState( EUnInitialized )
	{
	PRINT_ENTRY;
	// Initailization
	for ( TInt i = 0; i < KNumOfStates; i++ )
		{
		for ( TInt j = 0; j < KNumOfCommands; j++ )
			{
			iStateChanges [i][j] = EInvalidState;
			}
		}

	// set the valid transition states in the table

	// valid state changes from Uninitailize
	iStateChanges [EUnInitialized][EInitializeCommand] = EInitialized;
	iStateChanges [EUnInitialized][EInitializingCommand] = EInitializing;
	iStateChanges [EUnInitialized][EDeadStateCommand]
	                               = ENonInitializedDeadState;


	// valid state changes from Initailize
	iStateChanges [EInitialized][EStartCommand]		= EStart;
	iStateChanges [EInitialized][EPauseCommand]		= EPause;
	iStateChanges [EInitialized][EResumeCommand]	= EStart;
	iStateChanges [EInitialized][EInputEndCommand]	= EInitializedInStopping;
	iStateChanges [EInitialized][EStopCommand]		= EStop;
	iStateChanges [EInitialized][EDeadStateCommand]	= EInitializedDeadState;

	iStateChanges [EInitializing][EDeadStateCommand] = EInitializedDeadState;
	iStateChanges [EInitializing][EInitializeCommand]	= EInitialized;

	// valid state changes from Start
	iStateChanges [EStart][EStartCommand]		= EStart;
	iStateChanges [EStart][EPauseCommand]		= EPause;
	iStateChanges [EStart][EInputEndCommand]	= EStopping;
	iStateChanges [EStart][EStopCommand]		= EStop;
	iStateChanges [EStart][EDeadStateCommand]	= ENonInitializedDeadState;

	// valid  State changes from pause
	iStateChanges [EPause][EPauseCommand]		= EPause;
	iStateChanges [EPause][EResumeCommand]		= EStart;
	iStateChanges [EPause][EInputEndCommand]	= EPauseInStopping;
	iStateChanges [EPause][EStopCommand]		= EStop;
	iStateChanges [EPause][EDeadStateCommand]	= ENonInitializedDeadState;

	// valid state changes from Stop
	iStateChanges [EStop][EStartCommand]	= EStart;
	iStateChanges [EStop][EInputEndCommand] = EStopInInputEnd;
	iStateChanges [EStop][EStopCommand]		= EStop;
	iStateChanges [EStop][EDeadStateCommand]= ENonInitializedDeadState;

	// valid state changes from InitailizeInStopping
	iStateChanges [EInitializedInStopping][EStartCommand] = EStopping;
	iStateChanges [EInitializedInStopping][EDeadStateCommand]
	                                       = ENonInitializedDeadState;

	// valid  State Changes from EStopping
	iStateChanges [EStopping][EPauseCommand] = EPauseInStopping;
	iStateChanges [EStopping][EStopCommand]	 = EStop;
	iStateChanges [EStopping][EDeadStateCommand] = ENonInitializedDeadState;

	// valid state changes from PauseInStopping
	iStateChanges [EPauseInStopping][EResumeCommand] = EStopping;
	iStateChanges [EPauseInStopping][EStopCommand] = EStop;
	iStateChanges [EPauseInStopping][EDeadStateCommand]
	                                 = ENonInitializedDeadState;

	// valid state changes frm StopInInputEnd
	iStateChanges [EStopInInputEnd][EStartCommand] = EStopping;
	iStateChanges [EStopInInputEnd][EStopCommand] = EStop;
	iStateChanges [EStopInInputEnd][EDeadStateCommand]
	                                = ENonInitializedDeadState;
	}

//---------------------------------------------------------------------------
//Constrcutor.
//---------------------------------------------------------------------------
//
EXPORT_C CStateMachine* CStateMachine::NewL()
	{
	PRINT_ENTRY;
	CStateMachine* self = new ( ELeave ) CStateMachine();
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop();
	PRINT_EXIT;
	return( self );
	}

//---------------------------------------------------------------------------
//Symbian 2nd Phase Constrcutor.
//---------------------------------------------------------------------------
//
void CStateMachine::ConstructL()
	{
	PRINT_ENTRY;
	PRINT_EXIT;
	}

//---------------------------------------------------------------------------
//Checks whether transition to new state is possible or not.
//---------------------------------------------------------------------------
//
EXPORT_C TBool CStateMachine::IsTransitionValid( TCommand aCommand )
	{
	PRINT_ENTRY;

	if ( iStateChanges[iState][aCommand] != EInvalidState )
		{
		PRINT_EXIT;
		return( ETrue );
		}
	else
		{
		PRINT_EXIT;
		return( EFalse );
		}
	}

//---------------------------------------------------------------------------
//Transits to new state. If transition cann't be done, object will remain in
//the previous state.
//---------------------------------------------------------------------------
//
EXPORT_C TInt CStateMachine::Transit( TCommand aCommand )
	{
	PRINT_ENTRY;
	if ( !IsTransitionValid ( aCommand ) )
		{
		return KErrGeneral;
		}
	iState = iStateChanges[iState][aCommand];
	PRINT_EXIT;
	return KErrNone;
	}

//---------------------------------------------------------------------------
//Tells whether the state is initialized or not. Here initilized means if the
//state is in any state other than EUnInitialized
//---------------------------------------------------------------------------
//
EXPORT_C TBool CStateMachine::IsInitialized()
	{
	PRINT_ENTRY;
	if ( iState	!=	EUnInitialized )
		{
		PRINT_EXIT;
		return ETrue;
		}
	else
		{
		PRINT_EXIT;
		return EFalse;
		}
	}

//---------------------------------------------------------------------------
//Tells whether the state is exactly in EInitialized state or not.
//---------------------------------------------------------------------------
//
EXPORT_C TBool CStateMachine::IsInInitializedState()
	{
	PRINT_ENTRY;
	if ( iState	==	EInitialized )
		{
		PRINT_EXIT;
		return ETrue;
		}
	else
		{
		PRINT_EXIT;
		return EFalse;
		}
	}

//---------------------------------------------------------------------------
//Tells whether the state is initializing or not.
//---------------------------------------------------------------------------
//
EXPORT_C TBool CStateMachine::IsInitializing()
	{
	PRINT_ENTRY;
	if ( iState	==	EInitializing )
		{
		PRINT_EXIT;
		return ETrue;
		}
	else
		{
		PRINT_EXIT;
		return EFalse;
		}
	}

//---------------------------------------------------------------------------
//Tells whether the state is in any one of the input ending
//states i.e
//EInitializedInStopping,
//EStopping,
//EPauseInStopping,
//EStopInInputEnd
//---------------------------------------------------------------------------
//
EXPORT_C TBool CStateMachine::IsInputEndPending()
	{
	PRINT_ENTRY;
	if ( iState == EInitializedInStopping ||
		iState == EStopping ||
		iState == EPauseInStopping ||
		iState == EStopInInputEnd )
		{
		PRINT_EXIT;
		return ETrue;
		}
	else
		{
		PRINT_EXIT;
		return EFalse;
		}
	}

//---------------------------------------------------------------------------
//Tells whether state is in EStart state
//---------------------------------------------------------------------------
//
EXPORT_C TBool CStateMachine::IsStarted()
	{
	PRINT_ENTRY;
	if ( iState == EStart )
		{
		PRINT_EXIT;
		return ETrue;
		}
	else
		{
		PRINT_EXIT;
		return EFalse;
		}
	}

//---------------------------------------------------------------------------
//Tells whether stae is in EPlaying state
//---------------------------------------------------------------------------
//
EXPORT_C TBool CStateMachine::IsPlaying()
	{
	PRINT_ENTRY;
	if ( iState == EStart || iState == EStopping )
		{
		PRINT_EXIT;
		return ETrue;
		}
	else
		{
		PRINT_EXIT;
		return EFalse;
		}
	}

//---------------------------------------------------------------------------
//Tells whether state is in EPause state
//---------------------------------------------------------------------------
//
EXPORT_C TBool CStateMachine::IsPaused()
	{
	PRINT_ENTRY;
	if ( ( iState == EPause ) || ( iState == EPauseInStopping ) )
		{
		PRINT_EXIT;
		return ETrue;
		}
	else
		{
		PRINT_EXIT;
		return EFalse;
		}
	}

//---------------------------------------------------------------------------
//Tells whether stae is in EStop state
//---------------------------------------------------------------------------
//
EXPORT_C TBool CStateMachine::IsStopped()
	{
	PRINT_ENTRY;
	if ( iState == EStop )
		{
		PRINT_EXIT;
		return ETrue;
		}
	else
		{
		PRINT_EXIT;
		return EFalse;
		}
	}

//---------------------------------------------------------------------------
//Tells whether stae is in EInitailize or not
//---------------------------------------------------------------------------
//
EXPORT_C TBool CStateMachine::IfIsStateInInitailize()
	{
	PRINT_ENTRY;
	if ( iState == EInitialized )
		{
		PRINT_EXIT;
		return ETrue;
		}
	else
		{
		PRINT_EXIT;
		return EFalse;
		}
	}

//---------------------------------------------------------------------------
//Resets the state machine to EUnInitialized state.
//---------------------------------------------------------------------------
//
EXPORT_C void CStateMachine::Reset()
	{
	PRINT_ENTRY;
	iState	=	EUnInitialized;
	PRINT_EXIT;
	}



//---------------------------------------------------------------------------
//Tells whether stae is in EDeadState state
//---------------------------------------------------------------------------
//
EXPORT_C TBool CStateMachine::IsInDeadState()
	{
	PRINT_ENTRY;
	if ( ( iState == EInitializedDeadState ) ||
		 ( iState == ENonInitializedDeadState ) )
		{
		PRINT_EXIT;
		return ETrue;
		}
	else
		{
		PRINT_EXIT;
		return EFalse;
		}
	}

//---------------------------------------------------------------------------
//Destructor for StateMachine
//---------------------------------------------------------------------------
//
CStateMachine::~CStateMachine()
	{}