/*

* Copyright (c) 2009-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: 

*     State machine

*

*

*/

#ifndef ADMSTATEMACHINE_H_

#define ADMSTATEMACHINE_H_

#include <e32base.h>

#include <e32debug.h>

#include "ADMAppUi.h"

#include "ADMInstallManager.h"

#include "ADMPackageInfo.h"

#include "ADMSisParser.h"

#include "ADMXmlParser.h"

// Forward declarations

class TState;

class CStateMachine;

enum TStatePanic

	{

	EPanicStateIndexOutOfBounds = 1000,

	EPanicStateImplementationMissing,

	EPanicStateInvalidBootstrapVersion,

	EPanicStateInvalidMachineUid,

	EPanicStateFetchStatus,

	EPanicStateFetchPackageNull,

	EPanicStateUnexpectedPackage,

	EPanicStateUnexpectedRootPackage,

	EPanicStateWrapperNotInstalled

	};

const TInt KUnknownState = -40000;

// Timeout for waiting for download deletion. Default 2 s.

const TInt KDlDeletingTimeout = 2*1000*1000;

class CStateFactory : public CBase

	{

public:

	enum TAppState

		{

		EStateSetup = 0,                   // 0

		EStateSetupParsing,

		EStateBuildDepTree,

		EStateDownloadChangesFile,

		EStateParseChangesFile,

		EStateDownloadDepFile,             // 5

		EStateParseDepFile,

		EStateBuildFetchList,

		EStateVerifyAvailableDiskSpace,

		EStateConfirmDownload,

		EStateConfirmRoamingDownload,      // 10

		EStateStartDependencyDownload,

		EStateDownloadDependency,

		EStateInstallDependency,

		EStateInstallAppSis,

		EStateUninstallDependency,         // 15

		EStatePrepareExitWithError,

		EStateLaunchApp,

		EStateExit,

		EStateLast

		};

	TState& GetState(const TAppState aState) const;

	TInt StateIndex(const TState* aState) const;

	inline CStateMachine& StateMachine() const { return iStateMachine; }

	static CStateFactory* NewL(CStateMachine& aStateMachine);

	~CStateFactory();

private:

	CStateFactory(CStateMachine& aStateMachine);

	void ConstructL();

private:

	TFixedArray<TState*, EStateLast> iStates;

	CStateMachine&   iStateMachine;

	};

// Base class for a state

class TState

	{

public:

	//friend class CStateFactory;

	//friend class CStateMachine;

	TState(const CStateFactory& aFactory);

	// Change of states

	virtual void Enter() const;

	virtual void Exit() const;

	// Events from UI

	virtual void UserAccepted();

	virtual void UserRejected();

	virtual void UserCancelled();

	// Events from DownloadManager

	virtual void DownloadInProgress(const TInt aAlreadyDownloaded, const TInt aDownloadSize, const TReal32 aAvgDlSpeed);

	virtual void DownloadCompleted(const TInt aBytesDownloaded);

	virtual void DownloadFailed();

	virtual void DownloadCancelled();

	// Events from InstallManager

	virtual void InstallInProgress();

	virtual void InstallCompleted(TInt aStatus);

	virtual void InstallationCancelled();

protected:

	void DownloadFailed(const CStateFactory::TAppState aState);

	void PanicInState(TStatePanic aPanic) const;

protected:

	const CStateFactory& iFactory;

	CStateMachine& iStateMachine;

	};

// ----------------------------------------------------------------------------

class TStateSetup : public TState

	{

public:

	TStateSetup(const CStateFactory& aFactory);

	void Enter() const;

	};

// ----------------------------------------------------------------------------

class TStateSetupParsing : public TState

	{

public:

	TStateSetupParsing(const CStateFactory& aFactory);

	void Enter() const;

	};

// ----------------------------------------------------------------------------

class TStateDownloadDepFile : public TState

	{

public:

	TStateDownloadDepFile(const CStateFactory& aFactory);

	void Enter() const;

	void DownloadCompleted(const TInt aBytesDownloaded);

	void DownloadFailed();

	};

