/*

* Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

* Definition of the CInstallationPlanner

*

*/

/**

 @file

 @internalTechnology

 @released

*/

#ifndef __INSTALLATIONPLANNER_H__

#define __INSTALLATIONPLANNER_H__

#include <e32base.h>

#include "planner.h"

namespace Swi 

{

class RUiHandler;            // UISS handle

class RSisHelper;

class CInstallationResult;	

class CInstallationPlan;

class CApplication;

class CAppInfo;

class TAppInfo;           

class CContentProvider;      // Abstraction layer over SISX controller

class CSwisExpressionEnvironment;

class CSwisCreateExpressionEnvironment;

class CExpressionEvaluator;

class RSisRegistrySession;

class RSisRegistryEntry;

class RSisRegistryWritableEntry;

class CPlan;

namespace Sis 

{

class CController;          // SISX controller

class COptions;             // SISX options

class CFileDescription;

}

	/** T class used to store references to a controller and an application

	 It doesn't own either of them so T class should be ok

 	 * @released

 	 * @internalTechnology

	 */

	class TControllerAndParentApplication

		{

	public:

		TControllerAndParentApplication(const Sis::CController& aController, Swi::CApplication* aParentApplication);

		const Sis::CController& Controller();

		Swi::CApplication* ParentApplication();

	private:

		const Sis::CController& iController;

		Swi::CApplication* iParentApplication;

		};

/**

 * This class plans the installation. It asks the user all the required questions and builds

 * a list of application and files that need to be installed, without actually changing the

 * state of the device.

 * This class is used by Swi::CServerSISInstaller::DoInstallL(...)

 *

 * @released

 * @internalTechnology

 */

class CInstallationPlanner : public CPlanner

	{

public:

	/**

	 * This creates a new CInstallationPlanner object.

	 *

	 * @param aSisHelper          - SISHelper session

	 * @param aInstallerUI        - An implementation of the Installer UI

	 * @param aProvider           - Abstraction layer over the SISX contoller 

	 * @param aInstallationResult - Result of installation

	 */

	static CInstallationPlanner* NewL(RSisHelper& aSisHelper,

	  					RUiHandler& aInstallerUI, 

					    const CContentProvider& aProvider, 

					    CInstallationResult& aInstallationResult);

	/**

	 * This creates a new CInstallationPlanner object.

	 *

	 * @param aSisHelper           - SISHelper session

	 * @param aInstallerUI         - An implementation of the Installer UI

	 * @param aSISSignedController - Signed contoller of the main SIS file

	 * @param aInstallationResult  - Result of installation

	 */

	static CInstallationPlanner* NewLC(RSisHelper& aSisHelper,

	  					RUiHandler& aInstallerUI, 

					    const CContentProvider& aProvider, 

					    CInstallationResult& aInstallationResult);

	/**

	 * The destructor.

	 */

	virtual ~CInstallationPlanner(void);

public:

	/**

	 * Finish the plan once all controllers have been processed

	 */

	void FinalisePlanL(void);

	/**

	 * Finds the language index of the display language ID

	 * @param aAvailableLanguages - List of language ID's to find display ID from

	 * @return Index of language

	 */

	TInt FindDisplayLanguageIndex(const RArray<TLanguage>& aAvailableLanguages);

	/**

	 * @return Display language ID

	 */

	TLanguage DisplayLanguage(void) const;

	/** Gets the next controller to be processed in the plan

	@return ETrue If there is another controller or EFalse if finshed

	*/

	TBool GetNextController();

	/** Returns a reference to the current controller being processed

	*/

	const Sis::CController& CurrentController();

	/**

	Returns the main controller of the SIS file

	*/

	const Sis::CController& MainController();

	/**

	 * Returns an index number to the controller with the given Uid

	 * First found countroller is returned.

	 * @param aUid The Uid of the controller

	 * @return Index of the controller

	 */

	TInt GetControllerReference(TUid aUid);

	/** Plans the installation of the current controller.

	Asks for user options and finds embedded controllers and 

	conditional install blocks within the current controller for

	later use

	*/

	void PlanCurrentControllerL(RPointerArray<Sis::CFileDescription>& aFilesToCapabilityCheck);

	/** set the pointer to array of device supported languages

	to the reference of  aDeviceSupportedLanguages from install machine

	*/

	void SetDeviceSupportedLanguages(RArray<TInt>& aDeviceSupportedLanguages);

