/*

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

*     CADMAppUi implementation

*

*

*/

// INCLUDE FILES

#include <ADM.rsg>

#include <ADM.mbg>

#include <bacline.h>

#include <COEUTILS.H>

#include <mmtsy_names.h>    // Phone information

#include <hal.h>            // Hal::GetData()

#include <PathInfo.h>       // PathInfo::

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

#include <stringloader.h>   // StringLoader::LoadLC()

#include <aknquerydialog.h>

#include <aknnotewrappers.h>

#include <avkon.rsg>        // Default dialogs

#include <BAUTILS.H>

#include <rconnmon.h>

#include "ADM.hrh"

#include "ADM.pan"

#include "ADMApplication.h"

#include "ADMAppUi.h"

#include "ADMStateMachine.h"

#include "ADMXmlParser.h"

#include "ADMSisParser.h"

#include "ADMPackageInfo.h"

#include "ADMDownloadHandler.h"

#include "ADMInstallManager.h"

#include "networkstatuslistener.h"

#include "debug.h"

#include "globals.h"

#include "config.h"

#include "macros.h"

#include "utils.h"

#ifdef USE_LOGFILE

_LIT(KADMLogDir, "ADM");

_LIT(KADMLogFileName, "log.txt" );

_LIT(KADMLogFile, "?:\\logs\\ADM\\log.txt");

#endif

/**

 * Download path for dependency packages

 */

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

// ============================ MEMBER FUNCTIONS ===============================

void CADMAppUi::ConstructL()

	{

	LOG( "+ CADMAppUi::ConstructL()" );

	// Hide from application task list

	HideApplicationFromFSW();

	// Initialise app UI with standard value.

	BaseConstructL( ENoScreenFurniture /*CAknAppUi::EAknEnableSkin*/);

	StatusPane()->MakeVisible(EFalse);

	// Set download path

	TChar systemDrive;

	RFs::DriveToChar(RFs::GetSystemDrive(), systemDrive);

	HBufC* downloadPath = KADMFolderPath().AllocLC();

	downloadPath->Des()[0] = systemDrive;

	// Create the state machine

	iStateMachine = CStateMachine::NewL(*this, *downloadPath);

	iRfs = iEikonEnv->FsSession();

	iOviStoreRunning = CUtils::OviStoreRunning();

	// Process command line arguments

	ProcessCommandLineArgsL();

	iProgress = CProgressDialog::NewL(*this);

	// If we don't have exit reason set, we can show the progress already

	if (iExitReason == EExitNoError)

		{

		// Show progress bar with little progress already early on

		const TInt waitNoteRes = iResumingInstallation

				? R_ADM_CONTINUING_INST_TEXT

				: R_ADM_VERIFYING_SW_TEXT;

		ShowGlobalProgressL( waitNoteRes, 1, 10 );

		}

	iSwVersion = HBufC::NewL(KSysUtilVersionTextLength);

	// Initialize the telephone server

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

	User::LeaveIfError( iTelServer.LoadPhoneModule( KMmTsyModuleName ) );

	User::LeaveIfError( iPhone.Open( iTelServer, KMmTsyPhoneName ) );

	// Get device information

	User::LeaveIfError( GetPhoneInformation() );

	// Ignore the return code. Default URL will be used if error happens (leaves if no memory)

	ReadConfigurationL();

	ReadStaticResourcesL();

	// Kick the state machine running

	iStateMachine->Start();

	CleanupStack::PopAndDestroy(downloadPath);

	LOG( "- CADMAppUi::ConstructL()" );

	}

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

// CADMAppUi::CADMAppUi()

// C++ default constructor can NOT contain any code, that might leave.

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

//

CADMAppUi::CADMAppUi() :

		iExitReason(EExitNoError),

		iIAP(KInvalidIapId),

		iIsResumeRequired(ETrue)

	{

	// disable possible transition effects

	SetFullScreenApp(EFalse);

	INIT_DEBUG_LOG( KADMLogFile(), KADMLogDir, KADMLogFileName );

	LOG( "CADMAppUi::CADMAppUi()" );

	// Restore our thread priority to normal, we have been launched

	// with EPriorityBackground

//	RThread().SetPriority(EPriorityNormal);

	}

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

// CADMAppUi::~CADMAppUi()

