/*

* 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 implementation

*

*

*/

#include <ADM.rsg>

#include "ADMApplication.h" // KUidADMApp

#include "ADMStateMachine.h"

#include "ADMStateMachineDebug.h"

#include "globals.h"

#include "config.h"

#include <e32std.h>

#include <sysutil.h>        // SysUtil::DiskSpaceBelowCriticalLevel()

#include <BAUTILS.H>

#include <apgcli.h>

// Use Char 0xFF to indicate no drive is selected

const TChar KNoDriveSelected = 0xFF;

// Used to force the progress bar to finish

const TInt KProgressBarFullValue = 100;

TInt CompareVersions(TVersion& version1, TVersion& version2);

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

// Panic

//

// Raises a panic with specific panic code.

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

//

LOCAL_C inline void Panic(TInt aPanicCode)

	{

	_LIT(KPanic, "SmartInst-SM");

	User::Panic( KPanic, aPanicCode );

	}

LOCAL_C inline void Panic(TInt aPanicCode, TInt aState)

	{

	_LIT(KPanic, "SmartInst-SM");

	const TInt reason = aState*100 + aPanicCode;

	User::Panic( KPanic, reason );

	}

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

// Default constructor

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

//

CStateMachine::CStateMachine(CADMAppUi& aAppUi) :

	CActive(EPriorityNormal),

	iAppUi(aAppUi),

	iFailedState( CStateFactory::EStateLast )

	{

	CActiveScheduler::Add(this);

	}

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

// NewL()

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

//

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

	{

	CStateMachine* self = new (ELeave) CStateMachine(aAppUi);

	CleanupStack::PushL(self);

	self->ConstructL(aDownloadPath);

	CleanupStack::Pop();

	return self;

	}

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

// ConstructL()

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

//

void CStateMachine::ConstructL(const TDesC& aDownloadPath)

	{

	// Create a local semaphore for handling the download deleting

	// This must be the first to be created and last to be destroyed.

	iDlDeletingSemaphore.CreateLocal(0);

	iXmlParser = CXmlParser::NewL();

	iSisParser = CSisParser::NewL();

#ifdef USE_LOGFILE

	iInstallManager = CInstallManager::NewL(this, iAppUi.iLog);

	iDepTree = CDepTree::NewL(iAppUi.iLog, aDownloadPath);

	iDownloadHandler = CDownloadHandler::NewL(this, iAppUi.iLog, !(iAppUi.EikonEnv()->StartedAsServerApp()));

#else

	iInstallManager = CInstallManager::NewL(this);

	iDepTree = CDepTree::NewL(aDownloadPath);

	iDownloadHandler = CDownloadHandler::NewL(this, !(iAppUi.EikonEnv()->StartedAsServerApp()));

#endif

	iStateFactory = CStateFactory::NewL(*this);

	}

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

// Destructor

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

//

CStateMachine::~CStateMachine()

	{

	if (IsActive())

		{

		Cancel();

		}

	delete iStateFactory;

	delete iDownloadHandler;

	delete iInstallManager;

	delete iDepTree;

	delete iSisParser;

	delete iXmlParser;

	delete iDownloadedFile;

	iDlDeletingSemaphore.Close();

	}

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

// Updates the displayed progress bar

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

//

void CStateMachine::UpdateProgressBar(TInt aStartValue, TInt aEndValue)

	{

	iAppUi.iProgress->Update(aStartValue, aEndValue);

	}

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

// Removes the displayed progress bar

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

//

void CStateMachine::StopProgressBar() const

	{

	iAppUi.iProgress->Cancel();

	}

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

// Sets the failure state and reason for exit

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

//

void CStateMachine::SetFailureReason(TExitReason aReason)

	{

	iAppUi.iExitReason = aReason;

	iFailedState = (CStateFactory::TAppState)StateIndex();

	// If the device is not supported, don't create resume info

	if (aReason == EDeviceNotSupported)

		{

		iAppUi.iIsResumeRequired = EFalse;

		}

	}

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

// Shows the download query dialog with a specified text.

// @param aResourceId Resource ID for the text to be shown.

// @param aInfoResourceId Resource ID for additional information text.

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

//

void CStateMachine::ShowDownloadQueryL(const TInt aResourceId, const TInt aInfoResourceId)

	{

	iAppUi.ShowDownloadQueryL( aResourceId, aInfoResourceId );

	}

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

// Shows wait note

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

//

void CStateMachine::ShowWaitNoteL(const TInt aResourceId)

	{

	iAppUi.ShowWaitNoteL( aResourceId, ETrue );

	}

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

// Shows wait note with the specified values

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

//

