/*

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

* Declares entry classes for Software Components Registry interface.

*

*/

/**

 @file

 @publishedAll

 @released

*/

#ifndef SCRENTRIES_H

#define SCRENTRIES_H

#include <e32base.h>

#include <s32strm.h>

#include <f32file.h> 

#include <usif/usifcommon.h>

namespace Usif

    {

    // CONSTANTS

    /**

        KUnspecifiedLocale means that the locale is not specified and locale resolving will be done by SCR.

        First, the current locale with its downgraded languages (@see BaflUtils::GetDowngradePathL) is tried 

        by SCR. If no value is found, then non-localized values are searched for. 

     */

    static const TLanguage KUnspecifiedLocale = TLanguage(-1);

    /**

        KNonLocalized means that only non-localized values are looked up by SCR.

     */

    static const TLanguage KNonLocalized = TLanguage(0); 

    // CLASSES

    NONSHARABLE_CLASS(CGlobalComponentId) : public CBase

    /**

        Encapsulates the global software component identifier which is a named, component level and nullable string.

        that an installer may use to specify a deterministic identifier for the component that is unique within 

        the context of that software type. This global component id would be the package UID for native applications 

        or the midlet-names for Java etc 

        The global component id is consistent and equal on all devices. It is used to state dependencies 

        and to check for the presence of installed software components of arbitrary types without each installer having 

        to be aware of every other installers naming scheme.        

     */

        {

    public:

        /**

            Creates an empty global software component ID object.

            @return A pointer to the newly allocated global software component ID object, if creation is successful.

                    The pointer is also put onto the cleanup stack.

         */

        IMPORT_C static CGlobalComponentId* NewLC();

        /**

            Creates a global software component ID object.

            @param aGlobalIdName A deterministic identifier for the component that is unique within the context of that software type.

            @param aUniqueSwTypeName Non-localized unique software type name, such as @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava.

            @return A pointer to the newly allocated global software component ID object, if creation is successful.

         */ 

        IMPORT_C static CGlobalComponentId* NewL(const TDesC& aGlobalIdName, const TDesC& aUniqueSwTypeName);

        /**

            Creates a global software component ID object.

            @param aGlobalIdName A deterministic identifier for the component that is unique within the context of that software type.

            @param aUniqueSwTypeName Non-localized unique software type name, such as @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava.

            @return A pointer to the newly allocated global software component ID object, if creation is successful.

                    The pointer is also put onto the cleanup stack.

         */ 

        IMPORT_C static CGlobalComponentId* NewLC(const TDesC& aGlobalIdName, const TDesC& aUniqueSwTypeName);

        /**

            Creates a global software component ID object from a stream.

            @param aStream The stream to read the software component entry object from

            @return A pointer to the newly allocated global software component ID object, if creation is successful.

            @internalComponent

         */

        IMPORT_C static CGlobalComponentId* NewL(RReadStream& aStream);

        /**

            Externalises this CGlobalComponentId object to a write stream.

            @param aStream The stream to which the object is externalised.

            @internalComponent

         */

        IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

        /**

            Internalises this CGlobalComponentId object from a read stream.

            @param aStream The stream from which the object is internalised.

            @internalComponent

         */

        IMPORT_C void InternalizeL(RReadStream& aStream);

        /** @return The global id name part (@see CGlobalComponentId::NewLC) of the global component id.*/

        IMPORT_C const TDesC& GlobalIdName() const;

        /** @return The software type name part (@see CGlobalComponentId::NewLC) of the global component id. */

        IMPORT_C const TDesC& SoftwareTypeName() const;

        IMPORT_C ~CGlobalComponentId();

    private:

        CGlobalComponentId();

        void ConstructL(const TDesC& aGlobalIdName, const TDesC& aSoftwareTypeName);

    private:

        HBufC* iGlobalIdName;       ///< The global id name part of the global component id.

        HBufC* iSoftwareTypeName;   ///< The software type name part of the global component id.

        };

    NONSHARABLE_CLASS(CVersionedComponentId) : public CBase

    /**     

        Class that represents a continuous set of versions for a particular component.

        This class is used for specifying dependencies, where a dependant component requires 

        specific version(s) of the supplier to be present on the system. The version information 

        is optional, i.e. this class can be used to represent any version of a component.

        If this class is used to represent a dependant component, it specifies the range of versions

        of the dependency relationship defined by the dependant component. 

     */

        {

    public:

        /**

            Creates an empty version component identifier object.

            @return A pointer to the newly allocated version component identifier object, if creation is successful.

                    The pointer is also put onto the cleanup stack.

         */

        IMPORT_C static CVersionedComponentId* NewLC();

        /**

            Creates a versioned component identifier object.

            N.B. The version parameters are optional and used to set the lower and upper limit of the version range. 

                 It is also possible to set only an upper limit or a lower limit or none. If only one version 

                 parameter is supplied then a lower limit will be set. In this case, there is no upper limit. 

                 If the first version parameter is upplied with KNullDesC, then the second version parameter

                 will be used to set an upper limit.

            @param aGlobalId The global software component identifier.

            @param aVersionFrom The first version of the specified version range.

            @param aVersionTo The last version of the specified version range.

            @return A pointer to the newly allocated versioned component identifier object, if creation is successful.

         */ 

        IMPORT_C static CVersionedComponentId* NewL(const CGlobalComponentId& aGlobalId, const TDesC* aVersionFrom=NULL, const TDesC* aVersionTo=NULL);

        /**

            Creates a versioned component identifier object.

            For more information about the version parameters look at @see CVersionedComponentId::NewLC().

            @param aGlobalId The global software component identifier.

            @param aVersionFrom The first version of the specified version range.  

            @param aVersionTo The last version of the specified version range.

            @return A pointer to the newly allocated versioned component identifier object, if creation is successful.

                    The pointer is also put onto the cleanup stack.

         */ 

        IMPORT_C static CVersionedComponentId* NewLC(const CGlobalComponentId& aGlobalId, const TDesC* aVersionFrom=NULL, const TDesC* aVersionTo=NULL);

        /**

            Creates a versioned component identifier object from a stream.

            @param aStream The stream to read the versioned component identifier object from

            @return A pointer to the newly allocated versioned component identifier object, if creation is successful.

            @internalComponent

          */

        IMPORT_C static CVersionedComponentId* NewL(RReadStream& aStream);

        /**

            Internalises this CVersionedComponentId object from a read stream.

            @param aStream The stream from which the object is internalised.

            @internalComponent

         */

        IMPORT_C void InternalizeL(RReadStream& aStream);

        /**

            Externalises this CVersionedComponentId object to a write stream.

            @param aStream The stream to which the object is externalised.

            @internalComponent

         */

        IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

        /** @return The global id of the versioned component. */

        IMPORT_C const CGlobalComponentId& GlobalId() const;

        /** @return The first version of the specified version range. NULL, if there is no lower limit for the version range. */

        IMPORT_C const TDesC* VersionFrom() const;

        /** @return  The last version of the specified version range. NULL, if there is no upper limit for the version range. */

        IMPORT_C const TDesC* VersionTo() const;

        IMPORT_C ~CVersionedComponentId();

    private:

        CVersionedComponentId();

        void ConstructL(const CGlobalComponentId& aGlobalId, const TDesC* aVersionFrom, const TDesC* aVersionTo);

    private:

        CGlobalComponentId* iGlobalId;  ///< The global id of the versioned component identifier.

        HBufC* iVersionFrom;        ///< The first version of the specified version range.

        HBufC* iVersionTo;      ///< The last version of the specified version range.

        };

    class CComponentEntry : public CBase

    /**

        Class that represents a software component entry stored in the SCR.

     */

        {

        friend class CScrRequestImpl;

    public:

        /**

            Creates an empty software component entry object.

            @return A pointer to the newly allocated software component object, if creation is successful.

         */

        IMPORT_C static CComponentEntry* NewL();

        /**

            Creates an empty software component entry object.

            @return A pointer to the newly allocated software component object, if creation is successful.

                    The pointer is also put onto the cleanup stack.

         */

        IMPORT_C static CComponentEntry* NewLC();

        /**

            Creates a software component entry object from a stream.

            @param aStream The stream to read the software component entry object from

            @return A pointer to the newly allocated software component entry object, if creation is successful.

            @internalComponent

         */

        IMPORT_C static CComponentEntry* NewL(RReadStream& aStream);

        /**

            Creates a software component entry object.

            @param aId  The unique ID of the software component.

            @param aName The name of of the software component.

            @param aVendor The vendor name of the software component.

            @param aSwType The software type of the component.

            @param aGlobalId The globally unique identifier of the component.

            @param aRemovable Whether the component is removable. ETrue means the component is removable.

            @param aSize The total size of the component at installation time in bytes.

            @param aScomoState The SCOMO state of the component.

            @param aInstalledDrives The set of drives that files for the software component were installed to. 

            @param aVersion The version identifier of the software component.

            @param aInstallTime The formatted install time string. The format is as following: YYYYMMDD:HHMMSS

            @param aDrmProtected Whether the component is DRM protected. ETrue means the component is DRM protected.

            @param aHidden Whether the component is displayed in the list of installed components. ETrue means the component is hidden.

            @param aKnownRevoked Whether the component has been revoked. ETrue means that a revocation check was

                                   performed during or after the installation and the component was found to be revoked.

            @param aOriginVerified Whether the installer has verified the originator of the component. ETrue means the installer 

                                    has verified the originator of the software component by using appropriate checking mechanisms.

            @return A pointer to the newly allocated software component object, if creation is successful.

            @internalComponent

         */

        IMPORT_C static CComponentEntry* NewL(const TComponentId& aId, const TDesC& aName, const TDesC& aVendor, const TDesC& aSwType,

                                              const TDesC& aGlobalId, TBool aRemovable, TInt64 aSize, const TScomoState& aScomoState,

                                              const TDriveList& aInstalledDrives, const TDesC& aVersion, const TDesC& aInstallTime,

                                              TBool aDrmProtected, TBool aHidden, TBool aKnownRevoked, TBool aOriginVerified);

        /**

            Creates a software component entry object.

            @param aId  The unique ID of the software component.

            @param aName The name of of the software component.

            @param aVendor The vendor name of the software component.

            @param aSwType The software type of the component.

            @param aGlobalId The globally unique identifier of the component.

            @param aRemovable Whether the component is removable. ETrue means the component is removable.

            @param aSize The total size of the component at installation time in bytes.

            @param aScomoState The SCOMO state of the component.

            @param aInstalledDrives The set of drives that files for the software component were installed to. 

            @param aVersion The version identifier of the software component.

            @param aInstallTime The formatted install time string. The format is as following: YYYYMMDD:HHMMSS  

            @param aDrmProtected Whether the component is DRM protected. ETrue means the component is DRM protected.

            @param aHidden Whether the component is displayed in the list of installed components. ETrue means the component is hidden.

            @param aKnownRevoked Whether the component has been revoked. ETrue means that a revocation check was

                                   performed during or after the installation and the component was found to be revoked.

            @param aOriginVerified Whether the installer has verified the originator of the component. ETrue means the installer 

                                    has verified the originator of the software component by using appropriate checking mechanisms.

            @return A pointer to the newly allocated software component object, if creation is successful.

                           The pointer is also put onto the cleanup stack.

            @internalComponent

         */

        IMPORT_C static CComponentEntry* NewLC(const TComponentId& aId, const TDesC& aName, const TDesC& aVendor, const TDesC& aSwType, 

                                               const TDesC& aGlobalId, TBool aRemovable, TInt64 aSize, const TScomoState& aScomoState, 

                                               const TDriveList& aInstalledDrives, const TDesC& aVersion, const TDesC& aInstallTime,

                                               TBool aDrmProtected, TBool aHidden, TBool aKnownRevoked, TBool aOriginVerified);

        IMPORT_C ~CComponentEntry();

        /**

            Externalises this CComponentEntry object to a write stream.

            @param aStream The stream to which the object is externalised.

            @internalComponent

        */

        IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

        /**

            Internalises this CComponentEntry object from a read stream.

            @param aStream The stream from which the object is internalised.

            @internalComponent

        */

        IMPORT_C void InternalizeL(RReadStream& aStream);

        /** @return The unique ID of the software component. */

        IMPORT_C const TComponentId& ComponentId() const; 

        /** @return The name of the software component. */

        IMPORT_C const TDesC& Name() const;

        /** @return The vendor name of the software component. */

        IMPORT_C const TDesC& Vendor() const;

        /** @return The software type name of the software component, e.g @see Usif::KSoftwareTypeNative. */

        IMPORT_C const TDesC& SoftwareType() const;

        /** @return Globally unique component identifier. */

        IMPORT_C const TDesC& GlobalId() const;

        /** @return Whether the software component is removable. ETrue means it is removable. */

        IMPORT_C TBool IsRemovable() const;

        /** @return The total size of the component at installation time in bytes. */

        IMPORT_C TInt64  ComponentSize() const;

        /** @return The SCOMO state of the software component. @see Usif::TScomoState */

        IMPORT_C const TScomoState& ScomoState() const;

        /** @return The set of drives that files for the software component were installed to. */

        IMPORT_C const TDriveList& InstalledDrives() const;

        /** @return The version identifier of the software component. */

        IMPORT_C const TDesC& Version() const;

        /** @return The install time of the component. */

        IMPORT_C TTime InstallTimeL() const;

        /** @return  Whether the component is DRM protected. ETrue means the component is DRM protected.*/

        IMPORT_C TBool IsDrmProtected() const;

        /** @return  Whether the component is hidden in the list of installed components. ETrue means the component is hidden. */

        IMPORT_C TBool IsHidden() const;

        /** @return  Whether the component has been revoked. ETrue means that a revocation check was performed

                  during or after the installation and the component was found to be revoked.

         */

        IMPORT_C TBool IsKnownRevoked() const;

        /** @return  Whether the installer has verified the originator of the component. ETrue means the installer 

                         has verified the originator of the software component by using appropriate checking mechanisms.

         */

        IMPORT_C TBool IsOriginVerified()const;

    private:

        CComponentEntry();

        void ConstructL(const TComponentId& aId, const TDesC& aName, const TDesC& aVendor, const TDesC& aSwType, const TDesC& aGlobalId, TBool aRemovable, 

                        TInt64 aSize, const TScomoState& aScomoState, const TDriveList& aInstalledDrives, const TDesC& aVersion, const TDesC& aInstallTime,

                        TBool aDrmProtected, TBool aHidden, TBool aKnownRevoked, TBool aOriginVerified);

    private:

        TComponentId iComponentId;   ///< The unique id of the software component.

        HBufC* iName;                ///< Name of the software component.

        HBufC* iVendor;              ///< Vendor of the software component.

        HBufC* iSwType;              ///< Software type name of the component.

        HBufC* iGlobalId;            ///< Globally unique component identifier.

        TBool iRemovable;            ///< Whether the component is removable.

        TInt64 iSize;                ///< The total size of the component at installation time in bytes.

        TScomoState iScomoState;     ///< SCOMO state of the component.

        TDriveList iInstalledDrives; ///< The set of drives that files for the software component were installed to.

        HBufC* iVersion;             ///< Version identifier of the software component

        HBufC* iInstallTime;         ///< The install time of the component. 

        TBool iDrmProtected;         ///< Whether the component is DRM protected.

        TBool iHidden;               ///< Whether the component is hidden in the list of installed components.

        TBool iKnownRevoked;         ///< Whether the component has been revoked.

        TBool iOriginVerified;       ///< Whether the installer has verified the originator of the component.

        };

    class CPropertyEntry : public CBase

    /**

        Abstract base class for a software component property entry. 

        Specifies the type of a software component property. Before getting a property value, 

        the base property object must be converted to a derived property object (e.g. CIntPropertyEntry). 

     */

        {

    public:

    /** 

        Enumeration to indicate the type of the property.

     */

    enum TPropertyType

        {

        EBinaryProperty = 1,    ///< The property value is binary data. See @see CBinaryPropertyEntry.

        EIntProperty,       ///< The property value is integer. See @see CIntPropertyEntry.

        ELocalizedProperty,  ///< The property is a localizable string. See @see CLocalizablePropertyEntry.

        };  

    public:

        /**

            Creates a base software component property object from a stream.

            @param aStream The stream to read the software property object from.

            @return A pointer to the newly allocated software property object, if creation is successful.

            @internalComponent

         */

        IMPORT_C static CPropertyEntry* NewL(RReadStream& aStream);

        /** @return The name of the property. */

        IMPORT_C const TDesC& PropertyName() const;

        /** Virtual destructor for the component property object*/

        IMPORT_C virtual ~CPropertyEntry();

        /**

            Externalises a base/derived property object to a write stream.

            @param aStream The stream to which the object is externalised.

            @internalComponent

        */

        IMPORT_C void ExternalizeL(RWriteStream& aStream) const;         

        /** @return The type of the property object. Implemented by derived classes. */

        virtual CPropertyEntry::TPropertyType PropertyType() const = 0;

    protected:

        CPropertyEntry();

        void ConstructL(const TDesC& aPropertyName);

    private:

        virtual void DoExternalizeL(RWriteStream &aStream) const = 0;

        virtual void DoInternalizeL(RReadStream& aStream) = 0;

    private:    

        HBufC* iPropertyName;         ///< The name of the property entry.

        };

    class CIntPropertyEntry : public CPropertyEntry

    /**

        Class that represents an integer component property. 

     */

        {

    public:

        /**

            Creates an integer component property object.

            @param aPropertyName The name of the property.

            @param aPropertyValue The value of the property.

            @return A pointer to the newly allocated component property object, if creation is successful.

         */

        IMPORT_C static CIntPropertyEntry* NewL(const TDesC& aPropertyName, TInt64 aPropertyValue);

        /**

            Creates an integer component property object.

            @param aPropertyName The name of the property.

            @param aPropertyValue The value of the property.

            @return A pointer to the newly allocated component property object, if creation is successful.

                    The pointer is also put onto the cleanup stack.

         */

        IMPORT_C static CIntPropertyEntry* NewLC(const TDesC& aPropertyName, TInt64 aPropertyValue);

        IMPORT_C ~CIntPropertyEntry();

        /**

            The implementation of pure virtual function from @see Usif::CPropertyEntry.

            @return The type of the property object.

         */

        IMPORT_C CPropertyEntry::TPropertyType PropertyType() const;

        /** @return The 32-bit integer value. */ 

        IMPORT_C TInt IntValue();

        /** @return The 64-bit integer value. */ 

        IMPORT_C TInt64 Int64Value();

    private:

        void DoExternalizeL(RWriteStream& aStream) const;

        void DoInternalizeL(RReadStream& aStream);

        CIntPropertyEntry();

        CIntPropertyEntry(TInt64 aPropertyIntValue);