// Destructor.

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

//

CADMAppUi::~CADMAppUi()

	{

	LOG( "CADMAppUi::~CADMAppUi()" );

	// Stop the state machine

	iStateMachine->Stop();

	// Just be make sure that all global stuff is out from the screen

	CancelProgressBar();

	CancelWaitNote();

	iPhone.Close();

	iTelServer.Close();

	DELETE_IF_NONNULL( iQueryMessage            );

	DELETE_IF_NONNULL( iGlobalConfirmationQuery );

	DELETE_IF_NONNULL( iGlobalQueryObserver     );

	delete iAppIconFilename;

	delete iMainAppName;

	delete iConfigUrl;

	delete iSwVersion;

	delete iProgress;

	delete iDepFileName;

	delete iSisFileName;

	delete iStateMachine;

	CLOSE_DEBUG_LOG;

	}

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

// Processes the command line parameters and sets state machine initial

// state according to the parameters.

//

// Requires that the state machine has been instantiated (iStateMachine).

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

//

void CADMAppUi::ProcessCommandLineArgsL()

	{

	LOG( "+ ProcessCommandLineArgsL()" );

	CCommandLineArguments* args = CCommandLineArguments::NewLC();

	const TInt count = args->Count();

#ifdef FEATURE_INSTALL_RESUME

	// If ADM is launched from the menu, we don't get any command line parameters

	// Need to read the info from the resume info file, if it exists.

	if (count == 1)

		{

		CleanupStack::PopAndDestroy(args);

		const TInt ret = ReadResumeInfoL();

		if (ret != KErrNone)

			{

			ShowGlobalNoteL(EAknGlobalErrorNote, R_ADM_ERR_NO_PENDING_INSTALLATIONS_TEXT);

			ExitApp();

			}

		iResumingInstallation = ETrue;

		return;

		}

#else

	if (count == 1)

		{

		User::Leave( KErrNotSupported );

		}

#endif // FEATURE_INSTALL_RESUME

	// index to the command line args, starting at 1 (0 = executable name)

	TInt index = 1;

#ifdef DO_LOG

	for (int i = 0; i < count; i++)

		{

		LOG3( "Arg[%d]='%S'", i, &(args->Arg(i)) );

		}

#endif

	TPtrC arg = args->Arg(index++);

	TLex lex(arg);

	TUint32 protocolVerRaw = 0;

	TUint32 protocolVer = 0;

	TUint32 tmp;

	if ( lex.Val(protocolVerRaw, EDecimal) == 0)

		{

		LOG3( "(cmd) pVer(raw) = %d (%03x)", protocolVerRaw, protocolVerRaw );

		protocolVer = (protocolVerRaw & KCmdLineBitProtocolVerMask);

		}

	else

		{

		LOG( "Invalid P/BVersion, PANIC" );

		Panic(EPanicAdmCmdLineArgs);

		}

	if (protocolVer < 15)

		{

		// assume it's old version without the bit field support

		LOG2( "Using old args %d", protocolVer );

		// Following are the command line args passed in the old version of Bootstrap:

		// arg 0 - ADM.exe

		// arg 1 - Bootstrap Version

		// arg 2 - WrapperUid

		// arg 3 - IAP

		// arg 4 - Sisfilename

		// arg 5 - Depfilename (optional)

		// Get the Bootstrap version

		iBootstrapVersion = protocolVer;

		LOG2("(cmd) BVersion: %x", iBootstrapVersion);

		// Get the Wrapper uid

		TPtrC uidPtr = args->Arg(index++);

		lex.Assign(uidPtr);

		TUint32 uid = 0;

		if ( lex.Val(uid, EDecimal ) == 0)

			{

			LOG2("(cmd) Wrapper Uid: 0x%x", uid);

			iWrapperPackageUid = TUid::Uid(uid);

			}

		// See if at least the minimum options required are provided

		if (count < 5)

			{

			LOG2( "Incorrect # of arguments (%d) passed from bootstrap, PANIC", count );

			Panic(EPanicAdmCmdLineArgs);

			}

		// Get Iap

		TPtrC iapPtr = args->Arg(index++);

		lex.Assign(iapPtr);

		if ( lex.Val(iIAP, EDecimal) == 0 )

			{

			LOG2("(cmd) IAP: %d", iIAP);

			iStateMachine->SetIAP(iIAP);

			}

		switch (iBootstrapVersion)

			{

			case 1:

			case 2:

				{

				if ( count != 6 )

					{

					LOG2( "Incorrect # of arguments (%d) passed from bootstrap, PANIC", count );

					Panic(EPanicAdmCmdLineArgs);

					}

				iDepFileName = args->Arg(index++).AllocL();

				LOG2( "(cmd) DepFile: '%S'", iDepFileName);

				iSisFileName = args->Arg(index++).AllocL();

				LOG2( "(cmd) AppSis: '%S'", iSisFileName);

				break;

				}

			case 3:

				{

				iDepFileName = args->Arg(index++).AllocL();

				LOG2( "(cmd) DepFile: '%S'", iDepFileName);

				break;

				}

			case 4:

				{

				iSisFileName = args->Arg(index++).AllocL();

				LOG2( "(cmd) AppSis: '%S'", iSisFileName);

				break;

				}

			default:

				LOG2( "Invalid BVersion %d, PANIC", iBootstrapVersion );

				Panic(EPanicAdmCmdLineArgs);

				break;

			}

		}

	else if (protocolVer == 15)

		{

		LOG( "Using new args" );

		// Command line arguments, version 15 specification:

		//

		//31               9  8  7  6  5  4  3  2  1  0

		// +-------------+--+--+--+--+--+--+--+--+--+--+

		// | reserved    |  |  |  |  |  |  |           |

		// +-------------+--+--+--+--+--+--+--+--+--+--+

		//

		//      value

		// bits range description

		//  0-3  0-15 Command line parameter protocol version:

		//             0 = not supported

		//             1 = ADM.exe 1 <wrapper_uid> <iap> <depfile> <sisfile>

		//             2 = ADM.exe 2 <wrapper_uid> <iap> <depfile> <sisfile>

		//             3 = ADM.exe 3 <wrapper_uid> <iap> <depfile>

		//             4 = ADM.exe 4 <wrapper_uid> <iap> <sisfile> (this was used in beta1, beta2)

		//            15 = ADM.exe 15 [parameters as specified by other bits]

		//

		//         since

		//  bit  version type command line parameter present

		//    4      4     N  Bootstrap version number

		//    5      4     N  Wrapper UID

		//    6      4     N  IAP

		//    7      4     N  ADM launch condition code:

		//                    KCmdLineCancelAdm: ADM needs to cancel installation

		//                    KCmdLineLaunchAdm: ADM starts normally

		//    8      4     S  Full path to dependency XML file

		//    9      4     S  Full path to application SIS file

		//

		// Types:

		//  N  Natural decimal number (range 0 - 2^32-1, fits to TUint32)

		//  S  UTF-8 string, must NOT contains spaces or other whitespaces

		//

		// Command line parameters appear in the order of the bits set, i.e.

		// if bits 4, 8, 9 are set the command line parameters are:

		// ADM.exe 784 <bootstrap_version> <dep_file> <sis_file>

		//

		// If command line protocol version is less than 15, it is assumed that

		// old version command line parameter format is used.

		//

		// new version. bit fields define which parameters are present

		// these has to be processed in the right order: from LSB to MSB

		if (protocolVerRaw & KCmdLineBitBootstrapVersion)

			{

			TPtrC arg = args->Arg(index++);

			lex.Assign(arg);

			if ( lex.Val(iBootstrapVersion) == 0 )

				{

				LOG2( "(cmd) BVersion: %x", iBootstrapVersion );

				}

			else

				{

				LOG( "Invalid BVersion" );

				Panic(EPanicAdmCmdInvalidBootstrap);

				}

			}

		if (protocolVerRaw & KCmdLineBitWrapperUid)

			{

			TPtrC arg = args->Arg(index++);

			lex.Assign(arg);

			if ( lex.Val(tmp, EDecimal) == 0 )

				{

				LOG2("(cmd) Wrapper Uid: 0x%x", tmp);

				iWrapperPackageUid = TUid::Uid(tmp);

				}

			else

				{

				LOG( "Invalid wrapper package UID" );

				Panic(EPanicAdmCmdInvalidWrapperUid);

				}

			}

		if (protocolVerRaw & KCmdLineBitIAP)

			{

			TPtrC arg = args->Arg(index++);

			lex.Assign(arg);

			if ( lex.Val(iIAP, EDecimal) == 0 )

				{

				LOG2("(cmd) IAP: %d", iIAP);

				iStateMachine->SetIAP(iIAP);

				}

			else

				{

				LOG( "Invalid IAP" );

				Panic(EPanicAdmCmdInvalidIAP);

				}

			}

		if (protocolVerRaw & KCmdLineBitADMLaunchControl)

			{

			TPtrC arg = args->Arg(index++);

			lex.Assign(arg);

			if ( lex.Val(tmp, EDecimal) == 0 )

				{

				LOG2("(cmd) LState %d", tmp);

				switch (tmp)

					{

				case KCmdLineLaunchAdm:

					// this is valid, nothing needs to be done

					break;

				case KCmdLineCancelAdmNoResume:

					iIsResumeRequired = EFalse;

					// fall-through

				case KCmdLineCancelAdm:

					iStateMachine->SetStartState(CStateFactory::EStatePrepareExitWithError);

					iStateMachine->SetFailureReason(EUserCancelled);

					break;

				default:

					LOG2( "Invalid LState %d, PANIC", tmp );

					Panic(EPanicAdmCmdInvalidLaunchState2);

					break;

					} // switch

				}

			else

				{

				LOG( "Invalid LState, PANIC" );

				Panic(EPanicAdmCmdInvalidLaunchState);

				}

			}

		if (protocolVerRaw & KCmdLineBitFileDep)

			{

			iDepFileName = args->Arg(index++).AllocL();

			LOG2( "(cmd) DepFile: '%S'", iDepFileName);

			}

		if (protocolVerRaw & KCmdLineBitFileSis)

			{

			iSisFileName = args->Arg(index++).AllocL();

			LOG2( "(cmd) SisFile: '%S'", iSisFileName);

			}

		}

	else

		{

		LOG2( "Invalid PVersion %d, PANIC", protocolVer );

		Panic(EPanicAdmCmdInvalidProtocol);

		}

	CleanupStack::PopAndDestroy(args);

	LOG3( "- ProcessCommandLineArgsL(): %d->%d", count, index );

	}

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