// ----------------------------------------------------------------------------

class TStateParseDepFile : public TState

	{

public:

	TStateParseDepFile(const CStateFactory& aFactory);

	void Enter() const;

	};

// ----------------------------------------------------------------------------

class TStateBuildDepTree : public TState

	{

public:

	TStateBuildDepTree(const CStateFactory& aFactory);

	void Enter() const;

	};

// ----------------------------------------------------------------------------

class TStateDownloadChangesFile : public TState

	{

public:

	TStateDownloadChangesFile(const CStateFactory& aFactory);

	void Enter() const;

	void DownloadCompleted(const TInt aBytesDownloaded);

	void DownloadFailed();

	};

// ----------------------------------------------------------------------------

class TStateParseChangesFile : public TState

	{

public:

	TStateParseChangesFile(const CStateFactory& aFactory);

	void Enter() const;

	};

// ----------------------------------------------------------------------------

class TStateBuildFetchList : public TState

	{

public:

	TStateBuildFetchList(const CStateFactory& aFactory);

	void Enter() const;

	};

// ----------------------------------------------------------------------------

class TStateVerifyAvailableDiskSpace : public TState

	{

public:

	TStateVerifyAvailableDiskSpace(const CStateFactory& aFactory);

	void Enter() const;

	};

// ----------------------------------------------------------------------------

class TStateConfirmDownload : public TState

	{

public:

	TStateConfirmDownload(const CStateFactory& aFactory);

	void Enter() const;

	void UserAccepted();

	};

// ----------------------------------------------------------------------------

class TStateConfirmRoamingDownload : public TState

	{

public:

	TStateConfirmRoamingDownload(const CStateFactory& aFactory);

	void Enter() const;

	void UserAccepted();

	};

// ----------------------------------------------------------------------------

class TStateStartDependencyDownload : public TState

	{

public:

	TStateStartDependencyDownload(const CStateFactory& aFactory);

	void Enter() const;

	};

// ----------------------------------------------------------------------------

class TStateDownloadDependency : public TState

	{

public:

	TStateDownloadDependency(const CStateFactory& aFactory);

	void Enter() const;

	void DownloadCompleted(const TInt aBytesDownloaded);

	void DownloadInProgress(const TInt aAlreadyDownloaded, const TInt aDownloadSize, const TReal32 aAvgDlSpeed);

	void DownloadFailed();

private:

	TBool iRetryDownload; // Set to true, if we're retrying download

	};

// ----------------------------------------------------------------------------

class TStateInstallDependency : public TState

	{

public:

	TStateInstallDependency(const CStateFactory& aFactory);

	void Enter() const;

	void Exit() const;

	void InstallCompleted(TInt aStatus);

	};

// ----------------------------------------------------------------------------

class TStateInstallAppSis : public TState

	{

public:

	TStateInstallAppSis(const CStateFactory& aFactory);

	void Enter() const;

	void InstallCompleted(TInt aStatus);

	};

// ----------------------------------------------------------------------------

class TStateUninstallDependency : public TState

	{

public:

	TStateUninstallDependency(const CStateFactory& aFactory);

	void Enter() const;

	void InstallCompleted(TInt aStatus);

	};

// ----------------------------------------------------------------------------

class TStatePrepareExitWithError : public TState

	{

public:

	TStatePrepareExitWithError(const CStateFactory& aFactory);

	void Enter() const;

private:

	TInt CreateInstallationResumeInfo() const;

	void BackupFilesL() const;

	};

// ----------------------------------------------------------------------------

class TStateLaunchApp : public TState

	{

public:

	TStateLaunchApp(const CStateFactory& aFactory);

	void Enter() const;

	void UserAccepted();

	void UserRejected();

};

// ----------------------------------------------------------------------------

