/*

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

* As specified in SGL.GT0188.251

*

*/

/**

 @file 

 @internalComponent

 @released

*/

#ifndef __SISCONTROLLER_H__

#define __SISCONTROLLER_H__

#include "sisinfo.h"

#include "sissupportedoptions.h"

#include "sissupportedlanguages.h"

#include "sisprerequisites.h"

#include "sisproperties.h"

#include "sislogo.h"

#include "sisinstallblock.h"

#include "signaturecertchaindata.h"

#include "sisdataindex.h"

#include "sequence.h"

#include "version.h"

class CSISController : public CStructure <CSISFieldRoot::ESISController>

	{

public:

	typedef CSequence <CSignatureCertChainData, CSISFieldRoot::ESISSignatureCertificateChain> SignatureCertChainList;

public:

	/**

	 * Default controller

	 */

	CSISController ();

	/**

	 * Copy constructor

	 */

	CSISController (const CSISController& aInitialiser);

public:

	/**

	 * This function verifies the structure

	 * @param aLanguage - language

	 */ 

	virtual void Verify (const TUint32 aLanguages) const;

	/**

	 * Reads the file and internalize the content

	 * @param aFile Stream which contains the controller.

	 * @param aContainerSize controller size.

	 * @param aArrayType type of array. ESISUndefined if it is not an array.

	 */ 

	virtual void Read (TSISStream& aFile, const CSISFieldRoot::TFieldSize& aContainerSize, const CSISFieldRoot::TFieldType aArrayType = CSISFieldRoot::ESISUndefined);

	/**

	 * Write the content of the controller into the file.

	 * @param aFile Stream where the content needs to be written.

	 * @param aIsArrayElement bool which checks if the controller is part of an array.

	 */

	virtual void Write (TSISStream& aFile, const bool aIsArrayElement) const;

	/**

	 * @return name of the class.

	 */

	virtual std::string Name () const;

	/**

	Loads the Stub SIS Controller file. This function also checks if the file is a valid 

	Stub SIS Controller. 

	To ensure that the file reading should start from the length field of controller block 

	in the  read default type parameter is passed as CSISFieldRoot::ESISController

	@param aFileName	Stub SIS Controller file name

	*/

	void Load (const std::wstring& aFileName);

	/**

	 * Add a new language to the controller.

	 * @param aLan - language to be added.

	 */ 

	void AddLanguage (const CSISLanguage::TDialect aLan);

	/**

	 * @return total number of languages present in the controller.

	 */

	TUint32 LanguageCount () const;

	/**

	 * Checks whether there are any langauge specified for the controller.

	 * @return true if language is specified else false.

	 */ 

	bool AreLanguagesSpecified () const;

	/**

	 * Adds a new property into the controller.

	 * @param aKey - key of the property

	 * @param aValue - Value for the corresponding key

	 */

	void AddProperty (const CSISProperty::TKey aKey, const CSISProperty::TValue aValue);

	/**

	 * @return UID of the SIS file.

	 */

	CSISUid::TUid UID1 () const;

	/**

	 * Set the UID for the controller.

	 * @param aUID new UID for the SIS.

	 */

	void SetUID (const CSISUid::TUid aUID);

	/**

	 * Add package name to the existing list of package names for the controller.

	 * @param aPackageName - package name

	 */ 

	void AddName (const std::wstring& aLan)	;

	/**

	 * Add vendor name to the existing list of vendor names for the controller.

	 * @param aVendorName vendor name.

	 */

	void AddVendorName (const std::wstring& aLan);

	/**

	 * Set the unique vendor name for the controller.

	 * @param VendorUniqueName unique vendor name.

	 */

	void SetVendorUniqueName (const std::wstring& aVendorUniqueName);

	/**

	 * Set SIS version

	 * @param aVersion new version to be set.

	 */

	void SetVersion (const TVersion& aVersion);

	/**

	 * Each SIS has n number of package dependencies and each package dependency 

	 * has m number of dependency names, where n & m >= 0. 

	 * This function will add the dependency name to the existing list of 

	 * names of the last package dependency.

	 * @param aName new dependency name

	 */

	void AddDependencyName (const std::wstring& aName);

	/**

	 * Add a new package dependency into the list of existing package dependencies.

	 * @param aUID - UID of the package

	 * @param aFrom - From version 

	 * @param aTo - To version

	 */ 

	void AddDependency (const CSISUid::TUid aUID, const TVersion& aFrom, const TVersion& aTo);

	/**

	 * Each SIS has n number of target dependencies and each target dependency 

	 * has m number of target dependency names, where n & m >= 0. 

	 * This function will add the target dependency name to the existing list of 

	 * names of the last target dependency.

	 * @param aName new target dependency name

	 */

	void AddTargetName (const std::wstring& aName);

	/**

	 * Add a new target dependency into the list of existing tergate dependencies.

	 * @param aUID - UID of the target

	 * @param aFrom - From version 

	 * @param aTo - To version

	 */ 

	void AddTarget (const CSISUid::TUid aUID, const TVersion& aFrom, const TVersion& aTo);

	/**

	 * Add new option name to the last supported option.

	 * @param aName option name

	 */

	void AddOptionName (const std::wstring& aName);

	/**

	 * Creates a new object of supported options and pushes it into the existing list.

	 */

	void AddOption ();

	/**

	 * Adds a new install

	 * @param new installation flag.

	 */

	void AddInstallFlag(const TUint8 aFlag);

	/**

	 * Converts the string into installation option (only if its valid) and sets the

	 * option to last file of controller's installblock.

	 * @param aOption installation option string.

	 * @return returns the installation option

	 */

	CSISFileDescription::TSISInstOption InterpretOption (const std::wstring& aOption);

	/**

	 * Converts the string into installation type (only if its valid) and sets the

	 * type to controller.

	 * @param aOption installation type string.

	 * @return returns the installation type.

	 */

	CSISInfo::TSISInstallationType InterpretType (const std::wstring& aOption);

	/**

	 * Only preinstalled apps must be compressed. 

	 * @return false if the sis is preinstalled app or preinstalled patch, else true

	 */

	bool MustRejectCompression () const;

	/**

	 * Set MIME type of the last file of the base controller's install block.

	 * @param aMimeType MIME type

	 */

	void SetMimeType (const std::wstring& aMimeType);

	/**

	 * Add a new CSISIf object to the existing list in the controller's installblock.

	 */

	void AddIf ();

	/**

	 * @return returns the last CSISIf block present in the controller's installblock.

	 */

	const CSISIf& If () const;

	/**

	 * @return returns the last CSISIf block present in the controller's installblock.

	 */

	CSISIf& If ();

	/**

	 * @return install block of the controller.

	 */

	const CSISInstallBlock& InstallBlock () const;

	/**

	 * @return install block of the controller.

	 */

	CSISInstallBlock& InstallBlock ();

	/**

	 * Sets the controller's data index.

	 * @param aIndex new index of the controller

	 */

	void SetDataIndex (const TUint32 aIndex);

	/**

	 * @return data unit index of the controller

	 */

	TUint32 DataIndex () const;

	/**

	 * Sets the logo into the base controller

	 * @param aMime MIME type of the logo file.

	 * @param aTarget destination for the logo file.

	 * @param aFileName file name of the logo file.

	 * @param aDataUnit data unit where the logo file will be added

	 */

	void SetLogo (const std::wstring& aMime, const std::wstring& aTarget, const TUint32 aFileIndex, const CSISDataUnit& aDataUnit);

	/**

	 * Retrieves the instance of logo class

	 */

	inline const CSISLogo& Logo() const;

	/**

	 * Embeds the SIS file into the controller.

	 * @param aEmbed Controller to be embedded

	 * @param aIndex reserved for future use

	 */

	void Embed (class CSISController& aEmbed, const TUint32 aIndex);

	/**

	 * Set the compressed and uncompressed sizes of the logo file.

	 * @param aCompressedSize compressed size.

	 * @param aUncompressedSize uncompressed size.

	 */

	void SetLogoSizes (const TUint64 aCompressedSize, const TUint64 aUncompressedSize);

   	/**

   	 * Retrieves the Language of the controller pointed by language index.

   	 * @param aIndex language index

   	 * @return language

   	 */

	CSISLanguage::TLanguage Language (const TUint32 aIndex) const;

	/**

	 * Set the current time as the sis creation time.

	 */

	void SetNow ();

	/**

	 * Removes the most recent signature from the controller.

	 */

	void RemoveSignature ();

	/**

	 * Gets the signature count from the controller.

	 * @return signature count.

	 */

	inline int	SignatureCount() const;

	/**

	 * Returns the buffer containing controller data.

	 * @return raw controller buffer.

	 */

	const TUint8* RawBuffer () const;

	/**

	 * Buffer size which is actually read. Doesn't include data whose reading is skipped.

	 * @return buffer size.

	 */

	TUint64 BufferSize () const;

	/**

	 * Raw buffer size. The entire controller size.

	 * @return buffer size.

	 */

	TUint64 RawBufferSize () const;

	/**

	 * For calculating controller hash signature and data unit index is skipped.

	 * This function returns the length of the controller minus signature and data

	 * unit length.

	 * @return buffer size.

	 */

	TUint64 ControllerSizeForHash() const;

	/**

	 * Add a new signature chain into the controller.

	 * @param aSISSigCertChain signature chain.

	 */

	void AddSignatureChain(CSignatureCertChainData& aSISSigCertChain);

	/**

	 * Adds package entry related to this controller.

	 * @param aStream stream into which the package details need to be written.

	 * @param aVerbose If this option is set then detail description of pkg

	 * 			will be written into the stream.

	 */

	void AddPackageEntry(std::wostream& aStream, bool aVerbose) const;

	/**

	 * Retrieves the CSignatureCertChainData pointed by chain index.

	 * @param aIndex index of the chain in the controller.

	 * @return CSignatureCertChainData object (signature and cert chain container)

	 */

	inline const CSignatureCertChainData& SignatureCertChain(TUint32 aIndex) const;

	/**

	 * Prerequisites for this controller

	 * @return CSISPrerequisites

	 */

	inline const CSISPrerequisites& Prerequisites() const;

	/**

	 * Properties of the controller class.

	 * @return CSISProperties

	 */

	inline const CSISProperties& Properties() const;

	/**

	 * Retrieves the CSISInfo class which holds the basic information of the sis file.

	 * @return CSISInfo

	 */

	inline const CSISInfo& SISInfo() const;

	/**

	 * Retrieves the CSISLogo class which holds the log information.

	 * @return CSISLogo

	 */

	inline const CSISLogo& SISLogo() const;

	/**

	 * Supported option count.

	 * @return option count.

	 */

	inline TUint32 SupportedOptionCount() const;

	/**

	 * Retrieve controller ID

	 */

	inline int GetControllerID() const;

	/**

	 * If this function is called then it will skip reading of some class members

	 */

	static void SetSkip ();

private:

	void InsertMembers ();

	int DeleteDirectory (std::string& aDirectory);

private:

	// change these ? change Read and Write (for SignSIS) :

	CSISInfo				iInfo;

	CSISSupportedOptions	iSupportedOptions;

	CSISSupportedLanguages	iSupportedLanguages;

	CSISPrerequisites		iPrerequisites;

	CSISProperties			iProperties;

	CSISLogo				iLogo;

	CSISInstallBlock		iInstallBlock;

	SignatureCertChainList	iSignatures;

	CSISDataIndex			iDataIndex;

	TUint8*					iRawBuffer;

	TUint64					iRawBufferSize;

	TUint64					iBufferSize;

	/**

	 * Used distinguish between other embeded controllers.

	 * Base controllers ID will be -1 and embedded controllers

	 * ID starts with 0

	 */

	int						iControllerID; 

	static int				iLastCtlID; // Last allocated controller's ID.

	static bool				iSkip;

	};

