// 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

 */

 #ifndef BURSTATE_H

 #define BURSTATE_H

 // INCLUDES

 #include <e32svr.h>

 #include <featmgr/featurecmn.h>

 #include <featmgr/featureinfoplugin.h>

 #include <babackup.h>

 #include "featmgrclientserver.h"

 #include "featmgrtimer.h"

 #include "featmgrfeatureregistry.h"

 // CLASS DECLARATION

 class CFeatMgrServer;

 class CBurState;

 /**

  * States of the backup and restore state-machine.

  */ 

 typedef enum 

 	{

 	/** Normal state : Normal operation, not in a BUR state */

 	EFeatMgrBURState_None = 0,          

 	/** Error state */

 	EFeatMgrBURState_Error,             

 	/** Backup commands */

 	EFeatMgrBURState_BackupStarted,     

 	EFeatMgrBURState_BackupEnded,

 	/** Restore commands */

 	EFeatMgrBURState_RestoreStarted,    

 	EFeatMgrBURState_RestoreEnded,

 	} BURStatus;

 const TInt KBURArrayLength = 7;

 const TInt KBURErrorArrayLength = 5;

 /** 

  * State machine for handling the BUR operations for Feature Manager.

  */ 

 class CBurState

 	{

 	public: 

 	~CBurState();

 	CBurState(CFeatMgrServer* aServer);

 	static CBurState* NewL();

 	static CBurState* NewLC();

    	/**

      * Function from MBackupOperationObserver in response to a change in the state of the backup and

      * restore operation(s). This function is called to notify the Feature Manager that a backup and 

      * restore operation is in progress.

      * @param aBackupOperationAttributes The current state of the backup operation. Made up of 

      *        MBackupObserver::TFileLockFlags and TOperationType types.

      * @see	MBackupObserver::TFileLockFlags 

      * @see	TOperationType.

      */

 	 void BUROperationL(const TBackupOperationAttributes& aBackupOperationAttributes);

 	private:

 	CBurState();

 	void ConstructL();

    /** 

      * Used to check the TBackupOperationAttributes values that have arrived in Feature Manager 

      * as part of HandleBackupOperationEventL. This function makes sure the arguments from the Backup and Restore

      * server can be properly understood by the Feature Manager.

      * @param  TBackupOperationAttributes

      * @return Error code. Can either be KErrNone or KErrNotFound if an argument is not understood.

      * @see    CFeatMgrFeatureRegistry::HandleBackupOperationEventL

      */

     TInt CheckBURArguments(  const TBackupOperationAttributes& aBackupOperationAttributes );

     /** 

      * Conversion function will change TBackupOperationAttributes into a form more easily managed.

      * @param TBackupOperationAttributes

      * @return BURStatus

      */

     BURStatus ConvertToBURState(  const TBackupOperationAttributes& aBackupOperationAttributes );        

     /**

      * Increment the state machine.

      * @param aCurrent : current state (location)

      * @param aGoto : state to go to next (direction)

      * @return next state

      */

     BURStatus BUR_StateMachine( BURStatus aCurrent, BURStatus aGoto );

     void SetUpBurStruct();

     // Backup Notification

     TUint32 iBackupFlag;

     CBaBackupSessionWrapper *iBackupNotification;

     BURStatus iCurrentBURStatus;

     CFeatMgrServer *iServer;

     /** The file lock status of the file we are interested in. */ 

     MBackupObserver::TFileLockFlags iBURLockFlag;

     /** The current BUR operation, e.g. Start/End. */ 

     MBackupOperationObserver::TOperationType iBUROpType;

     /**

      * A structure for storing the information on the possible state elements

      * that are used for backup and restore. Each element has a current state, and

      * a direction to goto. e.g. (s1)-> (s2)-> (s3)-> (s4)-> (s5)-> etc..

      * The state machine is formed from a series of these interconnecting elements, 

      * and transition between states is handled by an associated function.

      */

     struct BURStruct

         {

         BURStatus iCurrent;

         BURStatus iGoto;

         /** A function pointer that is called to switch between states */

         BURStatus  (CFeatMgrServer::*iFunc)( BURStatus );

         };

     /** 

      * State machine architecture, written as BURStruct elements. This array defines the 

      * normal operation paths of the state machine.

      */

     BURStruct iBURStructArray[ KBURArrayLength ];

     /** 

      * Error handling is taken care of in the same manner as normal operation 

      * in the state machine architecture. Also written as written as BURStruct elements.

      * The error array defines a set of paths to take upon discovering a path that is 

      * not supported by the normal operation paths.

      */

     BURStruct iBURStructErrorArray[ KBURErrorArrayLength ];

 	};

 #endif // BURSTATE_H