	#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	// Set the planner to do it's planning activity only for component information collection. Not for installation.

	void SetInInfoCollectionMode(TBool aMode);

	// Says whether the planner plans only for component information collection.

	TBool IsInInfoCollectionMode();	

	#endif	 	

private:

	/**

	 * The constructor.

	 *

	 * @param aSisHelper          SISHelper session

	 * @param aInstallerUI        An implementation of the Installer UI

	 * @param aProvider           SISX file content provider

	 * @param aInstallationResult Result of installation

	 */

	CInstallationPlanner(RSisHelper& aSisHelper,

				RUiHandler& aInstallerUI, 

			    const CContentProvider& aProvider, 

			    CInstallationResult& aInstallationResult);

	/** 

	 * Second phase constructor.

	 * It builds the CAppInfo structure.

	 */

	void ConstructL();

private:

    /**

	 * Class used to store uid-application pairs.

     * @internalTechnology

     * @released

     */

	class CPackageApplicationPair:public CBase

		{

	public:

		static CPackageApplicationPair* NewLC(CSisRegistryPackage& aPackage, CApplication& aApplication);

		~CPackageApplicationPair();

		CSisRegistryPackage& Package() const;

		CApplication& Application();

	private:

		CPackageApplicationPair(CApplication& aApplication);

		void ConstructL(CSisRegistryPackage& aPackage);

		CSisRegistryPackage* iPackage;

		CApplication& iApplication;	

		};

	/**

	 * Class used to store some required information about a planned controller

	 * @internalTechnology

	 */

	class CFilesFromPlannedController:public CBase

		{

		public:

		static CFilesFromPlannedController* NewLC(TUid aUid, TUid aParentUid, Sis::TInstallType aInstallType, Sis::CString* aName);

		~CFilesFromPlannedController();

		/**

		 * Append a new file name into the file names list. 

		 * Ownership is transferred.

		 * @param aFileName A new file name to be added into the list

		 */

		void AppendL(HBufC* aFileName);

		/**

		 * Gets package UID 

		 * @return UID

		 */

		TUid Uid();

		/**

		 * Gets embedding package (parent) UID. Base packages have the same UID as parent UID.

		 * @return Parent UID

		 */

		TUid ParentUid();

		/**

		 * Gets the number of files in the list

		 */ 

		TInt Count();

		/**

		 * Gets the drive on which the application is being installed

		 */

		TChar Drive();

		/**

		 * Sets the drive on which the application is being installed

		 */

		void SetDrive(TChar& aDrive);

		/**

		 * Gets the name of the package

		 */

		Sis::CString* Name();

		/**

		 * Gets the install type of the package

		 */

		Sis::TInstallType InstallType();

		/**

		 * Returns whether the file name given matches with any files in the list

		 */

		TBool IsMatched(const TDesC& aFileName);

		/**

		 * Returns whether the file name given eclipses any files in the list 

		 */

		TBool IsEclipsed(const TDesC& aFileName);

		private:

		CFilesFromPlannedController(TUid aUid, TUid aParentUid, Sis::TInstallType aInstallType, Sis::CString* aName);

		//Package UID

		TUid iUid;

		//Embedding package UID

		TUid iParentUid;

		//Number of files in the list

		TInt iCount;

		//Installation drive

		TChar iDrive;

		//The list of file names to be installed

		RPointerArray<HBufC> iFileNames;

		//Install type of the package

		Sis::TInstallType iInstallType;

		//Name of the package

		Sis::CString* iName;

		};

	/**

	 * Check the filename to see if it is in apparc's import directory and if it 

	 * is add it to the plan

	 * */

	void AddApparcFilesToPlanL(const TDesC& aFilename);

	/**

	 * This function remembers that a package might need uninstalling, if we reach the end

	 * of the planning process and no upgrades for this package have been found.

	 *

	 * @param aUid				The UID of the applicattion which may need removing later.

	 * @param aApplication	The application which is upgrading the package this package was

	 *								originally embedded in. This is used to add it to the plan as embedded

	 *								in this original application.

	 */

	void NotePackageForProcessingL(CSisRegistryPackage& aPackage, CApplication& aApplication);

	/**

	 * This function is called whenever a package is upgraded. If this package UID was present

	 * on the list of packages which still need processing then it is removed.

	 *

	 * @param aUid The UID of the application which has been processed.

	 */

	void NotePackageProcessedL(TUid aUid);

