/*

* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:  Definition of CDocumentHandler class.

*                The purpose of the Documenthandler is to offer to applications

*                - wrapper for application embedding

*                - temporary file utility to support data caging for platform security 

*             

*

*/

#ifndef DOCUMENTHANDLER_H

#define DOCUMENTHANDLER_H

//  INCLUDES

#include <e32base.h>

#include <f32file.h>

// CONSTANTS

// App UIDs for handlers. Handlers are identified by the handler application's

// UID. E.g. The handler for WMLC (binary format of Wireless Markup Language)

// is responsible for launching the WMLBrowser. The data type

// application/wap.vnd.wmlc is therefore mapped to the browser's UID,

// 0x10008D39.

const TInt KTextHandler         = 0x1000599d;   // Notepad viever

const TInt KWmlcHandler         = 0x10008D39;   // WML Browser

const TInt KJamHandler          = 0x100009C1;   // JAM

const TInt KAppInstHandler      = 0x101F875A;   // Installer 

const TInt KBioViewerAppHandler = 0x0FC99F01;   // BVA

const TInt KImageViewerHandler  = 0x101f4d90;   // Image viever

const TInt KCertSaveAppHandler  = 0x100059D2;   // Cert response handler app

const TInt KCODHandler          = 0x10008d4a;   // COD handler

const TInt KDDhandler           = 0x10008d3f;   // DD Handler

// A global external mime type for all nokia games.

_LIT8(KGameMimeType, "application/x-NokiaGameData");

_LIT8(KDataTypeODM,"application/vnd.oma.drm.message"); // Not supported by DocumentHandler

_LIT8(KDataTypeDCF,"application/vnd.oma.drm.content"); // Deprecated, do not use from here

// Fail reasons

const TInt KBadMimeType         = -12002;        // Mime type conflict etc.

const TInt KMimeNotSupported    = -12003;        // No handler found

const TInt KNullContent         = -12005;        // Empty content

const TInt KDataDirNotFound     = -12006;        // Deprecated - not used

const TInt KExecNotAllowed      = -12007;        // Executables not allowed

const TInt KNoHostProcess       = -12008;        // Deprecated - not used

const TInt KNotInitialized      = -12009;        // Not initialized

const TInt KUserCancel          = -12010;        // User cancelled operation

const TInt KDRMErrSession           = -12011;   // DRM session error.

const TInt KDRMErrNoRights          = -12012;   // Invalid DRM rights.

const TInt KDRMErrRightsDBCorrupted = -12013;   // DRM rights db corrupted.

const TInt KDRMErrInvalidVersion    = -12014;   // Invalid DRM version.

const TInt KDRMErrPreviewRights     = -12015;   // Preview DRM rights.

// DATA TYPES

// API operations to inform special handlers of the entry function.

enum TDocOperation

    {

    EDocCopy,               // CopyL( aFileNameOld, aNameNew, aDataType, aAttr)

    EDocSave,               // SaveL( aContent, aDataType, aAttr )

    EDocSaveAs,             // SaveL( aContent, aDataType,aFileName, aAttr )

    EDocOpenFile,           // OpenFileL( aFileName, aDataType )

    EDocOpenFileEmb,        // OpenFileEmbeddedL( aFileName, aDataType) 

    EDocMove,               // MoveL( aFileNameOld, aNameNew, aDataType, aAttr)

    EDocSilentMove,         // SilentMoveL( aFileNameOld, aNameNew, aRootPaht, aDataType, aAttr)

    EDocSaveTemp,           // SaveTempFileL( aContent, aDataType, aFileName, aSharableFile)

    };

// FORWARD DECLARATIONS

class CDocHandlerBase;                       // Base class for handlers

class CEikProcess;                           // The host process

class MAknServerAppExitObserver;             // Viewer app exit observer 

class TDataType;                             // Mime type handling

class RApaLsSession;                         // App list server session

class CAiwGenericParamList;                  // Generic parameter list 

// CLASS DECLARATION

