// Copyright (c) 2010 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:
// Implements the state machine which drives backup and restore support for the 
// Bluetooth Manager server.
//

/**
 @file
 @internalAll
*/

#ifndef BTMANSERVERBURSTATEMACHINE_H
#define BTMANSERVERBURSTATEMACHINE_H

/**
TBTBURState - records the state of the BUR manager.
**/
enum TBTBURState
	{
	EBTBURStateNormal,			// Waiting for a BUR event

	EBTBURStateBackupRequest,		// Processing a backup request
	EBTBURStateBackupOngoing, 		// Taking part in a backup operation
	EBTBURStateBackupIgnore,		// Not taking part in a backup operation (e.g. operation may not affect us)

	EBTBURStateRestoreRequest,		// Processing a restore request
	EBTBURStateRestoreOngoing, 		// Taking part in a restore operation
	EBTBURStateRestoreIgnore,		// Not taking part in a restore operation (e.g. operation may not affect us)

	EBTBURStateProcessRestoreFile,		// Processing an available restore file.
	EBTBURStateRestoreFileProcessingComplete,	// Processing of restore file has completed and registry has been updated
	
	EBTBURStateUnknown,			// Used to indicate an invalid transition
	};

/**
TBTBUREvent - Events which can cause transitions in the state of the BUR manager
**/
enum TBTBUREvent
	{
	// Events relating to P&S key changes from BUR engine
	EBTBUREventUnset,			// Unset notification event received from the Secure Backup Engine
	EBTBUREventNormal,			// Normal mode notification event received from the Secure Backup Engine
	EBTBUREventBackup,			// Backup notification event received from the Secure Backup Engine
	EBTBUREventRestore,			// Restore notification event received from the Secure Backup Engine

	// Internally generated events
	EBTBUREventBackupProceed,		// BUR manager should proceed with backup operation
	EBTBUREventBackupReject,		// BUR manager should not proceed with backup operation
	EBTBUREventRestoreProceed,		// BUR manager should proceed with restore operation
	EBTBUREventRestoreReject,		// BUR manager should not proceed with restore operation
	EBTBUREventProcessRestoreFile,		// Request to process an available restore file
	EBTBUREventProcessRestoreFileComplete,	// Parsing of restore file has completed
	EBTBUREventRestoreFileTransitionNormal,	// Parsing of restore file has been completed, transition should be made to normal state.

	EBTBUREventAbortStateAction,		// A state action has encountered an error which requires an abort back to normal state.
	};

/**
State handling mechanisms - these classes support the state machine used by the BUR manager.
**/

class CBTManServerBURMgr;
class CBTManServerBURMgrStateAction;

NONSHARABLE_CLASS(CBTManServerBURMgrStateFactory) : public CBase
	{
public:
	static CBTManServerBURMgrStateFactory* NewL(CBTManServerBURMgr& aBURMgr);
	~CBTManServerBURMgrStateFactory();

	inline TBTBURState GetCurrentState();
	TInt TransitionState(TBTBUREvent aTransitionEvent);
	void ExecuteAction();

private:
	CBTManServerBURMgrStateFactory(CBTManServerBURMgr& aBURMgr);
	void ConstructL();

	void ConstructStateMachineL();
	CBTManServerBURMgrStateAction* ConstructStateLC(TBTBURState aState);

private:
	RPointerArray<CBTManServerBURMgrStateAction> iStateActions;
	CBTManServerBURMgr& iBURMgr;
	TBTBURState iState;

	};

NONSHARABLE_CLASS(CBTManServerBURMgrStateAction) : public CBase
	{
public:
	~CBTManServerBURMgrStateAction();

	inline TBTBURState GetThisState();
	virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent)=0;
	virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr)=0;
	virtual void HandleActionError(CBTManServerBURMgr& aBURMgr, TInt aError);

protected:
	CBTManServerBURMgrStateAction(TBTBURState aState);

protected:
	TBTBURState iState;

	};

/**
Normal state
**/

