installationservices/swcomponentregistry/inc/screntries.h
changeset 42 d17dc5398051
parent 25 98b66e4fb0be
child 55 ac7f90a6ff4c
--- a/installationservices/swcomponentregistry/inc/screntries.h	Thu May 27 12:58:35 2010 +0300
+++ b/installationservices/swcomponentregistry/inc/screntries.h	Fri Jun 11 13:45:18 2010 +0300
@@ -32,1043 +32,1077 @@
 #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);
+    {
+    // 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);
+        /**
+            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.
-		};
+        /**
+            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);
-		void ConstructL(const TDesC& aPropertyName);
-		static CIntPropertyEntry* NewLC();
-		friend CPropertyEntry* CPropertyEntry::NewL(RReadStream& aStream);
-		
-	private:
-		TInt64 iIntValue;   ///< The integer property value.
-		};
-	
-	class CBinaryPropertyEntry : public CPropertyEntry
-	/**
-		Class that represents a binary non-localizable 8-bit descriptor component property.		
-	*/
-		{
-	public:
-		/**
-			Creates a binary 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 CBinaryPropertyEntry* NewL(const TDesC& aPropertyName, const TDesC8& aPropertyValue);
-		
-		/**
-			Creates a binary 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 CBinaryPropertyEntry* NewLC(const TDesC& aPropertyName, const TDesC8& aPropertyValue);
-		
-		IMPORT_C ~CBinaryPropertyEntry(); 
-		
-		/**
-			The implementation of pure virtual function from @see Usif::CPropertyEntry.
-			@return The type of the property object.
-		 */
-		IMPORT_C TPropertyType PropertyType() const;
-		
-		/** @return The binary property value. */ 
-		IMPORT_C const TDesC8& BinaryValue();
-	
-	private:
-		CBinaryPropertyEntry();
-		void ConstructL(const TDesC& aPropertyName, const TDesC8& aPropertyValue);
-		void DoExternalizeL(RWriteStream& aStream) const;
-		void DoInternalizeL(RReadStream& aStream);
-	
-		static CBinaryPropertyEntry* NewLC();
-		friend CPropertyEntry* CPropertyEntry::NewL(RReadStream& aStream);
-		
-	private:
-		HBufC8* iValue; ///< The value of the binary property.
-		};
-	
-	NONSHARABLE_CLASS(CLocalizablePropertyEntry) : public CPropertyEntry
-	/**
-		Class that represents a localizable string component property.
-		
-		A localized component property is a string property which can have different values 
-		for different locales. A particular instance of a localized component property includes 
-		both the localized string value and the locale in question.
-	 */
-		{
-	public:
-		/**
-			Creates a localizable component property object.
-					
-			@param aPropertyName The name of the property.
-			@param aPropertyValue The value of the property.
-			@param aLocale The locale of the property.
-			@return A pointer to the newly allocated component property object, if creation is successful.
-		 */
-		IMPORT_C static CLocalizablePropertyEntry* NewL(const TDesC& aPropertyName, const TDesC& aPropertyValue, TLanguage aLocale);
-		
-		/**
-			Creates a localizable component property object.
-							
-			@param aPropertyName The name of the property.
-			@param aPropertyValue The value of the property.
-			@param aLocale The locale 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 CLocalizablePropertyEntry* NewLC( const TDesC& aPropertyName, const TDesC& aPropertyValue, TLanguage aLocale);
-		
-		IMPORT_C ~CLocalizablePropertyEntry();
-		
-		/** The locale of the localizable property object. */
-		IMPORT_C TLanguage LocaleL() const;
-		
-		/**
-			The implementation of pure virtual function from @see Usif::CPropertyEntry.
-			@return The type of the property object.
-		 */
-		IMPORT_C TPropertyType PropertyType() const;
-		
-		/** @return The string property value. */
-		IMPORT_C const TDesC& StrValue() const;		
-		
-	private:
-		CLocalizablePropertyEntry();
-		CLocalizablePropertyEntry(TLanguage aLocale);
-		void DoExternalizeL(RWriteStream &aStream) const;
-		void DoInternalizeL(RReadStream& aStream);
-		static CLocalizablePropertyEntry* NewLC();
-		friend CPropertyEntry* CPropertyEntry::NewL(RReadStream& aStream);
-		void ConstructL(const TDesC& aPropertyName, const TDesC& aPropertyValue);
-		
-	private:
-		TLanguage iLocale; ///< The language code of the locale.
-		HBufC* iStrValue; ///< The string value of the property
-		};
-	
-	NONSHARABLE_CLASS(CComponentFilter) : public CBase
-	/**
-		A filter class which is used to filter the software components stored in the SCR.
-		An empty filter object is first created and then required filter keys are set separately.
-	 */
-		{
-		friend class CScrRequestImpl;
-	public:
-		/**
-			Creates an empty component filter object.
-			@return A pointer to the newly allocated component filter object, if creation is successful.
-		 */
-		IMPORT_C static CComponentFilter* NewL();
-		
-		/**
-			Creates an empty component filter object.
-			@return A pointer to the newly allocated component filter object, if creation is successful.
-					The pointer is also put onto the cleanup stack.
-		 */
-		IMPORT_C static CComponentFilter* NewLC();
-		
-		/**
-			Creates a component filter object from a stream.
-			@param aStream The stream to read the component filter object from
-			@return A pointer to the newly allocated component filter object, if creation is successful.
-			@internalComponent
-		 */
-		IMPORT_C static CComponentFilter* NewL(RReadStream& aStream);
-		
-		~CComponentFilter();
-		
-		/**
-			Restricts the returned component names in the filter.
-			Please note that wildcards are not supported and matching is case-sensitive.
-			@param aName The name of the software component.
-		 */
-		IMPORT_C void SetNameL(const TDesC& aName);
-		
-		/**
-			Restricts the returned component vendor names in the filter.
-			Please note that wildcards are not supported and matching is case-sensitive.
-			@param aVendor The vendor name of the software component.
-		 */
-		IMPORT_C void SetVendorL(const TDesC& aVendor);
-		
-		/**
-			Restricts the returned component software types in the filter.
-			@param aSwType The software type name of the software component (e.g. @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava). 
-		*/
-		IMPORT_C void SetSoftwareTypeL(const TDesC& aSwType);
-		
-		/**
-			Sets whether the software component which is being searched for is removable.
-			@param aValue ETrue, if the software component is removable. Otherwise, EFalse.
-		 */
-		IMPORT_C void SetRemovable(TBool aValue);
-		
-		/**
-			Sets whether the software component which is being searched for is DRM protected.
-			@param aValue ETrue, if the software component is DRM protected. Otherwise, EFalse.
-		 */
-		IMPORT_C void SetDrmProtected(TBool aValue);
-		
-		/**
-			Sets whether the software component which is being searched for is hidden.
-			@param aValue ETrue, if the software component is hidden. Otherwise, EFalse.
-		 */
-		IMPORT_C void SetHidden(TBool aValue);
-		
-		/**
-			Sets whether the software component which is being searched for is known-revoked.
-			@param aValue ETrue, if the software component is known-revoked. Otherwise, EFalse.
-		 */
-		IMPORT_C void SetKnownRevoked(TBool aValue);
-		
-		/**
-			Sets whether the software component which is being searched for is origin-verified.
-			@param aValue ETrue, if the software component is origin-verified. Otherwise, EFalse.
-		 */
-		IMPORT_C void SetOriginVerified(TBool aValue);
-		
-		/**
-			Restricts the returned component SCOMO states in the filter.
-			See @see Usif::TScomoState for the list of SCOMO states.
-			@param aScomoState The SCOMO state of the software component.
-		 */
-		IMPORT_C void SetScomoStateL(TScomoState aScomoState);
-		
-		/**
-			Sets the set of drives that files of the software components were installed to.
-			If more than one drive is supplied, all software components which files were installed to
-			any of these drives are returned.
-		 */
-		IMPORT_C void SetInstalledDrivesL(const TDriveList& aDrives);
-		
-		/**
-			Adds a localizable property to the filter. Only the software components having 
-			this property with the specified value are returned by the filter. It is possible to 
-			add more than one property. In this case, the software components possessing all provided 
-			properties with the specified values are returned by the filter.
-			
-			For more information about searching for current locale variant of properties look at 
-			@see RSoftwareComponentRegistry::GetComponentPropertyL.
-			
-			If the locale is provided, the component will be returned only if the property exists 
-			for the specified locale. If the locale is not provided, or is equal to KUnspecifiedLocale,
-			then all software components which have the property with the specified value for any locale will
-			match this condition.
-			
-			@param aName The name of the property. Please note that wildcards are not supported and matching is case-insensitive.
-			@param aValue The value of the property.	
-			@param aLocale Optional. The language code of the property value.			
-					
-		 */
-		IMPORT_C void AddPropertyL(const TDesC& aName, const TDesC& aValue, TLanguage aLocale=KUnspecifiedLocale);
-		
-		/**
-			Adds an integer property to the filter. The software components having this
-			property with the specified value are enumerated. It is possible to add more than one property. 
-			In this case, the software components possessing all provided properties with the specified 
-			values are enumerated.
-			
-			@param aName The name of the property. Please note that wildcards are not supported and matching is case-insensitive.
-			@param aValue The value of the property.
-		 */
-		IMPORT_C void AddPropertyL(const TDesC& aName, TInt64 aValue);
-		
-		/**
-			Adds a binary 8-bit descriptor property to the filter. The software components having this
-			property with the specified value are enumerated. It is possible to add more than one property. 
-			In this case, the software components possessing all provided properties with the specified 
-			values are enumerated.
-			
-			@param aName The name of the property. Please note that wildcards are not supported and matching is case-insensitive.
-			@param aValue The value of the property.
-		 */
-		IMPORT_C void AddPropertyL(const TDesC& aName, const TDesC8& aValue);		
-		
-		/**
-		 	Sets a file name to filter the software components having registered this file.
-		 	Please note that wildcards are not supported and matching is case-insensitive.
-			
-			N.B. This call can be invoked multiple times for the same filter in order to request components which register a particular set of files.
-		 	@param aFile The fully qualified file path.
-		 */
-		IMPORT_C void SetFileL(const TDesC& aFile);
-		
-		/**
-			Externalises a component filter object to a write stream.
-			@param aStream The stream to which the object is externalised.
-			@internalComponent
-		*/
-		IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
-		
-	private:
-		CComponentFilter();
-		void ConstructL();
-		void InternalizeL(RReadStream& aStream);
-		
-		enum TFieldsFlag
-			{
-			EName 			= 0x0001,
-			EVendor 		= 0x0002,
-			ESoftwareType   = 0x0004,
-			ERemovable 		= 0x0008,
-			EScomoState 	= 0x0010,
-			EInstalledDrive = 0x0020,
-			EProperty       = 0x0040,
-			EFile			= 0x0080,
-			EDrmProtected   = 0x0100,
-			EHidden		    = 0x0200,
-			EKnownRevoked   = 0x0400,
-			EOriginVerified = 0x0800
-			};
-		
-	private:
-		TUint16 iSetFlag;			 ///< Flag variable that shows what fields have been set
-		HBufC* iName;				 ///< Name for the software component
-		HBufC* iVendor;				 ///< Vendor for the software component
-		HBufC* iSwType;				 ///< Software type of the component.
-		TBool iRemovable;			 ///< Whether the software component is removable
-		TScomoState iScomoState;	 ///< SCOMO state for the software component
-		TDriveList iInstalledDrives; ///< Installed drives for the software component
-		RPointerArray<CPropertyEntry> iPropertyList; ///< The list of key properties
-		HBufC* iFile;				///< The full name of the file owned by the component
-		TBool iDrmProtected;		 ///< Whether the component is DRM protected.
-		TBool iHidden;				 ///< Whether the component is displayed 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 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);
+        void ConstructL(const TDesC& aPropertyName);
+        static CIntPropertyEntry* NewLC();
+        friend CPropertyEntry* CPropertyEntry::NewL(RReadStream& aStream);
+        
+    private:
+        TInt64 iIntValue;   ///< The integer property value.
+        };
+    
+    class CBinaryPropertyEntry : public CPropertyEntry
+    /**
+        Class that represents a binary non-localizable 8-bit descriptor component property.     
+    */
+        {
+    public:
+        /**
+            Creates a binary 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 CBinaryPropertyEntry* NewL(const TDesC& aPropertyName, const TDesC8& aPropertyValue);
+        
+        /**
+            Creates a binary 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 CBinaryPropertyEntry* NewLC(const TDesC& aPropertyName, const TDesC8& aPropertyValue);
+        
+        IMPORT_C ~CBinaryPropertyEntry(); 
+        
+        /**
+            The implementation of pure virtual function from @see Usif::CPropertyEntry.
+            @return The type of the property object.
+         */
+        IMPORT_C TPropertyType PropertyType() const;
+        
+        /** @return The binary property value. */ 
+        IMPORT_C const TDesC8& BinaryValue();
+    
+    private:
+        CBinaryPropertyEntry();
+        void ConstructL(const TDesC& aPropertyName, const TDesC8& aPropertyValue);
+        void DoExternalizeL(RWriteStream& aStream) const;
+        void DoInternalizeL(RReadStream& aStream);
+    
+        static CBinaryPropertyEntry* NewLC();
+        friend CPropertyEntry* CPropertyEntry::NewL(RReadStream& aStream);
+        
+    private:
+        HBufC8* iValue; ///< The value of the binary property.
+        };
+    
+    NONSHARABLE_CLASS(CLocalizablePropertyEntry) : public CPropertyEntry
+    /**
+        Class that represents a localizable string component property.
+        
+        A localized component property is a string property which can have different values 
+        for different locales. A particular instance of a localized component property includes 
+        both the localized string value and the locale in question.
+     */
+        {
+    public:
+        /**
+            Creates a localizable component property object.
+                    
+            @param aPropertyName The name of the property.
+            @param aPropertyValue The value of the property.
+            @param aLocale The locale of the property.
+            @return A pointer to the newly allocated component property object, if creation is successful.
+         */
+        IMPORT_C static CLocalizablePropertyEntry* NewL(const TDesC& aPropertyName, const TDesC& aPropertyValue, TLanguage aLocale);
+        
+        /**
+            Creates a localizable component property object.
+                            
+            @param aPropertyName The name of the property.
+            @param aPropertyValue The value of the property.
+            @param aLocale The locale 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 CLocalizablePropertyEntry* NewLC( const TDesC& aPropertyName, const TDesC& aPropertyValue, TLanguage aLocale);
+        
+        IMPORT_C ~CLocalizablePropertyEntry();
+        
+        /** The locale of the localizable property object. */
+        IMPORT_C TLanguage LocaleL() const;
+        
+        /**
+            The implementation of pure virtual function from @see Usif::CPropertyEntry.
+            @return The type of the property object.
+         */
+        IMPORT_C TPropertyType PropertyType() const;
+        
+        /** @return The string property value. */
+        IMPORT_C const TDesC& StrValue() const;     
+        
+    private:
+        CLocalizablePropertyEntry();
+        CLocalizablePropertyEntry(TLanguage aLocale);
+        void DoExternalizeL(RWriteStream &aStream) const;
+        void DoInternalizeL(RReadStream& aStream);
+        static CLocalizablePropertyEntry* NewLC();
+        friend CPropertyEntry* CPropertyEntry::NewL(RReadStream& aStream);
+        void ConstructL(const TDesC& aPropertyName, const TDesC& aPropertyValue);
+        
+    private:
+        TLanguage iLocale; ///< The language code of the locale.
+        HBufC* iStrValue; ///< The string value of the property
+        };
+    
+    NONSHARABLE_CLASS(CComponentFilter) : public CBase
+    /**
+        A filter class which is used to filter the software components stored in the SCR.
+        An empty filter object is first created and then required filter keys are set separately.
+     */
+        {
+        friend class CScrRequestImpl;
+    public:
+        
+        enum TDbOperator
+            {
+            EEqual = 1,
+            ELike
+            };
+        
+        /**
+            Creates an empty component filter object.
+            @return A pointer to the newly allocated component filter object, if creation is successful.
+         */
+        IMPORT_C static CComponentFilter* NewL();
+        
+        /**
+            Creates an empty component filter object.
+            @return A pointer to the newly allocated component filter object, if creation is successful.
+                    The pointer is also put onto the cleanup stack.
+         */
+        IMPORT_C static CComponentFilter* NewLC();
+        
+        /**
+            Creates a component filter object from a stream.
+            @param aStream The stream to read the component filter object from
+            @return A pointer to the newly allocated component filter object, if creation is successful.
+            @internalComponent
+         */
+        IMPORT_C static CComponentFilter* NewL(RReadStream& aStream);
+        
+        ~CComponentFilter();
+        
+        /**
+            Restricts the returned component names in the filter.
+            Please note that wildcards are not supported and matching is case-sensitive.
+            @param aName The name of the software component.
+         */
+        IMPORT_C void SetNameL(const TDesC& aName);
+        
+        /**
+            Restricts the returned component vendor names in the filter.
+            Please note that wildcards are not supported and matching is case-sensitive.
+            @param aVendor The vendor name of the software component.
+         */
+        IMPORT_C void SetVendorL(const TDesC& aVendor);
+        
+        /**
+            Restricts the returned component software types in the filter.
+            @param aSwType The software type name of the software component (e.g. @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava). 
+        */
+        IMPORT_C void SetSoftwareTypeL(const TDesC& aSwType);
+        
+        /**
+            Sets whether the software component which is being searched for is removable.
+            @param aValue ETrue, if the software component is removable. Otherwise, EFalse.
+         */
+        IMPORT_C void SetRemovable(TBool aValue);
+        
+        /**
+            Sets whether the software component which is being searched for is DRM protected.
+            @param aValue ETrue, if the software component is DRM protected. Otherwise, EFalse.
+         */
+        IMPORT_C void SetDrmProtected(TBool aValue);
+        
+        /**
+            Sets whether the software component which is being searched for is hidden.
+            @param aValue ETrue, if the software component is hidden. Otherwise, EFalse.
+         */
+        IMPORT_C void SetHidden(TBool aValue);
+        
+        /**
+            Sets whether the software component which is being searched for is known-revoked.
+            @param aValue ETrue, if the software component is known-revoked. Otherwise, EFalse.
+         */
+        IMPORT_C void SetKnownRevoked(TBool aValue);
+        
+        /**
+            Sets whether the software component which is being searched for is origin-verified.
+            @param aValue ETrue, if the software component is origin-verified. Otherwise, EFalse.
+         */
+        IMPORT_C void SetOriginVerified(TBool aValue);
+        
+        /**
+            Restricts the returned component SCOMO states in the filter.
+            See @see Usif::TScomoState for the list of SCOMO states.
+            @param aScomoState The SCOMO state of the software component.
+         */
+        IMPORT_C void SetScomoStateL(TScomoState aScomoState);
+        
+        /**
+            Sets the set of drives that files of the software components were installed to.
+            If more than one drive is supplied, all software components which files were installed to
+            any of these drives are returned.
+         */
+        IMPORT_C void SetInstalledDrivesL(const TDriveList& aDrives);
+        
+        /**
+            Adds a localizable property to the filter. Only the software components having 
+            this property with the specified value are returned by the filter. It is possible to 
+            add more than one property. In this case, the software components possessing all provided 
+            properties with the specified values are returned by the filter.
+            
+            For more information about searching for current locale variant of properties look at 
+            @see RSoftwareComponentRegistry::GetComponentPropertyL.
+            
+            If the locale is provided, the component will be returned only if the property exists 
+            for the specified locale. If the locale is not provided, or is equal to KUnspecifiedLocale,
+            then all software components which have the property with the specified value for any locale will
+            match this condition.
+            
+            @param aName The name of the property. Please note that matching is case-insensitive.
+            @param aValue The value of the property.    
+            @param aLocale Optional. The language code of the property value.
+            @param aNameOperator The comparison operator (TDbOperator type) to be associated with the name.
+            @param aValueOperator The comparison operator (TDbOperator type) to be associated with the value.          
+                    
+         */
+        IMPORT_C void AddPropertyL(const TDesC& aName, const TDesC& aValue, TLanguage aLocale=KUnspecifiedLocale, 
+                TDbOperator aNameOperator = EEqual, TDbOperator aValueOperator = EEqual);
+        
+        /**
+            Adds an integer property to the filter. The software components having this
+            property with the specified value are enumerated. It is possible to add more than one property. 
+            In this case, the software components possessing all provided properties with the specified 
+            values are enumerated.
+            
+            @param aName The name of the property. Please note that matching is case-insensitive.
+            @param aValue The value of the property.
+            @param aNameOperator The comparison operator (TDbOperator type) to be associated with the name.
+            @param aValueOperator The comparison operator (TDbOperator type) to be associated with the value.          
+            
+         */
+        IMPORT_C void AddPropertyL(const TDesC& aName, TInt64 aValue, TDbOperator aNameOperator = EEqual, 
+                TDbOperator aValueOperator = EEqual);
+        
+        /**
+            Adds a binary 8-bit descriptor property to the filter. The software components having this
+            property with the specified value are enumerated. It is possible to add more than one property. 
+            In this case, the software components possessing all provided properties with the specified 
+            values are enumerated.
+            
+            @param aName The name of the property. Please note that matching is case-insensitive.
+            @param aValue The value of the property.
+            @param aNameOperator The comparison operator (TDbOperator type) to be associated with the name.
+            @param aValueOperator The comparison operator (TDbOperator type) to be associated with the value.          
+            
+         */
+        IMPORT_C void AddPropertyL(const TDesC& aName, const TDesC8& aValue, TDbOperator aNameOperator = EEqual, 
+                TDbOperator aValueOperator = EEqual);       
+        
+        /**
+            Sets a file name to filter the software components having registered this file.
+            Please note that wildcards are not supported and matching is case-insensitive.
+            
+            N.B. This call can be invoked multiple times for the same filter in order to request components which register a particular set of files.
+            @param aFile The fully qualified file path.
+         */
+        IMPORT_C void SetFileL(const TDesC& aFile);
+        
+        /**
+            Externalises a component filter object to a write stream.
+            @param aStream The stream to which the object is externalised.
+            @internalComponent
+        */
+        IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
+        
+    private:
+        CComponentFilter();
+        void ConstructL();
+        void InternalizeL(RReadStream& aStream);
+        
+        enum TFieldsFlag
+            {
+            EName           = 0x0001,
+            EVendor         = 0x0002,
+            ESoftwareType   = 0x0004,
+            ERemovable      = 0x0008,
+            EScomoState     = 0x0010,
+            EInstalledDrive = 0x0020,
+            EProperty       = 0x0040,
+            EFile           = 0x0080,
+            EDrmProtected   = 0x0100,
+            EHidden         = 0x0200,
+            EKnownRevoked   = 0x0400,
+            EOriginVerified = 0x0800
+            };
+        
+        class TPropertyOperator
+            {
+        public:
+            IMPORT_C TPropertyOperator(TDbOperator aNameOperator = EEqual, TDbOperator aValueOperator = EEqual);
+            void ExternalizeL(RWriteStream& aStream) const;
+            IMPORT_C void InternalizeL(RReadStream& aStream);  
+            IMPORT_C TDbOperator NameOperator() const;
+            IMPORT_C TDbOperator ValueOperator() const;
+        
+        private:
+            TDbOperator iNameOperator;
+            TDbOperator iValueOperator;
+            };
+        
+    private:
+        TUint16 iSetFlag;            ///< Flag variable that shows what fields have been set
+        HBufC* iName;                ///< Name for the software component
+        HBufC* iVendor;              ///< Vendor for the software component
+        HBufC* iSwType;              ///< Software type of the component.
+        TBool iRemovable;            ///< Whether the software component is removable
+        TScomoState iScomoState;     ///< SCOMO state for the software component
+        TDriveList iInstalledDrives; ///< Installed drives for the software component
+        RPointerArray<CPropertyEntry> iPropertyList; ///< The list of key properties
+        HBufC* iFile;               ///< The full name of the file owned by the component
+        TBool iDrmProtected;         ///< Whether the component is DRM protected.
+        TBool iHidden;               ///< Whether the component is displayed 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.
+        RArray<TPropertyOperator> iPropertyOperatorList; ///< The list of operators associated with each property. 
+        };
 
-	
-	class CLocalizableCommonData : public CBase
-	/**
-		Base class which provides common functionality for localized information classes (e.g. CLocalizableComponentInfo). 
-		Please note that this class cannot be instantiated.
-	 */
-		{
-	public:
-		~CLocalizableCommonData();	
-		
-		/** @return The locale of the data. */
-		IMPORT_C TLanguage Locale() const;
-		
-	protected:
-		CLocalizableCommonData();
-		CLocalizableCommonData(TLanguage aLocale);
-		
-		void ExternalizeL(RWriteStream& aStream) const;
-		void InternalizeL(RReadStream& aStream);
-		
-	private:
-		TLanguage iLocale; ///< The language code of the locale.
-		};
-		
-	NONSHARABLE_CLASS(CLocalizableComponentInfo) : public CLocalizableCommonData
-	/**
-		This class contains the localizable information of a software component.
-		Component names and vendor names are localizable names and transferred to the SCR 
-		with the objects of this class.
-	 */
-		{
-	public:
-		/**
-			Creates a localizable component information object.
-			@param aName The name of the component.
-			@param aVendor The vendor of the component.
-			@param aLocale The language code of the object's locale.
-			@return A pointer to the newly allocated localizable component info object, if creation is successful.
-		 */
-		IMPORT_C static CLocalizableComponentInfo* NewL(const TDesC& aName, const TDesC& aVendor, TLanguage aLocale);
-		
-		/**
-			Creates a localizable component information object.
-			@param aName The name of the component.
-			@param aVendor The vendor of the component.
-			@param aLocale The language code of the object's locale.
-			@return A pointer to the newly allocated component information object, if creation is successful.
-					The pointer is also put onto the cleanup stack.
-		 */
-		IMPORT_C static CLocalizableComponentInfo* NewLC(const TDesC& aName, const TDesC& aVendor, TLanguage aLocale);
-		
-		/**
-			Creates a localizable component information from a stream.
-			@param aStream The stream to read the component information object from.
-			@return A pointer to the newly allocated component information object, if creation is successful.
-			@internalComponent
-		 */
-		IMPORT_C static CLocalizableComponentInfo* NewL(RReadStream& aStream);
-		
-		~CLocalizableComponentInfo();
-		
-		/**
-			Externalises a localizable component information 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 localizable name of the component. */
-		IMPORT_C const TDesC& NameL() const;
-		
-		/** @return The localizable vendor name of the component. */
-		IMPORT_C const TDesC& VendorL() const;
-		
-	private:
-		CLocalizableComponentInfo();
-		CLocalizableComponentInfo(TLanguage aLocale);
-		void ConstructL(const TDesC& aName, const TDesC& aVendor);
-		void InternalizeL(RReadStream& aStream);
-		
-	private:
-		HBufC* iName;	   ///< The localizable component name.
-		HBufC* iVendor;    ///< The localizable component vendor name.
-		};
-	
-#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS	
-	NONSHARABLE_CLASS(CLocalizedSoftwareTypeName) : public CLocalizableCommonData
-		/**
-			This class contains localized software type names.
-			Software type names are localizable names and transferred to the SCR 
-			with the objects of this class.
-			
-			@internalTechnology
-		 */
-			{
-		public:	
-			/**
-				Creates a localized software type name object.
-				@param aName The name of the software type.
-				@param aLocale The language code of the object's locale.
-				@return A pointer to the newly allocated localized software type name object, if creation is successful.
-			 */
-			IMPORT_C static CLocalizedSoftwareTypeName* NewL(const TDesC& aName, TLanguage aLocale);
-			
-			/**
-				Creates a localized software type name object.
-				@param aName The name of the software type.
-				@param aLocale The language code of the object's locale.
-				@return A pointer to the newly allocated localized software type name object, if creation is successful.
-						The pointer is also put onto the cleanup stack.
-			 */
-			IMPORT_C static CLocalizedSoftwareTypeName* NewLC(const TDesC& aName, TLanguage aLocale);
-			
-			/**
-				Creates a localized software type name object from a stream.
-				@param aStream The stream to read the localized software type name object from.
-				@return A pointer to the newly allocated localized software type name object, if creation is successful.
-				@internalComponent
-			 */
-			IMPORT_C static CLocalizedSoftwareTypeName* NewL(RReadStream& aStream);
-			
-			~CLocalizedSoftwareTypeName();
-			
-			/**
-				Externalises a localized software type name 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 localized software type name. */
-			IMPORT_C const TDesC& NameL() const;
-			
-		private:
-			CLocalizedSoftwareTypeName();
-			CLocalizedSoftwareTypeName(TLanguage aLocale);
-			void ConstructL(const TDesC& aName);
-			void InternalizeL(RReadStream& aStream);
-			
-		private:
-			HBufC* iName;	   ///< The localized software type name.
-			};
-#endif //SYMBIAN_ENABLE_SPLIT_HEADERS	
-	
-	enum TScrComponentOperationType
-	/**
-		The type of the operation being performed on an SCR component. 
-	 */
-		{
-		EScrCompInstall =0,		///< A new SCR component is added.
-		EScrCompUnInstall,		///< A existing SCR component is removed.
-		EScrCompUpgrade,		///< An existing SCR component is updated.
-		EScrCompHidden			///< The component operation is hidden to the user. N.B. SCR doesn't save logs for this type of operation.
-		};
-	
-#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS	
-	NONSHARABLE_CLASS (CScrLogEntry) : public CBase
-	/**
-		Class that represents a software component log record generated by the SCR.
-	 */ 
-		{
-		friend class CScrRequestImpl;
-	public:
-		/**
-			Creates a log entry object.
-			@param aComponentName The name of the component.
-			@param aUniqueSwTypeName The non-localized, unique software type name, such as @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava.
-			@param aGlobalId The global Id of the component.
-			@param aVersion The version of the component.
-			@param aCompOpType The type of the component operation. @see Usif::TScrComponentOperationType
-			@return A pointer to the newly allocated log entry object, if creation is successful.
-			@internalComponent
-		 */
-		IMPORT_C static CScrLogEntry* NewL(const TDesC& aComponentName, const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId, const TDesC& aVersion, const TScrComponentOperationType aCompOpType);
-		
-		/**
-			Creates a log entry object.
-			@param aComponentName The name of the component.
-			@param aUniqueSwTypeName The non-localized, unique software type name, such as @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava.
-			@param aGlobalId The global Id of the component.
-			@param aVersion The version of the component.
-			@param aCompOpType The type of the component operation. @see Usif::TScrComponentOperationType
-			@return A pointer to the newly allocated log entry object, if creation is successful.
-					The pointer is also put onto the cleanup stack.
-			@internalComponent		
-		 */
-		IMPORT_C static CScrLogEntry* NewLC(const TDesC& aComponentName, const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId, const TDesC& aVersion, const TScrComponentOperationType aCompOpType);
+    
+    class CLocalizableCommonData : public CBase
+    /**
+        Base class which provides common functionality for localized information classes (e.g. CLocalizableComponentInfo). 
+        Please note that this class cannot be instantiated.
+     */
+        {
+    public:
+        ~CLocalizableCommonData();  
+        
+        /** @return The locale of the data. */
+        IMPORT_C TLanguage Locale() const;
+        
+    protected:
+        CLocalizableCommonData();
+        CLocalizableCommonData(TLanguage aLocale);
+        
+        void ExternalizeL(RWriteStream& aStream) const;
+        void InternalizeL(RReadStream& aStream);
+        
+    private:
+        TLanguage iLocale; ///< The language code of the locale.
+        };
+        
+    NONSHARABLE_CLASS(CLocalizableComponentInfo) : public CLocalizableCommonData
+    /**
+        This class contains the localizable information of a software component.
+        Component names and vendor names are localizable names and transferred to the SCR 
+        with the objects of this class.
+     */
+        {
+    public:
+        /**
+            Creates a localizable component information object.
+            @param aName The name of the component.
+            @param aVendor The vendor of the component.
+            @param aLocale The language code of the object's locale.
+            @return A pointer to the newly allocated localizable component info object, if creation is successful.
+         */
+        IMPORT_C static CLocalizableComponentInfo* NewL(const TDesC& aName, const TDesC& aVendor, TLanguage aLocale);
+        
+        /**
+            Creates a localizable component information object.
+            @param aName The name of the component.
+            @param aVendor The vendor of the component.
+            @param aLocale The language code of the object's locale.
+            @return A pointer to the newly allocated component information object, if creation is successful.
+                    The pointer is also put onto the cleanup stack.
+         */
+        IMPORT_C static CLocalizableComponentInfo* NewLC(const TDesC& aName, const TDesC& aVendor, TLanguage aLocale);
+        
+        /**
+            Creates a localizable component information from a stream.
+            @param aStream The stream to read the component information object from.
+            @return A pointer to the newly allocated component information object, if creation is successful.
+            @internalComponent
+         */
+        IMPORT_C static CLocalizableComponentInfo* NewL(RReadStream& aStream);
+        
+        ~CLocalizableComponentInfo();
+        
+        /**
+            Externalises a localizable component information 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 localizable name of the component. */
+        IMPORT_C const TDesC& NameL() const;
+        
+        /** @return The localizable vendor name of the component. */
+        IMPORT_C const TDesC& VendorL() const;
+        
+    private:
+        CLocalizableComponentInfo();
+        CLocalizableComponentInfo(TLanguage aLocale);
+        void ConstructL(const TDesC& aName, const TDesC& aVendor);
+        void InternalizeL(RReadStream& aStream);
+        
+    private:
+        HBufC* iName;      ///< The localizable component name.
+        HBufC* iVendor;    ///< The localizable component vendor name.
+        };
+    
+#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS    
+    NONSHARABLE_CLASS(CLocalizedSoftwareTypeName) : public CLocalizableCommonData
+        /**
+            This class contains localized software type names.
+            Software type names are localizable names and transferred to the SCR 
+            with the objects of this class.
+            
+            @internalTechnology
+         */
+            {
+        public: 
+            /**
+                Creates a localized software type name object.
+                @param aName The name of the software type.
+                @param aLocale The language code of the object's locale.
+                @return A pointer to the newly allocated localized software type name object, if creation is successful.
+             */
+            IMPORT_C static CLocalizedSoftwareTypeName* NewL(const TDesC& aName, TLanguage aLocale);
+            
+            /**
+                Creates a localized software type name object.
+                @param aName The name of the software type.
+                @param aLocale The language code of the object's locale.
+                @return A pointer to the newly allocated localized software type name object, if creation is successful.
+                        The pointer is also put onto the cleanup stack.
+             */
+            IMPORT_C static CLocalizedSoftwareTypeName* NewLC(const TDesC& aName, TLanguage aLocale);
+            
+            /**
+                Creates a localized software type name object from a stream.
+                @param aStream The stream to read the localized software type name object from.
+                @return A pointer to the newly allocated localized software type name object, if creation is successful.
+                @internalComponent
+             */
+            IMPORT_C static CLocalizedSoftwareTypeName* NewL(RReadStream& aStream);
+            
+            ~CLocalizedSoftwareTypeName();
+            
+            /**
+                Externalises a localized software type name 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 localized software type name. */
+            IMPORT_C const TDesC& NameL() const;
+            
+        private:
+            CLocalizedSoftwareTypeName();
+            CLocalizedSoftwareTypeName(TLanguage aLocale);
+            void ConstructL(const TDesC& aName);
+            void InternalizeL(RReadStream& aStream);
+            
+        private:
+            HBufC* iName;      ///< The localized software type name.
+            };
+#endif //SYMBIAN_ENABLE_SPLIT_HEADERS   
+    
+    enum TScrComponentOperationType
+    /**
+        The type of the operation being performed on an SCR component. 
+     */
+        {
+        EScrCompInstall =0,     ///< A new SCR component is added.
+        EScrCompUnInstall,      ///< A existing SCR component is removed.
+        EScrCompUpgrade,        ///< An existing SCR component is updated.
+        EScrCompHidden          ///< The component operation is hidden to the user. N.B. SCR doesn't save logs for this type of operation.
+        };
+    
+#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS    
+    NONSHARABLE_CLASS (CScrLogEntry) : public CBase
+    /**
+        Class that represents a software component log record generated by the SCR.
+     */ 
+        {
+        friend class CScrRequestImpl;
+    public:
+        /**
+            Creates a log entry object.
+            @param aComponentName The name of the component.
+            @param aUniqueSwTypeName The non-localized, unique software type name, such as @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava.
+            @param aGlobalId The global Id of the component.
+            @param aVersion The version of the component.
+            @param aCompOpType The type of the component operation. @see Usif::TScrComponentOperationType
+            @return A pointer to the newly allocated log entry object, if creation is successful.
+            @internalComponent
+         */
+        IMPORT_C static CScrLogEntry* NewL(const TDesC& aComponentName, const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId, const TDesC& aVersion, const TScrComponentOperationType aCompOpType);
+        
+        /**
+            Creates a log entry object.
+            @param aComponentName The name of the component.
+            @param aUniqueSwTypeName The non-localized, unique software type name, such as @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava.
+            @param aGlobalId The global Id of the component.
+            @param aVersion The version of the component.
+            @param aCompOpType The type of the component operation. @see Usif::TScrComponentOperationType
+            @return A pointer to the newly allocated log entry object, if creation is successful.
+                    The pointer is also put onto the cleanup stack.
+            @internalComponent      
+         */
+        IMPORT_C static CScrLogEntry* NewLC(const TDesC& aComponentName, const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId, const TDesC& aVersion, const TScrComponentOperationType aCompOpType);
 
-	 	/**
-	 		Creates a log entry object from a stream.
-	 		@param aStream The stream to read the log entry object from.
-	 		@return A pointer to the newly allocated log entry object, if creation is successful.
-	 				The pointer is also put onto the cleanup stack.
-	 		@internalComponent
-	 	*/
-		IMPORT_C static CScrLogEntry* NewLC(RReadStream& aStream);
-		
-		~CScrLogEntry();
-		
-	 	/**
-		 	Write the object to a stream 
-		 
-		 	@param aStream The stream to write to
-		 	@internalComponent
-		 */
-		IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
-		 
-		/**
-		 	Read the object from a stream
-		 
-		 	@param aStream The stream to read from.
-		 	@internalComponent
-		 */
-		IMPORT_C void InternalizeL(RReadStream& aStream) ;
-	    
-	    /**
-			@return The name of the component for which the log was generated.
-		 */
-		IMPORT_C const TDesC& ComponentName() const; 
-		
-		/**
-			@return The non-localized, unique software type name, such as @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava.
-		 */
-		IMPORT_C const TDesC& SoftwareTypeName() const;
-		
-		/**
-			The UID.
-		 	@return The global ID of the component.
-		 */
-		IMPORT_C const TDesC& GlobalId() const; 
-				
-		/**
-			@return The version of the component.
-		 */
-		IMPORT_C const TDesC& ComponentVersion() const; 
-	    
-		/**
-			@return The time when the operation occured.
-		 */
-		IMPORT_C const TTime OperationTime() const; 
-			    
-	    /**
-		    @return The type of the component operation for the log record.
-		 */
-		IMPORT_C TScrComponentOperationType OperationType() const;
-		
-		/**
-			@return The component id of the log record.
-			@internalComponent
-		 */
-		IMPORT_C TComponentId ComponentId() const;
-	
-	private:
-		CScrLogEntry();
-		void ConstructL(const TDesC& aComponentName, const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId, const TDesC& aVersion, const TScrComponentOperationType aCompOpType);
-		
-	private:	
-	    HBufC* iComponentName ;
-	    HBufC* iSwTypeName;
-		HBufC* iVersion;
-		TScrComponentOperationType iOpType ; 
-		TTime  iRecordTime ;   
-		HBufC* iGlobalId;
-		TComponentId iComponentId; 
-		};
-	
-#endif //SYMBIAN_ENABLE_SPLIT_HEADERS	
+        /**
+            Creates a log entry object from a stream.
+            @param aStream The stream to read the log entry object from.
+            @return A pointer to the newly allocated log entry object, if creation is successful.
+                    The pointer is also put onto the cleanup stack.
+            @internalComponent
+        */
+        IMPORT_C static CScrLogEntry* NewLC(RReadStream& aStream);
+        
+        ~CScrLogEntry();
+        
+        /**
+            Write the object to a stream 
+         
+            @param aStream The stream to write to
+            @internalComponent
+         */
+        IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
+         
+        /**
+            Read the object from a stream
+         
+            @param aStream The stream to read from.
+            @internalComponent
+         */
+        IMPORT_C void InternalizeL(RReadStream& aStream) ;
+        
+        /**
+            @return The name of the component for which the log was generated.
+         */
+        IMPORT_C const TDesC& ComponentName() const; 
+        
+        /**
+            @return The non-localized, unique software type name, such as @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava.
+         */
+        IMPORT_C const TDesC& SoftwareTypeName() const;
+        
+        /**
+            The UID.
+            @return The global ID of the component.
+         */
+        IMPORT_C const TDesC& GlobalId() const; 
+                
+        /**
+            @return The version of the component.
+         */
+        IMPORT_C const TDesC& ComponentVersion() const; 
+        
+        /**
+            @return The time when the operation occured.
+         */
+        IMPORT_C const TTime OperationTime() const; 
+                
+        /**
+            @return The type of the component operation for the log record.
+         */
+        IMPORT_C TScrComponentOperationType OperationType() const;
+        
+        /**
+            @return The component id of the log record.
+            @internalComponent
+         */
+        IMPORT_C TComponentId ComponentId() const;
+    
+    private:
+        CScrLogEntry();
+        void ConstructL(const TDesC& aComponentName, const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId, const TDesC& aVersion, const TScrComponentOperationType aCompOpType);
+        
+    private:    
+        HBufC* iComponentName ;
+        HBufC* iSwTypeName;
+        HBufC* iVersion;
+        TScrComponentOperationType iOpType ; 
+        TTime  iRecordTime ;   
+        HBufC* iGlobalId;
+        TComponentId iComponentId; 
+        };
+    
+#endif //SYMBIAN_ENABLE_SPLIT_HEADERS   
 
-	} // End of namespace Usif
+    } // End of namespace Usif
 
 #endif // SCRENTRIES_H