/*

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

*     CStateMachine class implementation.

*

*

*/

#include <e32base.h>

#include <aknappui.h>

#include <swinstdefs.h>

#include <swi/sisregistrysession.h>

#include <swi/sisregistryentry.h>

#include <httpdownloadmgrcommon.h>

#include <coeutils.h>

#include <SenDomFragment.h>

#include <SenXmlReader.h>

#include <SenElement.h>

#include <centralrepository.h>      // CRepository

#include <browseruisdkcrkeys.h>     // KCRUidBrowser

#include <wlanerrorcodes.h> 		//For download error handling

#include <etelpckt.h>       		//For download error handling

#include <exterror.h>       		//For download error handling

#include <httpdownloadmgrcommon.h>	//For download error handling (not in S60 5.0 SDK)

#include <es_enum.h>

#include <rconnmon.h>

#include <eikdef.h>

#include "bootstrapstatemachine.h"

#include "bootstrapappui.h"

#include "bootstrapconst.h"

#include "bootstrapinstallationobserver.h"

#include "smartinstallerdll.h"

#include "debug.h"

#include "globals.h"

#include "macros.h"

#include "config.h"

#include "utils.h" // HideAppFromMenuL()

// ADM binary name

_LIT(KAdmExePath, "ADM.exe");

_LIT(KDownloadFolder,"?:\\system\\adm\\");

// Sis file extension

_LIT(KSisExtn,".SIS");

_LIT(KSisxExtn,".SISX");

// Xml file extension

_LIT(KXMLExtn,".XML");

// Dep file extension

_LIT(KDepExtn,"_DEP");

// ADM changes file name

_LIT(KAdmChangesFile, "adm_changes.xml");

// Private folder of SWI Daemon

_LIT(KSWIDaemonPrivateFolder, "\\private\\10202dce\\");

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

// CStateMachine::NewLC

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

//

CStateMachine* CStateMachine::NewLC(CBootstrapAppUi& aSIUiObj, TUint32 aWrapperUid)

	{

	CStateMachine* object = new ( ELeave ) CStateMachine(aSIUiObj, aWrapperUid);

	CleanupStack::PushL( object );

	object->ConstructL();

	return object;

	}

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

// CStateMachine::NewL

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

//

CStateMachine* CStateMachine::NewL(CBootstrapAppUi& aSIUiObj, TUint32 aWrapperUid)

	{

	CStateMachine* object = CStateMachine::NewLC(aSIUiObj, aWrapperUid);

	CleanupStack::Pop();

	return object;

	}

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

// CStateMachine::CStateMachine

// C++ default constructor.

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

//

CStateMachine::CStateMachine(CBootstrapAppUi& aBsAppUiObj, TUint32 aWrapperUid) :

							CActive(CActive::EPriorityStandard),

							iAppUi(aBsAppUiObj),

							iWrapperPackageUid(aWrapperUid),

							iAdmChangesInfo(),

							iBootstrapFailed(EFalse)

#ifdef USE_LOGFILE

							, iLog(aBsAppUiObj.iLog)

#endif

	{

	CActiveScheduler::Add(this);

	}

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

// CStateMachine::ConstructL

// 2nd phase constructor.

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

//

void CStateMachine::ConstructL()

	{

	// Connect to the Download Manager

	TBool masterInstance(!(iAppUi.EikonEnv()->StartedAsServerApp()));

	iDownloadManager.ConnectL( KUidBootstrapApp, *this, masterInstance );

	User::LeaveIfError(iLauncher.Connect());

	iIsAdmInstalled = IsPackagePresentL(KUidAdm, iAdmInstalledVersion);

	ReadConfigurationL();

	}

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

// CStateMachine::~CStateMachine

// Virtual Destructor.

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

//

CStateMachine::~CStateMachine()

	{

	LOG( "~StateMachine()" );

	Cancel();

	DELETE_IF_NONNULL( iDepFilename );

	DELETE_IF_NONNULL( iSisFilename );

	DELETE_IF_NONNULL( iDownloadUrl );

	delete iInstallObsrv;

	delete iConfigUrl;

	delete iUrl;

	delete iDownloadFileName;

	iIapArray.Close();

	iDownloadManager.DeleteAll();

	iDownloadManager.Close();

	iLauncher.Close();

	}

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

// CStateMachine::RunL

// Called for each state transition

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

//