NONSHARABLE_CLASS(CBTManServerBURMgrStateNormal) : public CBTManServerBURMgrStateAction
	{
public:
	static CBTManServerBURMgrStateNormal* NewLC();
	~CBTManServerBURMgrStateNormal();

	virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent);
	virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr);

protected:
	CBTManServerBURMgrStateNormal();

	};

/**
Backup states
**/

NONSHARABLE_CLASS(CBTManServerBURMgrStateBackupRequest) : public CBTManServerBURMgrStateAction
	{
public:
	static CBTManServerBURMgrStateBackupRequest* NewLC();
	~CBTManServerBURMgrStateBackupRequest();

	virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent);
	virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr);
	virtual void HandleActionError(CBTManServerBURMgr& aBURMgr, TInt aError);

protected:
	CBTManServerBURMgrStateBackupRequest();

	};

NONSHARABLE_CLASS(CBTManServerBURMgrStateBackupOngoing) : public CBTManServerBURMgrStateAction
	{
public:
	static CBTManServerBURMgrStateBackupOngoing* NewLC();
	~CBTManServerBURMgrStateBackupOngoing();

	virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent);
	virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr);
	virtual void HandleActionError(CBTManServerBURMgr& aBURMgr, TInt aError);

protected:
	CBTManServerBURMgrStateBackupOngoing();

	};


NONSHARABLE_CLASS(CBTManServerBURMgrStateBackupIgnore) : public CBTManServerBURMgrStateAction
	{
public:
	static CBTManServerBURMgrStateBackupIgnore* NewLC();
	~CBTManServerBURMgrStateBackupIgnore();

	virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent);
	virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr);

protected:
	CBTManServerBURMgrStateBackupIgnore();

	};

/**
Restore states
**/

NONSHARABLE_CLASS(CBTManServerBURMgrStateRestoreRequest) : public CBTManServerBURMgrStateAction
	{
public:
	static CBTManServerBURMgrStateRestoreRequest* NewLC();
	~CBTManServerBURMgrStateRestoreRequest();

	virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent);
	virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr);
	virtual void HandleActionError(CBTManServerBURMgr& aBURMgr, TInt aError);

protected:
	CBTManServerBURMgrStateRestoreRequest();

	};

NONSHARABLE_CLASS(CBTManServerBURMgrStateRestoreOngoing) : public CBTManServerBURMgrStateAction
	{
public:
	static CBTManServerBURMgrStateRestoreOngoing* NewLC();
	~CBTManServerBURMgrStateRestoreOngoing();

	virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent);
	virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr);
	virtual void HandleActionError(CBTManServerBURMgr& aBURMgr, TInt aError);

protected:
	CBTManServerBURMgrStateRestoreOngoing();

	};

NONSHARABLE_CLASS(CBTManServerBURMgrStateRestoreIgnore) : public CBTManServerBURMgrStateAction
	{
public:
	static CBTManServerBURMgrStateRestoreIgnore* NewLC();
	~CBTManServerBURMgrStateRestoreIgnore();

	virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent);
	virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr);

protected:
	CBTManServerBURMgrStateRestoreIgnore();

	};

/**
Restore file processing states
**/

NONSHARABLE_CLASS(CBTManServerBURMgrStateProcessRestoreFile) : public CBTManServerBURMgrStateAction
	{
public:
	static CBTManServerBURMgrStateProcessRestoreFile* NewLC();
	~CBTManServerBURMgrStateProcessRestoreFile();

	virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent);
	virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr);
	virtual void HandleActionError(CBTManServerBURMgr& aBURMgr, TInt aError);

protected:
	CBTManServerBURMgrStateProcessRestoreFile();

	};

NONSHARABLE_CLASS(CBTManServerBURMgrStateRestoreFileProcessingComplete) : public CBTManServerBURMgrStateAction
	{
public:
	static CBTManServerBURMgrStateRestoreFileProcessingComplete* NewLC();
	~CBTManServerBURMgrStateRestoreFileProcessingComplete();

	virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent);
	virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr);

protected:
	CBTManServerBURMgrStateRestoreFileProcessingComplete();

	};

#endif // BTMANSERVERBURSTATEMACHINE_H