/**

* Utility class for opening and saving any supported content.

* This class declares an interface for the DocumentHandler, a

* common component in Series60.

*

* The CDocumentHandler class will not itself implement any content

* handling routines. It's responsible for finding out which application

* can handle given data type and constructing a correct handler implementation

* for that application. If the given data type is supported by the system

* but no specific handler is found, the CDocDefaltHandler is then constructed.

* The default handler is an implementation of the CDoCDocHandlerBase class with

* standard "Epoc-style" content handling.

*

* The handler application can be lauched standalone or embedded. The

* Embedded launching is preferred way in Series60.

* Standalone launching means that the application will run in

* it's own process. Embedded launching means that the UI of an

* application, which is responsible for handling given data type,

* is embedded into the parent application. There will be only

* parent applications icon shown in the fast swap window when an

* application is embedded.

*

* Link your application against CommonUI.lib.

*

* <b>An example: </b> 

*<pre> 

* #include <DocumentHandler.h>

*

* <i>// Define DocHandler</i>

* CDocumentHandler* iDocHandler;

* 

* <i>// Construct DocHandler</i>

* void ConstructL()

*    {

*    iDocHandler = CDocumentHandler::NewL();

*

*    <i>// I want to be notified when exit happends. Because I

*    // pass "this" pointer, I have to derive from

*    // MAknServerAppExitObserver class.</i>

*    iDocHandler->SetExitObserver(this)     

*    }

*

* <i>// delete DocHandler</i>

* void ~Myapp()

*    {

*    delete iDocHandler;

*    }

*

*

* <i>// and use like this</i>

*

* void OpenAttachmentL( RFile& aFile,           <i>// A file to be open</i>

*                       TDataType& aDataType )  <i>// DataType can be empty</i>

*   {

*   TInt error = KErrNone;

*   TFileName path;

*

*   <i>

*   // Leaves on system wide errors like disk full, out of memory etc.</i>

*   error = iDocHandler->OpenFileEmbeddedL( aFile, aDataType );

*   // The status code can be either KErrNone or KUserCancel

*

*    }

* </pre>

*

*/