void CStateMachine::ShowInstallingWaitNoteL(const TInt aCurrent, const TInt aLast)

	{

	iAppUi.ShowWaitNoteNumL( R_ADM_INSTALLING_TEXT, aCurrent, aLast );

	}

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

// Shows the progress bar with the specified values

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

//

void CStateMachine::ShowProgressBarL(const TInt aStartValue, const TInt aEndValue, const TInt aCurrent, const TInt aLast)

	{

	iAppUi.ShowGlobalProgressL( R_ADM_DOWNLOADING_TEXT,

			aStartValue, aEndValue,

			aCurrent, aLast );

	}

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

// Stops the wait note

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

//

void CStateMachine::StopWaitNote()

	{

	iAppUi.CancelWaitNote();

	}

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

// Starts the state machine from the initial state.

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

//

void CStateMachine::Start()

	{

	LOG( "+ CStateMachine::Start()" );

	// If the initial state has been set, don't change it here

	if (!iState)

		{

		iState = &iStateFactory->GetState( CStateFactory::EStateSetup );

		}

	iStatus = KRequestPending;

	SetActive();

	// send signal that this request has completed

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	}

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

// Stops the state machine

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

//

void CStateMachine::Stop()

	{

	LOG( "+ CStateMachine::Stop()" );

	Cancel();

	iDepTree->RemoveDownloadedFiles( FsSession() );

	// Log statistics. Prevent divide-by-zero.

	if (iDownloadTime == 0)

		iDownloadTime = 1;

	LOG4( "Total %d kB in %.1f s, avg %.2f kB/s",

			iCumulativeDownloaded/1024,

			iDownloadTime/1000000.0,

			iCumulativeDownloaded*1000000.0 / iDownloadTime / 1024.0);

	}

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

// Returns current state ID

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

//

TInt CStateMachine::StateIndex() const

	{

	return iStateFactory->StateIndex(iState);

	}

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

// Request the next state we want the application to go to

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

//

void CStateMachine::SetState(const CStateFactory::TAppState aState)

	{

	SetState( iStateFactory->GetState(aState) );

	}

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

// Set the starting state of the state machine, but do not invoke state change

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

//

void CStateMachine::SetStartState(const CStateFactory::TAppState aState)

	{

	iState = &iStateFactory->GetState( aState );

	}

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

// Request the next state we want the application to go to

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

//

void CStateMachine::SetState(TState& aState)

	{

	LOG3( "+ SetState(): %d -> %d", iStateFactory->StateIndex(iState), iStateFactory->StateIndex(&aState) );

	iState->Exit();

	iState = &aState;

	SetActive();

	// send signal that this request has completed

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	//LOG2( "- SetState(): now in %d", iStateFactory->StateIndex(iState) );

	}

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

// Active object heart

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

//

void CStateMachine::RunL()

	{

	//LOG2( "+ CStateEngine::RunL(): state=%d", iStateFactory->StateIndex(iState) );

	iState->Enter();

	//LOG2( "- CStateEngine::RunL(): %d", iStateFactory->StateIndex(iState) );

	}

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

// Handles the leaves from RunL().

//

// SPECIFIC CASES NOT DONE YET:

// -

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

//

TInt CStateMachine::RunError(const TInt aError)

	{

	LOG3("+ SM::RunError(): %d, %d", StateIndex(), aError );

	TExitReason err = EInstallationFailed;

	switch ( aError )

		{

		case KLeaveExit:

			{

			// TODO: Ugly hack: we need to return KLeaveExit as RunError()

			// gets called when application exit is called within RunL().

			//LOG( "Exit() left" );

			return KLeaveExit;

			}

		case SwiUI::KSWInstErrUserCancel:

			{

			LOG( "User cancelled installation" );

			// User cancelled the installation

			err = EUserCancelled;

			}

			break;

		case SwiUI::KSWInstErrInsufficientMemory:

			{

			LOG( "Installer left: not enough space" );

			err = EInsufficientMemory;

			}

			break;

		case SwiUI::KSWInstErrMissingDependency:

			{

			LOG( "Installer left: missing dependency." );

			//err = EInstallationFailed;

			}

			break;

		case SwiUI::KSWInstErrFileCorrupted:

		case SwiUI::KSWInstErrPackageNotSupported:

		case SwiUI::KSWInstErrGeneralError:

		case SwiUI::KSWInstErrNoRights:

		case SwiUI::KSWInstErrNetworkFailure:

		case SwiUI::KSWInstErrAccessDenied:

		case SwiUI::KSWInstUpgradeError:

			{

			LOG2( "Installer left, err=%d", aError );

			//err = EInstallationFailed;

			}

			break;

		case KErrServerTerminated:

			{

			LOG( "Server process terminated, cannot continue." );

			}

			break;

		case EUnsupportedDevice:

			{

			LOG( "MachineId not present in supported devices list" );

			err = EDeviceNotSupported;

			}

			break;

		case KErrAlreadyExists:

			{

			// Download already exists

			LOG( "Existing download" );

			err = EDownloadFailed;

			}

			break;

		default:

			{

			LOG2( "Uncategorized leave %d, exiting", aError );

			}

			break;

		}

	LOG2( "Exiting due to failure %d", err );

	SetFailureReason( err );

	SetState( CStateFactory::EStatePrepareExitWithError );

	return KErrNone;

	}

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

