/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

* Declares entry classes for Software Components Registry interface.

*

*/

/**

 @file

 @publishedAll

 @prototype 

*/

#ifndef APPREGENTRIES_H

#define APPREGENTRIES_H

#include <e32base.h>

#include <s32strm.h>

#include <f32file.h> 

namespace Usif

    {

    class CScrRequestImpl;

    class CDataType;

    class CServiceInfo;

    class CLocalizableAppInfo;

    class CAppViewData;

    class CCaptionAndIconInfo;

    const TInt KSCRMaxAppGroupName=0x10; // Length of App's logical groupname

    typedef TBuf<KSCRMaxAppGroupName> TAppGroupName;

    NONSHARABLE_CLASS (TApplicationCharacteristics)

    /**

     Used to store application characteristics like its embeddabilty, group name etc.

     */

         {

     public:

         /**

          Creates an empty TApplicationCharacteristics object.

          */

         IMPORT_C TApplicationCharacteristics();

         IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

         IMPORT_C void InternalizeL(RReadStream& aStream);

     public:

         /** 

           Defines an application's support for embeddability. 

          */

         enum TAppEmbeddability {

             /** 

              An application cannot be embedded. 

             */

             ENotEmbeddable=0,

             /** 

              An application can be run embedded or standalone and can read/write embedded document-content. 

             */

             EEmbeddable=1,

             /** 

              An application can only be run embedded and can read/write embedded document-content. 

             */

             EEmbeddableOnly=2,

             /** 

              An application can be run embedded or standalone and cannot read/write embedded document-content. 

             */

             EEmbeddableUiOrStandAlone=5,

             /** 

              An application can only be run embedded and cannot read/write embedded document-content. 

             */

             EEmbeddableUiNotStandAlone=6 

             };         

         /** 

          Indicates the extent to which the application can be embedded.

         */

         TAppEmbeddability iEmbeddability;

         /** 

          Indicates whether the application is document-based and supports being asked 

          to create a new file. 

         */

         TBool iSupportsNewFile;

         /** 

          Indicates whether the existence of the application should be advertised to the 

          user. If this is set to ETrue, the application does not appear on the Extras 

          Bar (or equivalent). 

         */

         TBool iAppIsHidden; // not shown in the Shell etc.

         /** 

          Allows the application to be launched in the foreground (when set to EFalse) 

          or in the background (when set to ETrue). 

         */

         TBool iLaunchInBackground;  // Series 60 extension to allow apps to be launched in the background   

         /** 

          Stores the application's logical group name. 

         */

         TAppGroupName iGroupName; // Series 60 extension to allow apps to be categorized according a logical group name, e.g. 'games'

         /** 

          Indicates the application attributes. One or more values from TCapabilityAttribute may be specified. 

         */

         TUint iAttributes;

         };    

    class TEmbeddableFilter

       {

    public:

       /** Constructs an empty embeddability filter. 

        */

       IMPORT_C TEmbeddableFilter();

       /** Adds aEmbeddability value to the EmbeddabilityFlag. 

        */

       IMPORT_C void AddEmbeddability(TApplicationCharacteristics::TAppEmbeddability aEmbeddability);

       /** Compares aEmbeddability with the filter.

        * @param aEmbeddability TAppEmbeddability value to compare.

        * @see TAppEmbeddability for more details.

        * @return True, if aEmbeddability is included in the filter; false, otherwise. 

        */

       IMPORT_C TBool MatchesEmbeddability(TApplicationCharacteristics::TAppEmbeddability aEmbeddability) const;

       /** Sets the value of aEmbeddability with EmbeddabilityFlag's value.

        */

       void  SetEmbeddabilityFlags(TUint aEmbeddabilityFlags);

       /** Return the value of iEmbeddability.

        */

       IMPORT_C TUint EmbeddabilityFlags() const;

    private:

       TUint iEmbeddabilityFlags;

       };

    NONSHARABLE_CLASS(CAppInfoFilter) : public CBase

    /**

        A filter class which is used to filter the Application registration Info 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 AppRegistrationInfo filter object.

            @return A pointer to the newly allocated AppRegistrationInfo filter object, if creation is successful.

         */

        IMPORT_C static CAppInfoFilter* NewL();

        /**

            Creates an empty AppRegistrationInfo filter object.

            @return A pointer to the newly allocated AppRegistrationInfo filter object, if creation is successful.

                    The pointer is also put onto the cleanup stack.

         */

        IMPORT_C static CAppInfoFilter* NewLC();

        /**

            Creates a AppRegistrationInfo filter object from a stream.

            @param aStream The stream to read the AppRegistrationInfo filter object from

            @return A pointer to the newly allocated AppRegistrationInfo filter object, if creation is successful.

            @internalComponent

         */

        IMPORT_C static CAppInfoFilter* NewL(RReadStream& aStream);

        IMPORT_C void SetAllApps();

        IMPORT_C void SetAllApps(const TInt aScreenMode);

        IMPORT_C void SetEmbeddableApps();

        IMPORT_C void SetEmbeddableApps(const TInt aScreenMode);

        IMPORT_C void SetEmbeddabilityFilter(TEmbeddableFilter& aEmbeddabilityFilter);    

        IMPORT_C void SetEmbeddabilityFilterWithScreenMode(TEmbeddableFilter& aEmbeddabilityFilter, const TInt aScreenMode);  

        IMPORT_C void SetCapabilityAttributeMaskAndValue(const TInt aCapabilityAttributeMask, const TInt aCapabilityAttributeValue);

        IMPORT_C void SetCapabilityAttributeMaskAndValue(const TInt aCapabilityAttributeMask, const TInt aCapabilityAttributeValue, const TInt aScreenMode );

        IMPORT_C void SetServerApps(const TUid aServiceUid);

        IMPORT_C void SetServerApps(const TUid aServiceUid, const TInt aScreenMode);

        ~CAppInfoFilter();

        IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

        void InternalizeL(RReadStream& aStream);

    private:

        CAppInfoFilter();

        void ConstructL();

        enum TAppRegInfoFlag

            {

            EAllApps                                                    = 0x0001,

            EAllAppsWithScreenMode                                      = 0x0002,

            EGetEmbeddableApps                                          = 0x0004,

            EGetEmbeddableAppsWithSreenMode                             = 0x0008,

            EGetFilteredAppsWithEmbeddabilityFilter                     = 0x0010,

            EGetFilteredAppsWithEmbeddabilityFilterWithScreenMode       = 0x0020,

            EGetFilteredAppsWithCapabilityMaskAndValue                  = 0x0040,

            EGetFilteredAppsWithCapabilityMaskAndValueWithScreenMode    = 0x0080,

            EGetServerApps                                              = 0x0100,

            EGetServerAppsWithScreenMode                                = 0x0200,

            };

    private:

        TUint16               iSetFlag;                                 ///< Flag variable that shows what fields have been set

        TInt                  iScreenMode;                              ///< Sreen Mode of the application

        TEmbeddableFilter     iEmbeddabilityFilter;                     ///< Embeddabilty Filter

        TUint                 iCapabilityAttributeMask;                 ///< Capability attribute bit mask

        TUint                 iCapabilityAttributeValue;                ///< Capability attribute bit value

        TUid                  iServiceUid;                              ///< Service Uid

        TUid                  iAppUid;                                  ///< Application Uid

        };

    NONSHARABLE_CLASS(CAppServiceInfoFilter) : public CBase

    /*

     * A filter class that determines the information fields that need to be set before a GetServiceInfoL is invoked.

     * Initially an empty filter is created and subsequently the Set methods are used to set the filter based on the input parameters 

     * with which the GetServiceInfoL query is made.

     */

    	{

    	friend class CScrRequestImpl;

    public:

       	/**

    	Creates an empty CAppServiceInfoFilter filter object.

    	@return A pointer to the newly allocated CAppServiceInfoFilter filter object, if creation is successful.

    	*/

    	IMPORT_C static CAppServiceInfoFilter* NewL();

    	/**

    	Creates an empty CAppServiceInfoFilter filter object.

    	@return A pointer to the newly allocated CAppServiceInfoFilter filter object, if creation is successful.

    	The pointer is also put onto the cleanup stack.

    	*/

    	IMPORT_C static CAppServiceInfoFilter* NewLC();

    	/**

    	Creates a CAppServiceInfoFilter filter object from a stream.

    	@param aStream The stream to read the CAppServiceInfoFilter filter object from

    	@return A pointer to the newly allocated CAppServiceInfoFilter filter object, if creation is successful.

    	@internalComponent

    	*/

    	IMPORT_C static CAppServiceInfoFilter* NewL(RReadStream& aStream);

    	IMPORT_C void SetAppUidForServiceInfo (const TUid aAppUid);

    	IMPORT_C void SetServiceUidForServiceImplementations (const TUid aServiceUid);

    	IMPORT_C void SetServiceUidAndDatatTypeForServiceImplementationsL (const TUid aServiceUid, const TDesC& aDataType);

    	IMPORT_C void SetAppUidAndServiceUidForOpaqueData (const TUid aAppUid, const TUid aServiceUid);

    	~CAppServiceInfoFilter();

    	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

    	void InternalizeL(RReadStream& aStream);

    private:

    	CAppServiceInfoFilter();

    	void ConstructL();

    	enum TServiceInfoFlag

            {

            EGetServiceInfoForApp                                       = 0x0001,

            EGetServiceImplementationForServiceUid                      = 0x0002,

            EGetServiceImplementationForServiceUidAndDatatType          = 0x0004,

            EGetOpaqueDataForAppWithServiceUid                          = 0x0008,

            };

    private:

    	TUint16 iSetFlag;  

    	TUid iAppUid;

    	TUid iServiceUid;

    	HBufC* iDataType; 

    	};

    NONSHARABLE_CLASS(COpaqueData) : public CBase

        {

    friend class CScrRequestImpl;

    public:

        /**

            Creates an empty COpaqueData object.

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

         */            

        IMPORT_C static COpaqueData* NewL();

        /**

            Creates an empty COpaqueData object.

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

                    The pointer is also put onto the cleanup stack.

         */          

        IMPORT_C static COpaqueData* NewLC();

        /**

            Creates an empty COpaqueData object.

            @param aOpaqueData  A 8-bit buffer containing the opaque data.

            @param aLanguage    The language associated with the opaque data. 

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

         */       

        IMPORT_C static COpaqueData* NewL(TDesC8& aOpaqueData, TLanguage aLanguage);

        /**

            Creates an empty COpaqueData object.

            @param aOpaqueData  A 8-bit buffer containing the opaque data.

            @param aLanguage    The language associated with the opaque data. 

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

                     The pointer is also put onto the cleanup stack.

         */           

        IMPORT_C static COpaqueData* NewLC(TDesC8& aOpaqueData, TLanguage aLanguage);

        /**

            Creates a COpaqueData object from the stream.

            @param  aStream   The stream to read the COpaqueData object from.

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

         */           

        IMPORT_C static COpaqueData* NewL(RReadStream& aStream);

        /**

         @return The buffer containing the opaque data.

         */

        IMPORT_C HBufC8& OpaqueData();

        /**

         @return The language associated with the opaque data.

         */       

        IMPORT_C TLanguage Language();

        ~COpaqueData();

        IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

        IMPORT_C void InternalizeL(RReadStream& aStream);

    private:

        COpaqueData();

        void ConstructL(const TDesC8& aOpaqueData, TLanguage aLanguage);

    private:

        HBufC8* iOpaqueData;

        TLanguage iLanguage;

        };

    class CPropertyEntry;

    NONSHARABLE_CLASS(CApplicationRegistrationData) : public CBase

    /*

     * This contains the basic information of an application such as application's uid, filename, 

     * attributes, embeddability, groupname, default screen number, opaque data, 

     * an array of pointers to localizable info, properties, file ownership info etc.

     *  

     * N.B. Mandatory fields associated to an application are AppUid and AppFile

     *      AppFile should contain the abosulte file path, along with the drive and extension (if any)

     */

          {

          friend class CScrRequestImpl;

      public:

          /**

              Creates an empty CApplicationRegistrationData object.

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

           */            

          IMPORT_C static CApplicationRegistrationData* NewL();

          /**

              Creates an empty CApplicationRegistrationData object.

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

                      The pointer is also put onto the cleanup stack.

           */                 

          IMPORT_C static CApplicationRegistrationData* NewLC();

          /**

              Creates a CApplicationRegistrationData object from the stream.

              @param  aStream   The stream to read the CApplicationRegistrationData object from.

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

           */                        

          IMPORT_C static CApplicationRegistrationData* NewL(RReadStream& aStream);

          /**

              Creates a CApplicationRegistrationData object.

              @param aOwnedFileArray          An array of files owned by the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aServiceArray            An array of services related information associated with the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aLocalizableAppInfoList  An array of localizable information associated with the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aAppPropertiesArray      An array of properties associated with the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aOpaqueDataArray         An array of opaque data associated with the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aAppUid                  The Uid of the application.

              @param aAppFile                 The executable file associated with the application.

              @param aCharacteristics         The attributes associated with the application. @see Usif::TApplicationCharacteristics

              @param aDefaultScreenNumber

              @param aTypeId

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

           */          

          IMPORT_C static CApplicationRegistrationData* NewL(

                        RPointerArray<HBufC>& aOwnedFileArray,

                        RPointerArray<Usif::CServiceInfo>& aServiceArray,

                        RPointerArray<CLocalizableAppInfo>& aLocalizableAppInfoList,

                        RPointerArray<CPropertyEntry>& aAppPropertiesArray,

                        RPointerArray<COpaqueData>& aOpaqueDataArray,

                        TUid aAppUid, const TDesC& aAppFile, 

                        TApplicationCharacteristics& aCharacteristics,

                        TInt aDefaultScreenNumber, TInt aTypeId = 0);

          /**

              Creates a CApplicationRegistrationData object.

              @param aOwnedFileArray          An array of files owned by the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aServiceArray            An array of services related information associated with the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aLocalizableAppInfoList  An array of localizable information associated with the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aAppPropertiesArray      An array of properties associated with the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aOpaqueDataArray         An array of opaque data associated with the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aAppUid                  The Uid of the application.

              @param aAppFile                 The executable file associated with the application.

              @param aCharacteristics         The attributes associated with the application. @see Usif::TApplicationCharacteristics

              @param aDefaultScreenNumber

              @param aTypeId

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

                      The pointer is also put onto the cleanup stack.

           */            

          IMPORT_C static CApplicationRegistrationData * NewLC(

                        RPointerArray<HBufC>& aOwnedFileArray,

                        RPointerArray<CServiceInfo>& aServiceArray,

                        RPointerArray<CLocalizableAppInfo>& aLocalizableAppInfoList,

                        RPointerArray<CPropertyEntry>& aAppPropertiesArray,

                        RPointerArray<COpaqueData>& aOpaqueDataArray,

                        TUid aAppUid, const TDesC& aAppFile,

                        TApplicationCharacteristics& aCharacteristics,

                        TInt aDefaultScreenNumber, TInt aTypeId = 0);

           /**

              Creates a CApplicationRegistrationData object.

              @param aOwnedFileArray          An array of files owned by the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aServiceArray            An array of services related information associated with the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aLocalizableAppInfoList  An array of localizable information associated with the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aAppPropertiesArray      An array of properties associated with the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aAppUid                  The Uid of the application.

              @param aAppFile                 The executable file associated with the application.

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

           */            

          IMPORT_C static CApplicationRegistrationData* NewL(RPointerArray<HBufC>& aOwnedFileArray, RPointerArray<CServiceInfo>& aServiceArray, RPointerArray<CLocalizableAppInfo>& aLocalizableAppInfoList,

                                                             RPointerArray<CPropertyEntry>& aAppPropertiesArray, TUid aAppUid, 

                                                             const TDesC& aAppFile);

           /**

              Creates a CApplicationRegistrationData object.

              @param aOwnedFileArray          An array of files owned by the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aServiceArray            An array of services related information associated with the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aLocalizableAppInfoList  An array of localizable information associated with the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aAppPropertiesArray      An array of properties associated with the application. The ownership is also transferred to CApplicationRegistrationData.

              @param aAppUid                  The Uid of the application.

              @param aAppFile                 The executable file associated with the application.

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

			          The pointer is also put onto the cleanup stack.

           */             

          IMPORT_C static CApplicationRegistrationData* NewLC(RPointerArray<HBufC>& aOwnedFileArray, RPointerArray<CServiceInfo>& aServiceArray, RPointerArray<CLocalizableAppInfo>& aLocalizableAppInfoList,

                                                             RPointerArray<CPropertyEntry>& aAppPropertiesArray, TUid aAppUid, 

                                                             const TDesC& aAppFile);

          ~CApplicationRegistrationData();

          IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

		  IMPORT_C void InternalizeL(RReadStream& aStream);

          IMPORT_C const TUid AppUid() const;

          IMPORT_C const TDesC& AppFile() const;

          IMPORT_C TInt TypeId() const;

          IMPORT_C TUint Attributes() const;

          IMPORT_C TBool Hidden() const;

          IMPORT_C TApplicationCharacteristics::TAppEmbeddability Embeddability() const;

          IMPORT_C TBool NewFile() const;

          IMPORT_C TBool Launch() const;

          IMPORT_C const TDesC& GroupName() const;

          IMPORT_C TInt DefaultScreenNumber() const;

          IMPORT_C const RPointerArray<HBufC>& OwnedFileArray() const;

          IMPORT_C const RPointerArray<CServiceInfo>& ServiceArray() const;

          IMPORT_C const RPointerArray<CLocalizableAppInfo>& LocalizableAppInfoList() const;

          IMPORT_C const RPointerArray<CPropertyEntry>& AppProperties() const;

          IMPORT_C const RPointerArray<COpaqueData>& AppOpaqueData() const;

      private:

          CApplicationRegistrationData();

          void ConstructL(RPointerArray<HBufC>& aOwnedFileArray,

                RPointerArray<CServiceInfo>& aServiceArray, 

                RPointerArray<CLocalizableAppInfo>& aLocalizableAppInfoList,

                RPointerArray<CPropertyEntry>& aAppPropertiesArray,

                RPointerArray<COpaqueData>& aOpaqueDataArray, TUid aAppUid,

                const TDesC& aAppFile, TApplicationCharacteristics& aCharacteristics,

                TInt aDefaultScreenNumber, TInt aTypeId);

          void ConstructL(RPointerArray<HBufC>& aOwnedFileArray, RPointerArray<CServiceInfo>& aServiceArray,

                                    RPointerArray<CLocalizableAppInfo>& aLocalizableAppInfoList, RPointerArray<CPropertyEntry>& aAppPropertiesArray,

                                    TUid aAppUid, const TDesC& aAppFile);

          void ConstructL(const TDesC& aAppFile);

      private:

          RPointerArray<HBufC> iOwnedFileArray;                               // FileOwnershipInfo

          RPointerArray<CServiceInfo> iServiceArray;                    // Service Info and Service Data Type

          RPointerArray<CLocalizableAppInfo> iLocalizableAppInfoList;   //LocalizableAppInfo

          RPointerArray<CPropertyEntry> iAppPropertiesArray;            // AppProperties

          RPointerArray<COpaqueData> iOpaqueDataArray;

          // AppRegistrationInfo Table

          TUid iAppUid;

          HBufC* iAppFile;

          TInt iTypeId;

          TApplicationCharacteristics iCharacteristics;

          TInt iDefaultScreenNumber;                          

          };

  NONSHARABLE_CLASS(CDataType) : public CBase

  /*

   * It contains the priority and type information associated to each service provided by the application.