	/**

	 * This function processes the remaining packages by adding them to the plan under the

	 * correct applications.

	 */

	void ProcessRemainingPackagesL();

	TBool IsPackageProcessed(TUid aUid) const;

	void PrepareEclipsableFilesListL(const Sis::CController& aController);

	void SetupExpressionEnvironmentL(const CApplication& aApplication);

	TBool IsValidSaUpgradeL(RSisRegistryWritableEntry& aRegistryEntry, const TBool aIsSisNonRemovable, const TBool aControllerFlag);

	/**

	 * Non-SU packages can Eclipse iff:

	 * a) The package uids match and 

	 * b) The package to be installed is signed for (not self signed) and 

	 * c) The package to be installed is immediate Upgrade to ROM ( SP or PU or PP over ROM 

	 *    (PA will have errored before reached here. If Not this function will panic with KErrNotSupported.)

	 *     (SA is allowed based on next condition)

	 * (or) The package to be installed is (SA+RU type or PU type ) and it has a matching ROM stub SIS file

	 * are allowed to eclipse files.	

	 * The package to be installed is not of preinstall Apps

	 */

	TBool IsValidEclipsingUpgradeL(const Sis::CController& aController, RSisRegistryWritableEntry& aRegistryEntry, const TBool aIsUpgradedRomStub);

	TBool IsEclipsableL(const TDesC& aRomFile);

	TBool ValidEclipseL(RFs& aFs, TFileName& aFileName, CApplication& aApplication);

	void WarnEclipseOverWriteL(CApplication& aApplication);

	void AdornedProcessingOfFileL(RFs& aFs, TDesC& aFileName, TDes& aUnadornedName, RPointerArray<HBufC>& aAdornedFileNamesFound);

	void HandleFileOverwritingL(TDesC& aFilename, CApplication& aApplication);

	/**

	 * Process a controller to create a plan. This processes controllers 

	 * recursively, adds files where necessary, and also adds property

	 * key,value pairs to the plan, to be inserted into the registry at a 

	 * later date.

	 */

	CApplication* ProcessControllerL(const Sis::CController& aController, TInt aCumulativeDataIndex, RPointerArray<Sis::CFileDescription>& aFilesToCapabilityCheck, TUid aParentUid);

	/**

	 * Generates an installation plan for a controller. It should be called after ProcessControllerL,

	 * which populates the lists of processed files and embedded controllers.

	 * This function relies on those lists, translates them into a plan understood by installation processor,

	 * and also processes conditional statements.

	 *

	 * @param aInstallBlock The block to process.

 	 * @param aApplication Installation plan to create.	 

	 */

	void ProcessInstallBlockL(const Sis::CInstallBlock& aInstallBlock, CApplication& aApplication, RPointerArray<Sis::CFileDescription>& aFilesToCapabilityCheck, CFilesFromPlannedController& aPlannedFiles);

	/**

	 * Processes properties, by adding them to the plan of the current CApplication.

	 *

	 * @param aProperties	The properties to add to the application plan.

	 * @param aApplication	The application plan to add the properties to.

	 */

	void ProcessPropertiesL(const Sis::CProperties& aProperties, CPlan& aPlan, CApplication& aApplication);

	/**

	 * Processes any IF THEN ELSE blocks of embbedded SIS files

	 * @param sisFileOptionsList - List of embedded options to process

	 * @param aApplication - The created application object to add files to

	 */

	void ProcessEmbeddedIfBlockL(const RPointerArray<Sis::COptions>& aSISFileOptionsList, 

				      CPlan& aPlan, CApplication& aApplication);

	void ProcessFileDescriptionL(const Sis::CFileDescription& aFileDescription, CApplication& aApplication, RPointerArray<Sis::CFileDescription>& aFilesToCapabilityCheck, CFilesFromPlannedController& aPlannedFiles);

	/**

	 * Process files to be removed as part of this install

	 *

	 */

	void ProcessFilesToRemoveL(CApplication& aApplication, RSisRegistryWritableEntry& aRegistryEntry); 

	/**

	 * Displays the upgrade dialog

	 *

	 * @param aController The controller to take the application

	 * @param aUpgradedApp The registry entry of the application being upgraded.

	 */

	void DisplayUpgradeDialogL(const TAppInfo& aCurrentAppInfo, RSisRegistryEntry& aUpgradedApp);	

	/**

	 * Gets the display language ID from the UI

	 */