// Read the information from the resume info file, if launched from the menu.

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

//

TInt CADMAppUi::ReadResumeInfoL()

	{

	LOG( "+ ReadResumeInfo()" );

	RArray< TPtrC > lineBuffer;

	TInt err = 0;

	HBufC* buffer = ReadConfigFile( iRfs, KADMResumeInfoFile, lineBuffer, err );

	if ( buffer && err == KErrNone )

		{

		// Read the main application name

		TPtrC namePtr = GetConfigValue( KRFieldAppName, lineBuffer, err );

		if ( err == KErrNone )

			{

			iMainAppName = namePtr.AllocL();

			LOG2( "Resuming '%S'", iMainAppName );

			}

		// Get BootstrapVersion from the resume info file

		TPtrC bootstrapVersionLine = GetConfigValue( KRFieldBootstrap, lineBuffer, err );

		if ( err == KErrNone )

			{

			TLex lex(bootstrapVersionLine);

			if ( lex.Val(iBootstrapVersion) == 0 )

				{

				LOG2( "(resume) Version: %d", iBootstrapVersion );

				}

			else

				{

				// TODO: Error: Can this ever happen?!

				//LOG( "Incorrect version in the resume info" );

				return KErrNotSupported;

				}

			}

		else

			{

			LOG2( "Failed to read version from the resume info (%d)", err );

			return err;

			}

		}

	else

		{

		LOG( "! No resume information, cannot continue" );

		// Resume information file doesn't exist

		return err;

		}

	// Get the Wrapper uid

	TPtrC uidPtr = GetConfigValue( KRFieldWrapperPkgUid, lineBuffer, err );

	if ( err == KErrNone )

		{

		TLex lex(uidPtr);

		TUint32 uid = 0;

		if ( lex.Val(uid, EDecimal ) == 0)

			{

			LOG2( "Wrapper Uid: 0x%x", uid );

			iWrapperPackageUid = TUid::Uid(uid);

			}

		else

			{

			//LOG( "Incorrect wrapper UID in resume info" );

			return KErrNotSupported;

			}

		}