inline CSISController::CSISController () :

		iRawBuffer (NULL),

		iRawBufferSize(0),

		iBufferSize (0),

		iLogo (false)

	{

	InsertMembers ();

	}

inline void CSISController::AddLanguage (const CSISLanguage::TDialect aLan)	

	{ 

	iSupportedLanguages.AddLanguage (aLan); 

	}

inline TUint32 CSISController::LanguageCount () const						

	{ 

	return iSupportedLanguages.LanguageCount (); 

	}

inline bool CSISController::AreLanguagesSpecified () const					

	{ 

	return iSupportedLanguages.AreLanguagesSpecified (); 

	}

inline void CSISController::AddProperty (const CSISProperty::TKey aKey, const CSISProperty::TValue aValue)

	{ 

	iProperties.AddProperty (aKey, aValue); 

	}

inline CSISUid::TUid CSISController::UID1 () const								

	{ 

	return iInfo.UID1 (); 

	}

inline void CSISController::SetUID (const CSISUid::TUid aUID)					

	{ 

	iInfo.SetUID (aUID); 

	}

inline void CSISController::AddName (const std::wstring& aLan)					

	{ 

	iInfo.AddName (aLan); 

	}

inline void CSISController::AddVendorName (const std::wstring& aLan)				

	{ 

	iInfo.AddVendorName (aLan); 

	}