NONSHARABLE_CLASS(CDocumentHandler) : public CBase

    {

    public:        // Constructors and destructor

        /**

        * Two-phased constructor. Leaves on failure.

        *

        * @param aProcess   The host process, which will be

        *                   used for embedded launching.

        *

        * @return           The constructed CDocumentHandler

        * @deprecated in Series60 3.0, instead use NewL without CEikProcess parameter

        */

        IMPORT_C static CDocumentHandler* NewL( CEikProcess* aProcess );

        /**

        * Two-phased constructor. Leaves on failure.

        *

        * @param aProcess   The host process, which will be

        *                   used for embedded launching.

        *

        * @return           The constructed CDocumentHandler

        * @deprecated in Series60 3.0, instead use NewL without CEikProcess parameter

        */

        IMPORT_C static CDocumentHandler* NewLC( CEikProcess* aProcess );

        /**

        * Two-phased constructor. Leaves on failure.

        *

        *

        * @return           The constructed CDocumentHandler

        * @since Series 60 3.0

        */

        IMPORT_C static CDocumentHandler* NewL( );

        /**

        * Two-phased constructor. Leaves on failure.

        *

        *

        * @return           The constructed CDocumentHandler

        * @since Series 60 3.0

        */

        IMPORT_C static CDocumentHandler* NewLC( );

        /**

        * Destructor.

        */

        IMPORT_C virtual ~CDocumentHandler();

    private:        // Constructors and destructor

        /**

        * C++ default constructor.

        */

        CDocumentHandler( );

        /**

        * C++ copy constructor

        */

        CDocumentHandler( const CDocumentHandler& );

        /**

        * By default EPOC constructor is private.

        */

        void ConstructL();

    public:       // New functions, data caging

      /**

       * Utility method for opening filehandle from existing file for OpenFileL 

       * calls. The created file handle is meant to be shared across process 

       * boundaries.

       * 

       * This function can leave in some system wide error situation.

       * E.g. out of memory, not enough space in filesystem etc. These

       * errors are usually trapped by the application framework.

       *

       * NOTE! Caller is responsible of closing opened file handle. 

       *

       * @param aFileName  Name (including directory information) for file. 

       *                   This file should exist allready, otherwise this 

       *                   function leaves with KErrNotFound. 

       * @param aSharableFile Returned file handle that can be shared.

       * @since Series 60 3.0

       */

      IMPORT_C void OpenTempFileL(

          const TDesC& aFileName,

          RFile &aSharableFile);

      /**

       * Utility method for save aContent with aDataType temporarily

       * for OpenFileL calls. The created file handle is meant to be shared 

       * across process boundaries.

       *

       * This temporary file will be saved to process private temp directory.

       * Temporary directory will be created if not existing yet. 

       *

       * This function can leave in some system wide error situation.

       * E.g. out of memory, not enough space in filesystem etc. These

       * errors are usually trapped by the application framework.

       *

       * NOTE! Caller is responsible of closing opened file handle!

       * Created temporary file will be deleted in destructor of 

       * DocumentHandler, but caller can delete it self as well.

       *

       * @param aContent   A content data buffer. Narrow descriptor that

       *                   can contain any kind of data.

       * @param aDataType  A data type for the content of the file. If empty

       *                   the DocumentHandler tries to recognize the content.

       * @param aFileName  Use this name for saving. The name must not 

       *                   contain any directory information.

       * @param aSharableFile Returned file handle that can be shared.

       * @since Series 60 3.0

       */

      IMPORT_C void SaveTempFileL(

          const TDesC8& aContent,

          TDataType& aDataType,

          const TDesC& aFileName,

          RFile &aSharableFile);

    public:       // New functions, parameter handling

      /**

       * Returns an empty instance of CAiwGenericParamList class. It can be

       * used for example as an input parameter list for API methods.

       * This is just a convinience method and doesn't have

       * to be used. If consumer wants to create input list by itself

       * it is ok. If this method is used, service handler takes care

       * of deleting returned generic parameter list.

       *

       * @return  An empty instance of CAiwGenericParameter list.

       * @since Series 60 3.0

       */

      IMPORT_C CAiwGenericParamList& InParamListL();

      /**

       * Returns a list of possible output parameters handler application

       * may have set after executing the service. The caller is responsible 

       * for deleting the parameter instance if not null.

       *

       * @return   List of output parameters, NULL if nothing set.

       * @deprecated

       */          

      IMPORT_C const CAiwGenericParamList* OutParamList();

    public:       // New functions, open file with filehandle

       /**

        * Launches an application in standalone capable of handling

        * data in aSharableFile (using aDatatype if available). 

        * Doesn't save data from the file. In case of DRM protected 

        * files with restricted rights, there will be query asking

        * if user want open file. 

        *

        * This function can leave in some system wide error situation.

        * E.g. out of memory, not enough space in filesystem etc. See 

        * also possible error codes from documenthandler.h header file.

        * 

        * @param aSharableFile  A sharable file handle to be passed to

        *                       the launched application

        * @param aDataType  A data type for the content of the file. If empty

        *                   the DocumentHandler tries to recognize the content.

        * @return           KErrNone if success. KUserCancel if the user 

        *                   cancelled the operation. 

        * @since Series 60 3.0

        */

      IMPORT_C TInt OpenFileL(

          RFile& aSharableFile,

          TDataType& aDataType);      

       /**

        * Launches an application in embedded (if possible) capable of 

        * handling data in aSharableFile (using aDatatype if available). 

        * Doesn't save data from the file. In case of DRM protected

        * files with restricted rights, there will be query asking

        * if user want open file. 

        *

        * This function can leave in some system wide error situation.

        * E.g. out of memory, not enough space in filesystem etc. See 

        * also possible error codes from documenthandler.h header file.

        *

        * @param aSharableFile  A sharable file handle to be passed to

        *                       the launched application. 

        * @param aDataType  A data type for the content of the file. If empty

        *                   the DocumentHandler tries to recognize the content.

        * @param aParamList Parameter list to be passed to handler application.

        * @return           KErrNone if success. KUserCancel if the user 

        *                   cancelled the operation. 

        * @since Series 60 3.0

        */

      IMPORT_C TInt OpenFileEmbeddedL(

          RFile& aSharableFile,

          TDataType& aDataType,

          const CAiwGenericParamList& aParamList);

        /**

        * Launches an application in embedded (if possible) capable of 

        * handling data in aSharableFile (using aDatatype if available). 

        * Doesn't save data from the file. In case of DRM protected

        * files with restricted rights, there will be query asking

        * if user want open file. 

        *

        * This function can leave in some system wide error situation.

        * E.g. out of memory, not enough space in filesystem etc. See 

        * also possible error codes from documenthandler.h header file.

        *

        * @param aSharableFile  A sharable file handle to be passed to

        *                       the launched application. 

        * @param aDataType  A data type for the content of the file. If empty

        *                   the DocumentHandler tries to recognize the content.

        * @return           KErrNone if success. KUserCancel if the user 

        *                   cancelled the operation. 

        * @since Series 60 3.0

        */

      IMPORT_C TInt OpenFileEmbeddedL(

          RFile& aSharableFile,

          TDataType& aDataType);

    public:       // open file with filename

        /**

        * Launches an application standalone capable of handling

        * data in aFilename, with aDataType. Doesn't copy data

        * from the file.

        *

        * This function can leave in some system wide error situation.

        * E.g. out of memory, not enough space in filesystem etc. See 

        * also possible error codes from documenthandler.h header file.

        *

        * @param aFileName  Name of the file. Directory path included.

        * @param aDataType  A data type for the content of the file. If empty

        *                   the DocumentHandler tries to recognize the content.

        * @return           KErrNone if success. KUserCancel if the user 

        *                   cancelled the operation.

        */

        IMPORT_C TInt OpenFileL(

            const TDesC& aFileName,

            TDataType& aDataType );

        /**

        * Launches an application embedded capable of handling data in

        * aFilename with aDataType. Doesn't copy data from the file.

        *

        * This function can leave in some system wide error situation.

        * E.g. out of memory, not enough space in filesystem etc. See 

        * also possible error codes from documenthandler.h header file.

        *

        * @param aFileName  Name of the file. Directory path included.

        * @param aDataType  A data type for the content of the file. If empty

        *                   the DocumentHandler tries to recognize the content.

        * @return           KErrNone if success. KUserCancel if the user 

        *                   cancelled the operation.

        */

        IMPORT_C TInt OpenFileEmbeddedL(

            const TDesC& aFileName,

            TDataType& aDataType );

    public:       // data saving

        /**

        * Save aContent with aDataType using aAttr to a correct directory.

        * Generates a new name for saving. The storage is usually a filesystem, 

        * but can be anything from application spesific data structures to 

        * a database.

        *

        * This function can leave in some system wide error situation.

        * E.g. out of memory, not enough space in filesystem etc. See 

        * also possible error codes from documenthandler.h header file.

        *

        * @param aContent   A content data buffer. Narrow descriptor that

        *                   can contain any kind of data.

        * @param aDataType  A data type for the content of the file. If empty

        *                   the DocumentHandler tries to recognize the content.

        * @param aAttr      Use these file attributes for saving. Your can 

        *                   find these attributes from 

        *                   \epoc32\include\f32file.h header file. 

        *                   If the storage is not a filesystem these 

        *                   attributes are ignored.

        * @return           KErrNone if success. KUserCancel if the user 

        *                   cancelled the operation.

        */

        IMPORT_C TInt SaveL(

            const TDesC8& aContent,

            TDataType& aDataType,

            const TUint aAttr );

        /**

        * Save aBuffer with aDataType using aAttr to a correct storage with a

        * supplied name. The storage is usually a filesystem, but can be 

        * anything from application spesific data structures to a database.

        *

        * This function can leave in some system wide error situation.

        * E.g. out of memory, not enough space in filesystem etc. See 

        * also possible error codes from documenthandler.h header file.

        *

        * @param aContent   A content data buffer. Narrow descriptor that

        *                   can contain any kind of data.

        * @param aDataType  A data type for the content of the file. If empty

        *                   the DocumentHandler tries to recognize the content.

        * @param aName      Use this name for saving. The name must not 

        *                   contain any directory information.

        * @param aAttr      Use these file attributes for saving. Your can 

        *                   find these attributes from 

        *                   \epoc32\include\f32file.h header file. 

        *                   If the storage is not a filesystem these 

        *                   attributes are ignored.

        * @return           KErrNone if success. KUserCancel if the user 

        *                   cancelled the operation.

        */

        IMPORT_C TInt SaveL(

            const TDesC8& aContent,

            TDataType& aDataType,

            const TDesC& aName,

            const TUint aAttr );

        /**

        * Copy a file named aFileNameOld to the correct storage using

        * name aNameNew and aFileAttr. If aNameNew is empty, use

        * the old name.

        *

        * This function can leave in some system wide error situation.

        * E.g. out of memory, not enough space in filesystem etc. See 

        * also possible error codes from documenthandler.h header file.

        *

        * @param aFileNameOld   Name of the file being copied.

        * @param aNameNew       Name of the new file. If null, use the 

        *                       old name.

        * @param aDataType      A data type for the file. If empty the 

        *                       DocumentHandler tries to recognize type.

        * @param aAttr          Use these file attributes for saving. 

        *                       ReadOnly, ReadWrite.

        * @return               KErrNone if success. KUserCancel if the user 

        *                       cancelled the operation.

        */

        IMPORT_C TInt CopyL(

            const TDesC& aFileNameOld,

            const TDesC& aNameNew,

            TDataType& aDataType,

            const TUint aAttr );

        /**

        * Copy a file with handle aFileOld to the correct storage using

        * name aNameNew and aFileAttr. If aNameNew is empty, use

        * the old name.

        *

        * This function can leave in some system wide error situation.

        * E.g. out of memory, not enough space in filesystem etc. See 

        * also possible error codes from documenthandler.h header file.

        *

        * @param aFileOld       Handle of the file being copied.

        * @param aNameNew       Name of the new file. If null, use the 

        *                       old name.

        * @param aDataType      A data type for the file. If empty the 

        *                       DocumentHandler tries to recognize type.

        * @param aAttr          Use these file attributes for saving. 

        *                       ReadOnly, ReadWrite.

        * @return               KErrNone if success. KUserCancel if the user 

        *                       cancelled the operation.

        */

        IMPORT_C TInt CopyL(

            const RFile& aFileOld,

            const TDesC& aNameNew,

            TDataType& aDataType,

            const TUint aAttr );

        /**

        * Move a file named aFileNameOld to the correct storage using

        * name aNameNew and aFileAttr. Note that file in the old location 

        * (aFileNameOld) will be removed during this operation.

        *

        * This function can leave in some system wide error situation.

        * E.g. out of memory, not enough space in filesystem etc. See 

        * also possible error codes from documenthandler.h header file.

        *

        * @param aFileNameOld   Name of the file being copied.

        * @param aNameNew       Name of the new file. If null, use the 

        *                       default name for this mime-type. 

        * @param aDataType      A data type for the file. If empty the 

        *                       DocumentHandler tries to recognize type.

        * @param aAttr          Use these file attributes for saving. 

        *                       ReadOnly, ReadWrite.

        * @return               KErrNone if success. KUserCancel if the user 

        *                       cancelled the operation.

        * @since Series60 2.8

        */

        IMPORT_C TInt MoveL(

            const TDesC& aFileNameOld,

            const TDesC& aNameNew,

            TDataType& aDataType,

            const TUint aAttr );

        /**

        * Move a file named aFileNameOld to the correct storage using

        * name aNameNew and aFileAttr. This method operates silently, so 

        * nothing will be asked from user. Caller should give root path of 

        * the selected memory. Unique file name will be created automatically 

        * without user interaction. Note that file in the old location 

        * (aFileNameOld) will be removed during this operation. 

        *

        * This function can leave in some system wide error situation.

        * E.g. out of memory, not enough space in filesystem etc. See 

        * also possible error codes from documenthandler.h header file.

        * 

        * @param aFileNameOld   Name of the file being copied.

        * @param aNameNew       Name of the new file. If null, use the 

        *                       default name for this mime-type. 

        * @param aRootPath      Root path of the selected memory where file 

        *                       should be moved.

        * @param aDataType      A data type for the file. If empty the 

        *                       DocumentHandler tries to recognize type.

        * @param aAttr          Use these file attributes for saving. 

        *                       ReadOnly, ReadWrite.

        * @return               KErrNone if success. 

        * @since Series60 3.0

        */

        IMPORT_C TInt SilentMoveL(

            const TDesC& aFileNameOld,

            const TDesC& aNameNew,

            const TDesC& aRootPath,

            TDataType& aDataType,

            const TUint aAttr );

    public:       // query functions

        /**

        * Is the aDataType supported by the system.

        *

        * @param    aDataType Data type for content.

        *

        * @return   True if there is an application capable of handling

        *           aDataType. False if no application can handle

        *           this mime type.

        */

        IMPORT_C TBool CanHandleL( const TDataType& aDataType );

        /**

        * Is opening of aDataType supported by the system.

        *

        * @param    aDataType Data type for content.

        *

        * @return   True if there is an application capable of handling

        *           aDataType. False if no application can handle

        *           this mime type.

        */

        IMPORT_C TBool CanOpenL( const TDataType& aDataType );

        /**

        * Is saving aDataType supported by the system.

        *

        * @param    aDataType Data type for content.

        *

        * @return   True if there is an application capable of handling

        *           aDataType. False if no application can handle

        *           this mime type.

        */

        IMPORT_C TBool CanSaveL( const TDataType& aDataType );

        /**

        * Get the whole path including filename where the content was saved.

        * If the content was not saved to a file, this function returns

        * a name that represents the saved object.  

        * 

        * It may not be possible to open the object with the returned 

        * value, if it's not a real file in the filesystem. This situation

        * may happen when e.g. the handler application stores it's contents in

        * some weird data structure.

        *

        * @param    aPath The path of the saved content.

        *

        * @return   KErrNone if the path was found. KNotInitialised if the  

        *           handler is not initialised.        

        */

        IMPORT_C TInt GetPath( TDes& aPath );   

        /**

        * Get the uid of handler application. In case of media files uid is 

        * Media Gallery's uid. This method should be called only succesfully 

        * completed DocumentHandler operations. 

        *

        * @param    aUid Uid of the handler application for the content. 

        *

        * @return   KErrNone if the uid was found. KNotInitialised if the 

        *           handler is not initialised.        

        * @since Series 60 2.8

        */

        IMPORT_C TInt HandlerAppUid( TUid& aUid );   

        /**

        * Set an observer for embedded application exit events. 

        * DocumentHandler will delegate embedding applications exit 

        * events to aObserver if it's not NULL:

        * 

        * @param    aObserver Exit observer

        * @since Series 60 3.0

        */

        IMPORT_C void SetExitObserver( MAknServerAppExitObserver* aObserver );

        /**

        * Utility method for appending a correct file name extension for some 

        * content. This method should be called if wanted quarantee that file 

        * extension of aFileName is correct with aDataType. 

        *

        * This method uses internal mapping table to find correct file 

        * extension to aFileName. Mapping table contains mainly extensions

        * and datatypes, which cannot be recognized based on the data it self 

        * (No header information etc.). 

        *

        * This method replaces existing extension with correct one at aFileName 

        * if needed. If aDatatype is not found from mapping table or aDatatype

        * is not supported by any application, aFileName will remain unchanged.

        *

        * @param aFileName  Append extension to this filename. 

        * @param aDataType  The content type of the file.

        * @since Series 60 3.0

        */

        IMPORT_C void CheckFileNameExtension(

            TDes& aFileName,

            const TDataType& aDatatype );

        /**

        * Get the RApaLsSession.

        *

        * @return Pointer to RApaLsSession

        */

        RApaLsSession* ApaLs();

        /**

        * Get the exit observer.    

        *

        * @return Pointer to exit observer

        * @since Series 60 3.0

        */

        MAknServerAppExitObserver* ServerAppExitObserver() const;

        /**

        * Get the operation code of the api entry function.

        */

        TDocOperation DocOperation() const;

        /** 

        * Close sharable FileSession. 

        */

        void CloseSharableFS();

        /**

        * Set temporary file, which will be deleted in destructor.

        */

        void SetTempFile( const TDesC& aTempFile);

        /**

        * Utility method to find out if there are any applications that 

        * support progressive downloading for a given data type. 

        *        

        * The decision is based on configuration made in central repository.

        *

        * @param aDataType  The content type of the file.

        * @param aUid  An Uid of the applications for the given data type.

        * @return ETrue if progressive download was supported for the given

        *   data type. Otherwise EFalse.

        * @since Series 60 3.1

        */

        IMPORT_C TBool CanHandleProgressivelyL( 

            const TDataType& aDataType, 

            TUid& aUid );

        /**

        * Utility method to provide a list of applications that support 

        * progressive downloading. 

        *

        * The list of applications uids is configured central repository.

        *

        * @param aUidList A list of app Uids

        * @since Series 60 3.2

        */            

        IMPORT_C void GetProgressiveDownloadAppUidsL( RArray<TInt32>& aUidList );            

    private:        // New functions

        /**

        * Construct a handler for a given data type. A previous handler will 

        * be destroyed and the new one is constructed.

        *

        * The desicion of which handler implementation to use is

        * based on Apparc's AppForDataType query. If the app uid is

        * found for aDataType and there is a hardcoded handler for it,

        * the right handler will be constucted. If the app uid is not found

        * try to match a data type for some handler. The default handler is

        * constructed if no handler entry is found.

        *

        * @param    aUid UID of the handler application.

        * @return   Error code

        */

        TInt FindHandlerL(

            const TDataType& aDataType,

            const TUid& aUid);

        /**

        * Try to find a handler for aUid. Constructs iHandler if found.

        *

        * @param aDataType A data type to pass to a handler

        * @param aUid An uid to search a handler for

        */

        void FindHandlerByUidL( 

            const TUid& aUid, 

            const TDataType& aDataType);

        /**

        * Try to find a handler for aDataType. Constructs iHandler if found.

        *

        * @param aUid      An Uid for handler application.

        * @param aDataType A data type to search a handler for.

        */

        void FindHandlerByMimeTypeL( 

            const TUid& aUid, 

            const TDataType& aDataType);

        /**

        * Makes all the nesessary security checks and maps aDataType to 

        * an UID of the handler application. If system is not able to handle 

        * the content type, or file is DRM protectedfile, aDataType and aUid  

        * will left empty.

        *

        * @param aFileName  Filename

        * @param aDataType  Data type for the file

        * @param aUid       An application UID will be returned if a handler 

        *                   was found.

        * @return           KErrNone if success, error code if failure.

        */

        TInt RecognizeAndCheckFileL(

            const TDesC& aFileName,

            TDataType& aDataType,

            TUid& aUid );     

        /**

        * Makes all the nesessary security checks and maps aDataType to 

        * an UID of the handler application. If system is not able to handle 

        * the content type, or file is DRM protectedfile, aDataType and aUid  

        * will left empty.

        *

        * @param aFileHandle Filehandle

        * @param aDataType  Data type for the file

        * @param aUid       An application UID will be returned if a handler 

        *                   was found.

        * @return           KErrNone if success, error code if failure.

        */

        TInt RecognizeAndCheckFileL(

            RFile& aFileHandle,

            TDataType& aDataType,

            TUid& aUid );     

        /**

        * This method lists all supported mime-types of system using 

        * RDebug::Print. On UREL mode this method do nothing.

        */

        void ListSupportedMimeTypesL();

        /**

        * Prohibit the assignment operation

        */

        CDocumentHandler operator=( const CDocumentHandler& )  const;

        /**

        * Convert a hex string to 32-bit integer.

        */        

        TInt ConvertHexStringToInt32( 

            const TDesC& aHexString, 

            TInt32& aInt );               

    private:          // Data

        /**

        * The entry operation. Handlers can query about the entry function

        * when they need to implement some special behaviour.

        */

        TDocOperation iOperation;

        /**

        * A handler providing operations. 

        */

        CDocHandlerBase* iHandler;

        /**

        * A ApaLs session client.

        */

        RApaLsSession* iApaLs;

        /**

        * Notify embedded app's exit event to this observer.

        */

        MAknServerAppExitObserver* iServerAppExitObserver;

        /**

        * Holds sharable Fileserver session

        */

        RFs iSharableFS;

        /**

        * Parameter list created using InParamListL function

        */

        CAiwGenericParamList* iInParams;

        /**

        * Filename of temporary saved file. This file will be deleted 

        * in destructor of documenthandler

        */

        TFileName iTempFileName;     

    };

#endif              // DOCUMENTHANDLER_H

// End of File