	void ChooseLanguageDialogL(CContentProvider& aContent, CApplication& aApplication);

	/**

	 * Gets the drive to install onto from UI

	 */

	void ChooseDriveDialogL(CContentProvider& aContent, CApplication& aApplication, const TInt64 &aSize);

	/**

	 * Gets list of options user wishes to install from UI

	 */

	void ChooseOptionsDialogL(CContentProvider& aContent, CApplication& aApplication);

	/** Display an error dialog for the current application

	@param aType The error that occured

	@param aParam Additional information to display with the error

	*/

	void DisplayErrorL(TErrorDialog aType, const TDesC& aParam);

	/** Determine whether it is necessary to display a drive selection 

	dialog 

	@param aInstallBlock The install block to search for files that require user drive selection

	@return ETrue if any files require user drive selection, EFalse if they are all hard coded

	*/

	TBool IsUserDriveSelectionRequiredL(const Sis::CInstallBlock& aInstallBlock) const;

	/** Reclaim the space used by an older version of this application

	that will be removed before copying files for the new version

	@param aApplication The application with the list of files to add / remove

	*/

	void ReclaimUninstallSpaceL(const CApplication& aApplication);

	/** Check that a file being added does not match or eclipse another file

	being added from another controller in the plan.

	@param aFileName The file to check for clashes with previous embedded

	                 controller.

	@leave KErrAlreadyExists If the file exists with the same name, drive and

	                         path in a previously planned controller.

	@leave KErrInvalidEclipse If the file exists with the same name and path

	                          but a different drive in a previously planned

	                          controller.

	*/

	void CheckFilesFromPlannedControllersL(const TDesC& aFileName, CFilesFromPlannedController& aPlannedFiles) const;

	/**

	 *

	 * Check if the augmentation being installed is an upgrade to an existing

	 * augmentation, or an entirely new augmenation being installed.

	 *

	 * @param aController The controller of the SIS file being installecd

	 * @param aRegistryEntry The registry entry for the base package being upgraded

	 * @param aRegistrySession The registry session associated with the entry

	 * @return ETrue if this is an SP upgrade, EFalse otherwise

	 *

	 */

	TBool IsAugmentationUpgradeL(const Sis::CController& aController,

								 RSisRegistryEntry& aRegistryEntry,

								 RSisRegistrySession& aRegistrySession);

	/**

	 *

	 * Check if the augmentation being installed is an upgrade to a planned

	 * augmentation, or an entirely new augmenation being installed.

	 *

	 * @param aController The controller of the SIS file being installecd

	 * @return ETrue if this is an SP upgrade, EFalse otherwise

	 *

	 */

	TBool IsAugmentationUpgrade(const Sis::CController& aController);

	/**

	 * Check the planned controllers' array to find out if there is any controller that

	 * has got the same UID with the controller being processed. If the current

	 * controller is an partial upgrade or standard patch, its base package must 

	 * be already planned.

	 *

	 * @param aUid The UID of the SIS file being processed

	 * @param aIndex Index of the base package

	 * @param aParentUid The UID of the base package

	 * @return ETrue if there is any controller with the same UID in the list,

	 *		   EFalse otherwise

	 */

	 TBool IsPlannedControllerL(const Sis::CController& aController, TInt& aIndex, TUid aParentUid);

	 /**

	 * Sets the flag to indicate if an installation package contains a supported_language

	 * token and if there are matching languages

	 * @param aInstallBlock 

	 * @param aApplication 

	 * @param aContent 

	 */

	 void SetDeviceLanguagesL(const Sis::CInstallBlock& aInstallBlock, CApplication& aApplication, const CContentProvider& aContent);

	 /**

	 Checks the SIS is allowed to install/upgrade to eclipse the ROM storage

	 though the ROM stub exist or not

	 @param aApplication The application of the SIS file being installed

	 @return ETrue if the file allowed to install based on SU Cert Rules, EFalse otherwise

	 */

	TBool IsValidSystemUpgradeL(const CApplication& aApplication);

private:

	/** Handle to SISHelper */

	RSisHelper& iSisHelper;

	/**

	 * Abstraction layer over the SISX controller

	 */

	const CContentProvider& iContentProvider;

	/**

	 * Index of language to display messages to user in

	 */

	TInt iDisplayLanguageIndex;

	/**

	 * Information about the application being installed.

	 * This is passed to the UI callbacks.

	 */

	CAppInfo* iAppInfo;