inline void CSISController::SetVersion (const TVersion& aVersion)

	{ 

	iInfo.SetVersion (aVersion); 

	}

inline void CSISController::AddDependencyName (const std::wstring& aName)			

	{ 

	iPrerequisites.AddDependencyName (aName); 

	}

inline void CSISController::AddTargetName (const std::wstring& aName)				

	{ 

	iPrerequisites.AddTargetName (aName); 

	}

inline void CSISController::AddOptionName (const std::wstring& aName)				

	{ 

	iSupportedOptions.AddOptionName (aName); 

	}

inline void CSISController::AddOption ()										

	{ 

	iSupportedOptions.AddOption (); 

	}

inline CSISFileDescription::TSISInstOption CSISController::InterpretOption (const std::wstring& aOption)

	{ 

	return iInstallBlock.InterpretOption (aOption); 

	}

inline CSISInfo::TSISInstallationType CSISController::InterpretType (const std::wstring& aOption)

	{

	return iInfo.InterpretType (aOption); 

	}

inline bool CSISController::MustRejectCompression () const

	{

	return iInfo.MustRejectCompression (); 

	}

inline void CSISController::SetMimeType (const std::wstring& aMimeType)			

	{ 

	iInstallBlock.SetMimeType (aMimeType); 

	}

inline void CSISController::AddIf ()												

	{ 

	iInstallBlock.AddIf (); 

	}

inline const CSISIf& CSISController::If () const									

	{ 

	return iInstallBlock.If (); 

	}

inline CSISIf& CSISController::If ()												

	{ 

	return iInstallBlock.If (); 

	}

inline const CSISInstallBlock& CSISController::InstallBlock () const				

	{ 

	return iInstallBlock; 

	}

inline CSISInstallBlock& CSISController::InstallBlock ()							

	{ 

	return iInstallBlock; 

	}

inline void CSISController::SetDataIndex (const TUint32 aIndex)					

	{ 

	iDataIndex.SetIndex (aIndex);