void CStateMachine::RunL()

	{

	switch (iAppState)

		{

		case EBSStateInit:

			{

			StateInitL();

			RequestState(EBSStateDownloadChanges);

			}

			break;

		case EBSStateDownloadChanges:

			{

			StateDownloadL();

			// No need to request a state change. HandleDMgrEventL() will

			// trigger a correct event after the download has completed.

			}

			break;

		case EBSStateParseChanges:

			{

			StateParseChangesL();

			if( IsAdmDownloadRequired() )

				{

				RequestState(EBSStateDownloadAdm);

				}

			else

				{

				RequestState(EBSStateLaunchAdm);

				}

			}

			break;

		case EBSStateDownloadAdm:

			{

			StateDownloadL();

			// No need to request a state change. HandleDMgrEventL() will

			// trigger a correct event after the download has completed.

			}

			break;

		case EBSStateInstallAdm:

			{

			StateInstallAdmL();

			// No need to request a state change. HandleInstallCompleteL() will

			// trigger a correct event after the installation has completed.

			}

			break;

		case EBSStateLaunchAdm:

			{

			StateLaunchAdmL();

			RequestState(EBSStateExit);

			}

			break;

		case EBSStateExit:

			{

			// Exit the application

			Cancel();

			iAppUi.ExitApp(iAppState);

			}

			break;

		case EBSStateExitWithError:

			{

			Cancel();

			//Error Id needs to be already set before the state transition.

			iAppUi.ExitApp(iAppState);

			}

			break;

		default:

			LOG2( "Ignoring state change %d", iAppState );

			break;

		}

	}

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

// CStateMachine::StateComplete

// Trigger the state transition.

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

//

void CStateMachine::RequestState(const EBSAppState aNextState)

	{

	LOG3( "+ RequestState(): %d->%d", iAppState, aNextState );

	iAppState = aNextState;

	iStatus = KRequestPending;

	if( !IsActive() )

		{

		SetActive();

		}

	TRequestStatus* status = &iStatus;

	User::RequestComplete( status, KErrNone );

	}

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

// CStateMachine::RunError

// Call Handlefailure incase of error.

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

//

TInt CStateMachine::RunError(TInt aError)

	{

	LOG2( "+ CStateMachine::RunError(%d)", aError );

	if ( aError != KLeaveExit )

		{

		HandleFailure();

		return KErrNone;

		}

	else

		{

		return KLeaveExit;

		}

	}

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

// CStateMachine::DoCancel

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

//

void CStateMachine::DoCancel()

	{

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

	iLauncher.CancelAsyncRequest(SwiUI::ERequestSilentInstall);

	iDownloadManager.DeleteAll();

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

	}

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

// CStateMachine::Start

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

//

void CStateMachine::Start()

	{

	SetActive();

	// send signal that this request has completed

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	}

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

// CStateMachine::Stop

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

//

void CStateMachine::Stop()

	{

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

	Cancel();

	}

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

// CBootstrapAppUi::ReadConfigurationL

// Leaves if runs out of memory

// Called from ConstructL in InitState

// @return KErrNone if configuration was read correctly, error code otherwise

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

//

TInt CStateMachine::ReadConfigurationL()

	{

	LOG( "+ ReadConfiguration()" );

	TFileName configFile;

	RArray< TPtrC > lineBuffer;

	RFs& rfs = CEikonEnv::Static()->FsSession();

	// Find the configuration file from the private directory

	TInt ret = rfs.PrivatePath( configFile );

	if ( ret == KErrNone )

		{

		TBuf<2> appDrive;

		// Insert the drive of the running application

		appDrive.Copy(iAppUi.Application()->AppFullName().Left(2));

		configFile.Insert( 0, appDrive );

		// Append the configuration file name

		configFile.Append( KConfigFile );

		LOG2( "configFile = %S", &configFile );

		HBufC* buffer = ReadConfigFile( rfs, configFile, lineBuffer, ret );

		if ( buffer && ret == KErrNone )

			{

			// Get Url from the config file

			TPtrC urlLine = GetConfigValue( KCfgTagUrl, lineBuffer, ret );

			if ( ret == KErrNone )

				{

				iConfigUrl = HBufC8::NewL( urlLine.Length() );

				iConfigUrl->Des().Copy(urlLine );

				LOG8_2( "configUrl = %S", iConfigUrl );

				}

			delete buffer;

			}

		}

	if ( !iConfigUrl )

		{

		// Error occured while reading the configuration, use default URL

		iConfigUrl = HBufC8::NewL( KDefaultDepServerUrl().Length() );

		*iConfigUrl = KDefaultDepServerUrl;

		LOG8_2( "configUrl = %S (default)", iConfigUrl );

		}

	lineBuffer.Close();

	LOG2("-  ReadConfiguration(): %d", ret );

	return ret;

	}

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

// CBootstrapAppUi::StateInitL

// Enter in EBSStateSetup,

//

// Read the sis file name and dep file name, based on Bootstrap version

// Set the ADM changes file to download and the url to download from.

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

//

