diff -r aba6b8104af3 -r 84a16765cd86 installationservices/swcomponentregistry/inc/screntries.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/installationservices/swcomponentregistry/inc/screntries.h Fri Mar 19 09:33:35 2010 +0200 @@ -0,0 +1,1073 @@ +/* +* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* Declares entry classes for Software Components Registry interface. +* +*/ + + +/** + @file + @publishedAll + @released +*/ + +#ifndef SCRENTRIES_H +#define SCRENTRIES_H + +#include +#include +#include +#include + +namespace Usif + { + // CONSTANTS + + /** + KUnspecifiedLocale means that the locale is not specified and locale resolving will be done by SCR. + First, the current locale with its downgraded languages (@see BaflUtils::GetDowngradePathL) is tried + by SCR. If no value is found, then non-localized values are searched for. + */ + static const TLanguage KUnspecifiedLocale = TLanguage(-1); + + /** + KNonLocalized means that only non-localized values are looked up by SCR. + */ + static const TLanguage KNonLocalized = TLanguage(0); + + // CLASSES + + + NONSHARABLE_CLASS(CGlobalComponentId) : public CBase + /** + Encapsulates the global software component identifier which is a named, component level and nullable string. + that an installer may use to specify a deterministic identifier for the component that is unique within + the context of that software type. This global component id would be the package UID for native applications + or the midlet-names for Java etc + + The global component id is consistent and equal on all devices. It is used to state dependencies + and to check for the presence of installed software components of arbitrary types without each installer having + to be aware of every other installers naming scheme. + */ + { + public: + /** + Creates an empty global software component ID object. + @return A pointer to the newly allocated global software component ID object, if creation is successful. + The pointer is also put onto the cleanup stack. + */ + IMPORT_C static CGlobalComponentId* NewLC(); + + /** + Creates a global software component ID object. + @param aGlobalIdName A deterministic identifier for the component that is unique within the context of that software type. + @param aUniqueSwTypeName Non-localized unique software type name, such as @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava. + @return A pointer to the newly allocated global software component ID object, if creation is successful. + */ + IMPORT_C static CGlobalComponentId* NewL(const TDesC& aGlobalIdName, const TDesC& aUniqueSwTypeName); + + /** + Creates a global software component ID object. + @param aGlobalIdName A deterministic identifier for the component that is unique within the context of that software type. + @param aUniqueSwTypeName Non-localized unique software type name, such as @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava. + @return A pointer to the newly allocated global software component ID object, if creation is successful. + The pointer is also put onto the cleanup stack. + */ + IMPORT_C static CGlobalComponentId* NewLC(const TDesC& aGlobalIdName, const TDesC& aUniqueSwTypeName); + + /** + Creates a global software component ID object from a stream. + @param aStream The stream to read the software component entry object from + @return A pointer to the newly allocated global software component ID object, if creation is successful. + @internalComponent + */ + IMPORT_C static CGlobalComponentId* NewL(RReadStream& aStream); + + /** + Externalises this CGlobalComponentId object to a write stream. + @param aStream The stream to which the object is externalised. + @internalComponent + */ + IMPORT_C void ExternalizeL(RWriteStream& aStream) const; + + /** + Internalises this CGlobalComponentId object from a read stream. + @param aStream The stream from which the object is internalised. + @internalComponent + */ + IMPORT_C void InternalizeL(RReadStream& aStream); + + /** @return The global id name part (@see CGlobalComponentId::NewLC) of the global component id.*/ + IMPORT_C const TDesC& GlobalIdName() const; + + /** @return The software type name part (@see CGlobalComponentId::NewLC) of the global component id. */ + IMPORT_C const TDesC& SoftwareTypeName() const; + + IMPORT_C ~CGlobalComponentId(); + + private: + CGlobalComponentId(); + void ConstructL(const TDesC& aGlobalIdName, const TDesC& aSoftwareTypeName); + + private: + HBufC* iGlobalIdName; ///< The global id name part of the global component id. + HBufC* iSoftwareTypeName; ///< The software type name part of the global component id. + }; + + + NONSHARABLE_CLASS(CVersionedComponentId) : public CBase + /** + Class that represents a continuous set of versions for a particular component. + + This class is used for specifying dependencies, where a dependant component requires + specific version(s) of the supplier to be present on the system. The version information + is optional, i.e. this class can be used to represent any version of a component. + + If this class is used to represent a dependant component, it specifies the range of versions + of the dependency relationship defined by the dependant component. + */ + { + public: + + /** + Creates an empty version component identifier object. + @return A pointer to the newly allocated version component identifier object, if creation is successful. + The pointer is also put onto the cleanup stack. + */ + IMPORT_C static CVersionedComponentId* NewLC(); + + /** + Creates a versioned component identifier object. + + N.B. The version parameters are optional and used to set the lower and upper limit of the version range. + It is also possible to set only an upper limit or a lower limit or none. If only one version + parameter is supplied then a lower limit will be set. In this case, there is no upper limit. + If the first version parameter is upplied with KNullDesC, then the second version parameter + will be used to set an upper limit. + + @param aGlobalId The global software component identifier. + @param aVersionFrom The first version of the specified version range. + @param aVersionTo The last version of the specified version range. + + @return A pointer to the newly allocated versioned component identifier object, if creation is successful. + */ + IMPORT_C static CVersionedComponentId* NewL(const CGlobalComponentId& aGlobalId, const TDesC* aVersionFrom=NULL, const TDesC* aVersionTo=NULL); + + /** + Creates a versioned component identifier object. + For more information about the version parameters look at @see CVersionedComponentId::NewLC(). + + @param aGlobalId The global software component identifier. + @param aVersionFrom The first version of the specified version range. + @param aVersionTo The last version of the specified version range. + + @return A pointer to the newly allocated versioned component identifier object, if creation is successful. + The pointer is also put onto the cleanup stack. + */ + IMPORT_C static CVersionedComponentId* NewLC(const CGlobalComponentId& aGlobalId, const TDesC* aVersionFrom=NULL, const TDesC* aVersionTo=NULL); + + /** + Creates a versioned component identifier object from a stream. + @param aStream The stream to read the versioned component identifier object from + @return A pointer to the newly allocated versioned component identifier object, if creation is successful. + @internalComponent + */ + IMPORT_C static CVersionedComponentId* NewL(RReadStream& aStream); + + /** + Internalises this CVersionedComponentId object from a read stream. + @param aStream The stream from which the object is internalised. + @internalComponent + */ + IMPORT_C void InternalizeL(RReadStream& aStream); + + /** + Externalises this CVersionedComponentId object to a write stream. + @param aStream The stream to which the object is externalised. + @internalComponent + */ + IMPORT_C void ExternalizeL(RWriteStream& aStream) const; + + /** @return The global id of the versioned component. */ + IMPORT_C const CGlobalComponentId& GlobalId() const; + + /** @return The first version of the specified version range. NULL, if there is no lower limit for the version range. */ + IMPORT_C const TDesC* VersionFrom() const; + + /** @return The last version of the specified version range. NULL, if there is no upper limit for the version range. */ + IMPORT_C const TDesC* VersionTo() const; + + IMPORT_C ~CVersionedComponentId(); + + private: + CVersionedComponentId(); + void ConstructL(const CGlobalComponentId& aGlobalId, const TDesC* aVersionFrom, const TDesC* aVersionTo); + + private: + CGlobalComponentId* iGlobalId; ///< The global id of the versioned component identifier. + HBufC* iVersionFrom; ///< The first version of the specified version range. + HBufC* iVersionTo; ///< The last version of the specified version range. + }; + + + class CComponentEntry : public CBase + /** + Class that represents a software component entry stored in the SCR. + */ + { + friend class CScrRequestImpl; + public: + /** + Creates an empty software component entry object. + @return A pointer to the newly allocated software component object, if creation is successful. + */ + IMPORT_C static CComponentEntry* NewL(); + + /** + Creates an empty software component entry object. + @return A pointer to the newly allocated software component object, if creation is successful. + The pointer is also put onto the cleanup stack. + */ + IMPORT_C static CComponentEntry* NewLC(); + + /** + Creates a software component entry object from a stream. + @param aStream The stream to read the software component entry object from + @return A pointer to the newly allocated software component entry object, if creation is successful. + @internalComponent + */ + IMPORT_C static CComponentEntry* NewL(RReadStream& aStream); + + /** + Creates a software component entry object. + + @param aId The unique ID of the software component. + @param aName The name of of the software component. + @param aVendor The vendor name of the software component. + @param aSwType The software type of the component. + @param aGlobalId The globally unique identifier of the component. + @param aRemovable Whether the component is removable. ETrue means the component is removable. + @param aSize The total size of the component at installation time in bytes. + @param aScomoState The SCOMO state of the component. + @param aInstalledDrives The set of drives that files for the software component were installed to. + @param aVersion The version identifier of the software component. + @param aInstallTime The formatted install time string. The format is as following: YYYYMMDD:HHMMSS + @param aDrmProtected Whether the component is DRM protected. ETrue means the component is DRM protected. + @param aHidden Whether the component is displayed in the list of installed components. ETrue means the component is hidden. + @param aKnownRevoked Whether the component has been revoked. ETrue means that a revocation check was + performed during or after the installation and the component was found to be revoked. + @param aOriginVerified Whether the installer has verified the originator of the component. ETrue means the installer + has verified the originator of the software component by using appropriate checking mechanisms. + @return A pointer to the newly allocated software component object, if creation is successful. + @internalComponent + */ + IMPORT_C static CComponentEntry* NewL(const TComponentId& aId, const TDesC& aName, const TDesC& aVendor, const TDesC& aSwType, + const TDesC& aGlobalId, TBool aRemovable, TInt64 aSize, const TScomoState& aScomoState, + const TDriveList& aInstalledDrives, const TDesC& aVersion, const TDesC& aInstallTime, + TBool aDrmProtected, TBool aHidden, TBool aKnownRevoked, TBool aOriginVerified); + + /** + Creates a software component entry object. + + @param aId The unique ID of the software component. + @param aName The name of of the software component. + @param aVendor The vendor name of the software component. + @param aSwType The software type of the component. + @param aGlobalId The globally unique identifier of the component. + @param aRemovable Whether the component is removable. ETrue means the component is removable. + @param aSize The total size of the component at installation time in bytes. + @param aScomoState The SCOMO state of the component. + @param aInstalledDrives The set of drives that files for the software component were installed to. + @param aVersion The version identifier of the software component. + @param aInstallTime The formatted install time string. The format is as following: YYYYMMDD:HHMMSS + @param aDrmProtected Whether the component is DRM protected. ETrue means the component is DRM protected. + @param aHidden Whether the component is displayed in the list of installed components. ETrue means the component is hidden. + @param aKnownRevoked Whether the component has been revoked. ETrue means that a revocation check was + performed during or after the installation and the component was found to be revoked. + @param aOriginVerified Whether the installer has verified the originator of the component. ETrue means the installer + has verified the originator of the software component by using appropriate checking mechanisms. + @return A pointer to the newly allocated software component object, if creation is successful. + The pointer is also put onto the cleanup stack. + @internalComponent + */ + IMPORT_C static CComponentEntry* NewLC(const TComponentId& aId, const TDesC& aName, const TDesC& aVendor, const TDesC& aSwType, + const TDesC& aGlobalId, TBool aRemovable, TInt64 aSize, const TScomoState& aScomoState, + const TDriveList& aInstalledDrives, const TDesC& aVersion, const TDesC& aInstallTime, + TBool aDrmProtected, TBool aHidden, TBool aKnownRevoked, TBool aOriginVerified); + + IMPORT_C ~CComponentEntry(); + + /** + Externalises this CComponentEntry object to a write stream. + @param aStream The stream to which the object is externalised. + @internalComponent + */ + IMPORT_C void ExternalizeL(RWriteStream& aStream) const; + + /** + Internalises this CComponentEntry object from a read stream. + @param aStream The stream from which the object is internalised. + @internalComponent + */ + IMPORT_C void InternalizeL(RReadStream& aStream); + + /** @return The unique ID of the software component. */ + IMPORT_C const TComponentId& ComponentId() const; + + /** @return The name of the software component. */ + IMPORT_C const TDesC& Name() const; + + /** @return The vendor name of the software component. */ + IMPORT_C const TDesC& Vendor() const; + + /** @return The software type name of the software component, e.g @see Usif::KSoftwareTypeNative. */ + IMPORT_C const TDesC& SoftwareType() const; + + /** @return Globally unique component identifier. */ + IMPORT_C const TDesC& GlobalId() const; + + /** @return Whether the software component is removable. ETrue means it is removable. */ + IMPORT_C TBool IsRemovable() const; + + /** @return The total size of the component at installation time in bytes. */ + IMPORT_C TInt64 ComponentSize() const; + + /** @return The SCOMO state of the software component. @see Usif::TScomoState */ + IMPORT_C const TScomoState& ScomoState() const; + + /** @return The set of drives that files for the software component were installed to. */ + IMPORT_C const TDriveList& InstalledDrives() const; + + /** @return The version identifier of the software component. */ + IMPORT_C const TDesC& Version() const; + + /** @return The install time of the component. */ + IMPORT_C TTime InstallTimeL() const; + + /** @return Whether the component is DRM protected. ETrue means the component is DRM protected.*/ + IMPORT_C TBool IsDrmProtected() const; + + /** @return Whether the component is hidden in the list of installed components. ETrue means the component is hidden. */ + IMPORT_C TBool IsHidden() const; + + /** @return Whether the component has been revoked. ETrue means that a revocation check was performed + during or after the installation and the component was found to be revoked. + */ + IMPORT_C TBool IsKnownRevoked() const; + + /** @return Whether the installer has verified the originator of the component. ETrue means the installer + has verified the originator of the software component by using appropriate checking mechanisms. + */ + IMPORT_C TBool IsOriginVerified()const; + + private: + CComponentEntry(); + void ConstructL(const TComponentId& aId, const TDesC& aName, const TDesC& aVendor, const TDesC& aSwType, const TDesC& aGlobalId, TBool aRemovable, + TInt64 aSize, const TScomoState& aScomoState, const TDriveList& aInstalledDrives, const TDesC& aVersion, const TDesC& aInstallTime, + TBool aDrmProtected, TBool aHidden, TBool aKnownRevoked, TBool aOriginVerified); + private: + TComponentId iComponentId; ///< The unique id of the software component. + HBufC* iName; ///< Name of the software component. + HBufC* iVendor; ///< Vendor of the software component. + HBufC* iSwType; ///< Software type name of the component. + HBufC* iGlobalId; ///< Globally unique component identifier. + TBool iRemovable; ///< Whether the component is removable. + TInt64 iSize; ///< The total size of the component at installation time in bytes. + TScomoState iScomoState; ///< SCOMO state of the component. + TDriveList iInstalledDrives; ///< The set of drives that files for the software component were installed to. + HBufC* iVersion; ///< Version identifier of the software component + HBufC* iInstallTime; ///< The install time of the component. + TBool iDrmProtected; ///< Whether the component is DRM protected. + TBool iHidden; ///< Whether the component is hidden in the list of installed components. + TBool iKnownRevoked; ///< Whether the component has been revoked. + TBool iOriginVerified; ///< Whether the installer has verified the originator of the component. + }; + + class CPropertyEntry : public CBase + /** + Abstract base class for a software component property entry. + Specifies the type of a software component property. Before getting a property value, + the base property object must be converted to a derived property object (e.g. CIntPropertyEntry). + */ + { + public: + /** + Enumeration to indicate the type of the property. + */ + enum TPropertyType + { + EBinaryProperty = 1, ///< The property value is binary data. See @see CBinaryPropertyEntry. + EIntProperty, ///< The property value is integer. See @see CIntPropertyEntry. + ELocalizedProperty, ///< The property is a localizable string. See @see CLocalizablePropertyEntry. + }; + public: + /** + Creates a base software component property object from a stream. + @param aStream The stream to read the software property object from. + @return A pointer to the newly allocated software property object, if creation is successful. + @internalComponent + */ + IMPORT_C static CPropertyEntry* NewL(RReadStream& aStream); + + /** @return The name of the property. */ + IMPORT_C const TDesC& PropertyName() const; + + /** Virtual destructor for the component property object*/ + IMPORT_C virtual ~CPropertyEntry(); + + /** + Externalises a base/derived property object to a write stream. + @param aStream The stream to which the object is externalised. + @internalComponent + */ + IMPORT_C void ExternalizeL(RWriteStream& aStream) const; + + /** @return The type of the property object. Implemented by derived classes. */ + virtual CPropertyEntry::TPropertyType PropertyType() const = 0; + + protected: + CPropertyEntry(); + void ConstructL(const TDesC& aPropertyName); + + private: + virtual void DoExternalizeL(RWriteStream &aStream) const = 0; + virtual void DoInternalizeL(RReadStream& aStream) = 0; + + private: + HBufC* iPropertyName; ///< The name of the property entry. + }; + + class CIntPropertyEntry : public CPropertyEntry + /** + Class that represents an integer component property. + */ + { + public: + /** + Creates an integer component property object. + + @param aPropertyName The name of the property. + @param aPropertyValue The value of the property. + @return A pointer to the newly allocated component property object, if creation is successful. + */ + IMPORT_C static CIntPropertyEntry* NewL(const TDesC& aPropertyName, TInt64 aPropertyValue); + + /** + Creates an integer component property object. + + @param aPropertyName The name of the property. + @param aPropertyValue The value of the property. + @return A pointer to the newly allocated component property object, if creation is successful. + The pointer is also put onto the cleanup stack. + */ + IMPORT_C static CIntPropertyEntry* NewLC(const TDesC& aPropertyName, TInt64 aPropertyValue); + + IMPORT_C ~CIntPropertyEntry(); + + /** + The implementation of pure virtual function from @see Usif::CPropertyEntry. + @return The type of the property object. + */ + IMPORT_C CPropertyEntry::TPropertyType PropertyType() const; + + /** @return The 32-bit integer value. */ + IMPORT_C TInt IntValue(); + + /** @return The 64-bit integer value. */ + IMPORT_C TInt64 Int64Value(); + + private: + void DoExternalizeL(RWriteStream& aStream) const; + void DoInternalizeL(RReadStream& aStream); + + CIntPropertyEntry(); + CIntPropertyEntry(TInt64 aPropertyIntValue); + 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 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 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 + + } // End of namespace Usif + +#endif // SCRENTRIES_H