//

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

//

void CStateMachine::DoCancel()

	{

	LOG( "CStateMachine::DoCancel()" );

	iDownloadHandler->CancelAllDownloads();

	iInstallManager->CancelAll();

	}

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

// Sets the internet access point identifier for download handler

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

//

void CStateMachine::SetIAP(TUint32 aIAP)

	{

	iDownloadHandler->SetIAP(aIAP);

	}

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

// Handles the UI event from AppUi, filters it and passes it to states.

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

//

void CStateMachine::HandleUserResponse(TInt aStatus)

	{

	switch (aStatus)

		{

		case EAknSoftkeyYes:

			iState->UserAccepted();

			break;

		case EAknSoftkeyNo:

			iState->UserRejected();

			break;

		case EAknSoftkeyCancel:

		case EKeyPhoneEnd:

			// fall-through

		default:

			iState->UserCancelled();

			break;

		}

	}

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

//

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

//

void CStateMachine::HandleInstallCompletedL(TInt aStatus)

	{

	LOG4( "HandleInstallCompletedL(%d): %d. '%S'", aStatus, StateIndex(), iCurrentPackage->GetSisPackageName() );

	// TODO: Can iCurrentPackage ever be null? In case of root package installation??

	iState->InstallCompleted( aStatus );

	}

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

// Called, if IAP has changed

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

//

void CStateMachine::HandleIapChanged(const TUint32 aIAP)

	{

	iAppUi.iIAP = aIAP;

	SetIAP(aIAP);

	}

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

// Called when download has finished.

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

//

void CStateMachine::HandleHttpFetchCompleted(

		const TDesC& aDlFilename,

		const TInt /* aDownloadType */,

		const TInt32 aBytesDownloaded,

		const TReal32 aAvgDlSpeed, // bytes/second

		const TInt64 aDlTime       // microseconds

		)

	{

	delete iDownloadedFile;

	iDownloadedFile = NULL;

	iDownloadedFile = aDlFilename.Alloc();

	iDownloadSize = aBytesDownloaded;

	// Indicate that we've downloaded this amount already to keep progress bar happy

	iCumulativeDownloaded += aBytesDownloaded;

	// Calculate cumulative average download speed

	iDownloadTime += aDlTime;

#ifdef DEBUG_ADM

	TReal32 avgDlSpeed = iCumulativeDownloaded*1000000.0 / iDownloadTime;

#ifdef _DEBUG

	TBuf<32> buf;

	TReal r = avgDlSpeed;

	TRealFormat fmt(3, 2);

	fmt.iType = KRealFormatFixed; // | KDoNotUseTriads;

	buf.AppendNum(r/1024.0, fmt);

	buf.Append(' ');

	buf.Append(iAppUi.iPrefixKb);

	buf.Append('/');

	buf.Append('s');

	iAppUi.EikonEnv()->InfoMsg(buf);

#endif

	LOG8( "DL %7d/%7d (%.1f s, %3.02f kB/s) (total: %d kB, %.1f s, avg %.02f kB/s) OK",

			aBytesDownloaded, aBytesDownloaded, aDlTime/1000000.0, aAvgDlSpeed/1024.0,

			iCumulativeDownloaded/1024, iDownloadTime/1000000.0, avgDlSpeed/1024.0 );

#endif

	iState->DownloadCompleted(aBytesDownloaded);

	}

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

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

// Required for updating the progress bar.

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

//

void CStateMachine::HandleHttpFetchInProgress(const TInt32 aAlreadyDownloaded, const TInt32 aDownloadSize, const TReal32 aAvgDlSpeed)

	{

	iState->DownloadInProgress(aAlreadyDownloaded, aDownloadSize, aAvgDlSpeed);

	}

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

// Called when download manager encounters a problem while downloading

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

//

void CStateMachine::HandleHttpFetchFailure(

		const TDesC& aDlFilename,

		const TInt aGlobalErrorId,

		const TInt aErrorId,

		const TInt aFetchType

		)

	{

	if (aFetchType)

		{

		LOG5( "+ HandleHttpFetchFailure(): %d. %d, %d '%S'", StateIndex(), aGlobalErrorId, aErrorId, &aDlFilename );

		}

	delete iDownloadedFile;

	iDownloadedFile = NULL;