class TStateExit : public TState

	{

public:

	TStateExit(const CStateFactory& aFactory);

	void Enter() const;

private:

	void RemoveResumeFiles() const;

#ifdef FEATURE_REPORTING

	void Report() const;

public:

	void DownloadInProgress(const TInt /* aAlreadyDownloaded */, const TInt /* aDownloadSize */, const TReal32 /* aAvgDlSpeed */);

	void DownloadCompleted(const TInt /* aBytesDownloaded */);

	void DownloadFailed();

	void DownloadCancelled();

#endif

	};

// ----------------------------------------------------------------------------

class CStateMachine : public CActive,

	public CInstallManager::MInstallClient,

	public CDownloadHandler::MDownloadClient

	{

public:

	friend class TState;

	friend class TStateBuildDepTree;

	friend class TStateBuildFetchList;

	friend class TStateConfirmDownload;

	friend class TStateConfirmRoaming;

	friend class TStateDownloadChangesFile;

	friend class TStateDownloadDepFile;

	friend class TStateDownloadDependency;

	friend class TStateExit;

	friend class TStateInstallAppSis;

	friend class TStateInstallDependency;

	friend class TStateLaunchApp;

	friend class TStateParseChangesFile;

	friend class TStateParseDepFile;

	friend class TStateParseSisFile;

	friend class TStatePrepareExitWithError;

	friend class TStateSetup;

	friend class TStateSetupParsing;

	friend class TStateStartDependencyDownload;

	friend class TStateUninstallDependency;

	friend class TStateVerifyAvailableDiskSpace;

	friend class TStateWaitForUserConfirmation;

	static CStateMachine* NewL(CADMAppUi& aAppUi, const TDesC& aDownloadPath);

	~CStateMachine();

	void Start();

	void Stop();

	void SetStartState(const CStateFactory::TAppState aState);

	void SetState(const CStateFactory::TAppState aState);

	TInt StateIndex() const;

	// Interfacing for ADM

	// Called when user has made a selection in a query dialog

	void SetIAP(TUint32 aIAP);

	void HandleUserResponse(TInt aResponse);

	CStateFactory::TAppState FailedState() const { return iFailedState; }

	inline TInt32 TotalDownloadSize() const { return iDepTree->GetTotalDownloadSize(); }

	inline HBufC* LaunchCaption() const

		{

			CPackageInfo* root = iDepTree->GetRootNode();

			if (root)

				return root->GetPackageName();

			else

				return NULL;

		}

#ifdef USE_LOGFILE

	RFileLogger& Log() const { return iAppUi.iLog; }

#endif

	// Interface to ADM

	inline TBool ResumeRequired() const { return iAppUi.iIsResumeRequired; }

	inline TInt MachineUid() const { return iAppUi.iMachineUid; }

	inline TInt BootstrapVersion() const { return iAppUi.iBootstrapVersion; }

	inline TBool RegisteredRoaming() const { return iAppUi.RegisteredRoaming(); }

	inline TBool UsingWLAN() const { return iAppUi.UsingWLAN(); }

	inline TBool OviStoreRunning() const { return iAppUi.iOviStoreRunning; }

	inline TBool ResumingInstallation() const { return iAppUi.iResumingInstallation; }

	inline HBufC* DepFilename() const { return iAppUi.iDepFileName; }

	inline HBufC* SisFilename() const { return iAppUi.iSisFileName; }

	inline HBufC8* ConfigUrl() const { return iAppUi.iConfigUrl; }

	inline TUid& WrapperPackageUid() const { return (TUid&)iAppUi.iWrapperPackageUid; }

	inline RFs& FsSession() const { return iAppUi.EikonEnv()->FsSession(); }

	inline void SetSilentInstallationOk(const TBool aOk) { iAppUi.iSilentInstallationOk = aOk; }

	inline void SetNonSilentInstallation(const TBool aVal) { iAppUi.iNonSilentInstallation = aVal; }

	inline void SetAppLaunch(const TBool aSuccess) { iAppUi.iAppLaunch = aSuccess; }

	inline TBool AppLaunch() const { return iAppUi.iAppLaunch; }

	inline TInt ExitReason() const { return iAppUi.iExitReason; }

	void UpdateProgressBar(const TInt aStartValue, const TInt aEndValue);

	void StopProgressBar() const;

	void SetFailureReason(TExitReason aReason);

	void ShowDownloadQueryL(const TInt aResourceId, const TInt aInfoResourceId = -1);

	void ShowWaitNoteL(const TInt aResourceId);

	void ShowInstallingWaitNoteL(const TInt aCurrent, const TInt aLast);

	void ShowProgressBarL(const TInt aStartValue, const TInt aEndValue, const TInt aCurrent = -1, const TInt aLast = -1);

	void StopWaitNote();

protected:

	void RunL();

	void DoCancel();

	TInt RunError(const TInt aError);

	void SetState(TState& aState);

	//From MInstallClient

	void HandleInstallCompletedL(TInt aStatus);

	//From MDownloadClient

	/**

	 * Called by Download Manager when IAP has changed.

	 * @param aIAP IAP ID

	 */

	void HandleIapChanged(const TUint32 aIAP);

	/**

	 * Called by Download Manager when downloading of a packet is completed.

	 * @param aDlFileName Name of the downloaded file.

	 * @param aResponseType Download type.

	 * @param aDownloadSize Total number of bytes downloaded.

	 */

	void HandleHttpFetchCompleted( const TDesC& aDlFilename, const TInt aDownloadType, const TInt32 aBytesDownloaded, const TReal32 aAvgDlSpeed, const TInt64 aDlTime );

	/**

	 * Called when download manager has retrieved a packet from the network.

	 * Required for updating the progress bar.

	 */

	void HandleHttpFetchInProgress(const TInt32 aAlreadyDownloaded, const TInt32 aDownloadSize, const TReal32 aAvgDlSpeed);

	/**

	 * Called when download manager encounters a problem while downloading

	 */

	void HandleHttpFetchFailure( const TDesC& aDlFilename, const TInt aGlobalErrorId, const TInt aErrorId, const TInt aFetchType );

	/**

	 * Called when download manager is deleting the download.

	 */

	void HandleDownloadDeleting();

	// State machine required functions

	//void HandleFailure();

	//TBool VerifyAvailableDiskSpace();

	//void SilentInstallDownloadedPackageL();

private:

	CStateMachine(CADMAppUi& aAppUi);

	void ConstructL(const TDesC& aDownloadPath);

private:

	CADMAppUi&			iAppUi;

	CStateFactory*		iStateFactory;     //< owns

	CInstallManager*	iInstallManager;   //< owns

	CDownloadHandler*	iDownloadHandler;  //< owns

	CXmlParser*			iXmlParser; //< owns

	CSisParser*			iSisParser; //< owns

	CDepTree*			iDepTree;   //< owns

	CPackageInfo*		iCurrentPackage;

	/**

	 * Path to the downloaded file. Updated after each finishing each

	 * download (completed or failed).

	 */

	HBufC*              iDownloadedFile;   //< owns

	/**

	 * Current state.

	 */

	TState*             iState;

	/**

	 * The state that experienced failure that causes ADM to exit.

	 */

	CStateFactory::TAppState    iFailedState;

	/**

	 * Number of dependency tree nodes processed so far.

	 */

	TInt   iNodesProcessed;

	/**

	 * Progress bar current value.

	 */

	TInt32 iProgressCurrentValue;

	/**

	 * Progress bar maximum value. Stays constant after being set.

	 */

	TInt32 iProgressMaxValue;

	/**

	 * Current package # being downloaded/installed.

	 */

	TInt iCounterCurrent;

	/**

	 * Total number of packages being downloaded/installed.

	 */

	TInt iCounterMax;

	/**

	 * Total size of the packages to be downloaded in bytes.

	 * Used in progress bar update.

	 */

	TInt32 iDownloadSize;

	/**

	 * Downloaded bytes so far.

	 * Used in progress bar update.

	 */

	TInt32 iCumulativeDepDownloaded;

	/**

	 * Total number of bytes downloaded during session. Includes all

	 * dependency XML file downloads and .sis file downloads.

	 */