void CStateMachine::StateInitL()

	{

	LOG2( "+ SetFileNameInfo(): ver = %d", KBootstrapVersion );

	if( ( KBootstrapVersion < 1 ) && ( KBootstrapVersion > 4 ) )

		{

		// Unsupported Bootstrap version

		User::Leave( KErrNotSupported );

		}

	// Connect to SisRegistry to fetch Package info

	Swi::RSisRegistrySession registrySession;

	User::LeaveIfError( registrySession.Connect() );

	CleanupClosePushL( registrySession );

	Swi::RSisRegistryEntry entry;

	// Open registry entry

	User::LeaveIfError( entry.Open( registrySession, TUid::Uid( iWrapperPackageUid ) ) );

	CleanupClosePushL( entry );

	RPointerArray<HBufC> packageFiles;

	entry.FilesL( packageFiles );

	const TInt filesCount( packageFiles.Count() );

	// look into the files installed as part of the package,

	// to find the dep file name and actuall application file name.

	for ( TInt i=0; i<filesCount; i++ )

		{

		TParsePtrC parse( *packageFiles[i] );

		TPtrC orgExtn = parse.Ext();

		if ( orgExtn.Length() == 0 )

			{

			continue;

			}

		HBufC* extn = orgExtn.AllocLC();

		TPtr extnPtr = extn->Des();

		extnPtr.UpperCase();

		if ( KBootstrapVersion != 3 )

			{

			if (( extnPtr.Compare(KSisExtn) == 0 ) || ( extnPtr.Compare(KSisxExtn) == 0 ) )

				{

				TPtrC privatePath( KNullDesC );

				const TInt KDriveLength = 2;

				if ( ( packageFiles[i]->Length() ) > ( KSWIDaemonPrivateFolder().Length() + KDriveLength ) )

					{

					privatePath.Set( packageFiles[i]->Des().Mid( KDriveLength ) );

					privatePath.Set( privatePath.Left( KSWIDaemonPrivateFolder().Length() ) );

					}

				// Ignore if its a Stub Sis file

				if ( privatePath.CompareF( KSWIDaemonPrivateFolder ) )

					{

					if ( iSisFilename == NULL )

						{

						iSisFilename = packageFiles[i]->AllocL();

						LOG2( "Application sis '%S'", iSisFilename );

						}

					else

						// More than one sis present in the Wrapper Pkg

						{

						LOG2( "! More than one sis file present: '%S'. LEAVE.", packageFiles[i] );

						//TODO:GM: should there be a new error code for this??

						User::Leave( KErrNotSupported );

						}

					}

				} // if sis extension

			} // if (KBoostraVersion != 3)

		if ( KBootstrapVersion != 4 )

			{

			if( extnPtr.Compare(KXMLExtn) == 0 )

				{

				TPtrC orgName = parse.Name();

				const TInt namelength = orgName.Length();

				const TInt depSuffixlength = KDepExtn().Length();

				if ( namelength > depSuffixlength )

					{

					TPtrC depSuffix = orgName.Mid( ( namelength-depSuffixlength ), depSuffixlength );

					HBufC* name = depSuffix.AllocLC();

					TPtr namePtr = name->Des();

					namePtr.UpperCase();

					if ( namePtr.Compare( KDepExtn ) == 0 )

						{

						if ( iDepFilename == NULL )

							{

							iDepFilename = packageFiles[i]->AllocL();

							LOG2( "Dep file name is '%S'", iDepFilename );

							}

						else

							// More than one dep file present in the Wrapper Pkg

							{

							LOG2( "! More than one dep file present: '%S'. LEAVE.", packageFiles[i] );

							//TODO:GM: should there be a new error code for this??

							User::Leave( KErrNotSupported );

							}

						}

					CleanupStack::PopAndDestroy( name );

					}

				} // if XML extn

			} // if (KBoostrapVersion != 4)

		CleanupStack::PopAndDestroy( extn );

		}

	packageFiles.ResetAndDestroy();

	packageFiles.Close();

	if (KBootstrapVersion != 3)

		{

		if ( iSisFilename == NULL )

			{

			User::Leave( KErrNotSupported );

			}

		}

	if (KBootstrapVersion != 4)

		{

		if ( iDepFilename == NULL )

			{

			User::Leave( KErrNotSupported );

			}

		}

	CleanupStack::PopAndDestroy(&entry);

	CleanupStack::PopAndDestroy(&registrySession);

	iFileName.Set(KAdmChangesFile);

	// URL is already set

	DELETE_IF_NONNULL(iUrl);

	iUrl = iConfigUrl->AllocL();

	LOG2( "Filename is '%S'",&iFileName );

#ifdef FEATURE_BOOTSTRAP_SETIAP

	SetAndValidateIAPL();

#endif

	LOG( "- SetFileNameInfo()" );

	}

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

// CStateMachine::::IsAdmDownloadRequired

// Enter after EBSStateParseChanges

//

// Verify whether ADM sis download is required. Based on this, the next state will be set.

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

//

TBool CStateMachine::IsAdmDownloadRequired()

	{

	const TBool isAdmDownloadRequired =

			CompareVersions(iAdmInstalledVersion, iAdmChangesInfo.iVersion)

				== EGreaterSecondVersion;

	if ( isAdmDownloadRequired )

		{

		LOG7( "ADM update required (v%d.%02d.%d -> v%d.%02d.%d)",

			iAdmInstalledVersion.iMajor, iAdmInstalledVersion.iMinor, iAdmInstalledVersion.iBuild,

			iAdmChangesInfo.iVersion.iMajor, iAdmChangesInfo.iVersion.iMinor, iAdmChangesInfo.iVersion.iBuild

			);

		iFileName.Set(*iAdmChangesInfo.iSisName);