/*
* Copyright (c) 2006 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:  Plugin handling, manages the loading and unloading of the
*                plugin. Initializes the CInfoArray that contains the plugin
*                MIME-types supported.
*
*/

#ifndef PluginHandler_H
#define PluginHandler_H

//  INCLUDES
#include <e32std.h>
#include <npupp.h>
#include <f32file.h>
#include <badesca.h>
#include <wtf/HashSet.h>
#include <ECom/ImplementationInformation.h>    // ecom
#include "Ecombrowserplugininterface.h"
#include "WebCorePluginHandler.h"

// FORWARD DECLARATIONS
class PluginInfo;
class WebView;
class PluginSkin;

// CLASS DECLARATION

/**
* Primarily deals with the loading and unloading of plugins as well as
* other plugin utility functions.
*
*  @lib Browser Engine
*  @since 3.1
*/
class PluginHandler : public CBase
    {
    public:  // Constructors and destructor

        /**
        * Two-phased constructor.
        * @param aEnablePlugin flag to check for plugin support enabled by Browser Setting
        * @param aWebKitView Pointer to the browser view
        */
        static PluginHandler* NewL(TBool enablePlugin);

        /**
        * Destructor.
        */
        virtual ~PluginHandler();


    public: // New functions


        /**
        * Find a plugin by MIME type
        *
        * @since 3.1
        * @param aMIMEType The MIME type of the <object> element.
        * @return The handle of the plugin supporting the MIME type or KErrNotFound.
        */
        TInt findPlugin(const TDesC& mimeType);

        /**
        * Find a plugin by file extension
        *
        * @since 3.1
        * @param aFileName The url of the <object> element data.
        * @return The handle of the plugin supporting the file name or KErrNotFound.
        */
        TInt findPluginByExtension(const TDesC8& url);

        /**
        * Load a plugin if not yet loaded
        *
        * @since 3.1
        * @param aHandle The handle of the plugin, returned from FindPlugin.
        * @param aPluginFuncs Upon success it contains the associated
        *        plugin's function table.
        * @return void
        */

        void loadPluginL(TInt handle, NPPluginFuncs** retFuncs);

        /**
        * Unload a plugin. If this is the last instance, the library is unloaded.
        *
        * @since 3.1
        * @param aHandle The handle of the plugin, returned from FindPlugin.
        * @return void
        */
        void unloadPlugin(TInt handle);

        /**
        * Get the index of plugin info from its handle.
        *
        * @since 3.1
        * @param aHandle The handle of the plugin, returned from FindPlugin.
        * @return the index of the plugin info.
        */
        TUint getIndexFromHandle(TInt handle);

    public: //From MWebCorePluginHandler

        TInt getPluginCount();
        TBool pluginSupportsMIMEType(const TDesC& mimeType);
        TBool objectAtIndex(TInt index, TWebCorePluginInfo& aPluginInfo );
        void refreshPlugins(TBool reload);
        HBufC8* extensionsForMIMEType(TInt index, TDesC& mimeType);
        HBufC* descriptionForMIMEType(TInt index, TDesC& mimeType);

        /**
        * Determines whether a given content-type of dot-extension has a cooresponding
        * plugin or external application.  aContentType and aUrl can be NULL, but at least
        * one must be non-NULL (otherwise it will always return EFalse).  If aHandlerType
        * is EPlugin then it returns ETrue only if their is a supported plugin.  If aHandlerType
        * is EExternalApp then it returns ETrue only if their is a supported external
        * application.  If aHandlerType is EBoth then it returns ETrue only if their is a
        * supported plugin or external application.
        *
        * @since 3.1
        * @param aContentType the content type to compare against, may be NULL.
        * @param aUrl the url to extract the dot-extension and to compare against, may be NULL.
        *
        * @return ETrue or EFalse.
        */
        TBool isSupported(const TDesC& contType, const TDesC8& url);
        void  storePluginObject(PluginSkin* pluginObj);
        void  removePluginObject(PluginSkin* pluginObj);
        WTF::HashSet<PluginSkin*>& pluginObjects() { return m_pluginObjects; };
        PluginSkin*  pluginToActivate() { return m_pluginToActivate; };
        void  setPluginToActivate(PluginSkin* pluginObj) {m_pluginToActivate = pluginObj; };
        PluginSkin*  activePlugin() { return m_activePlugin; };
        void setActivePlugin(PluginSkin* pluginObj) { m_activePlugin = pluginObj; };
        HBufC* pluginMimeByExtention(const TPtrC8& url);
        PluginInfo* pluginInfoByExtention(const TPtrC8& aUrl, TInt* aExtIdx);

    private: // New functions

        /**
        * Scans for new plugins.
        *
        * @since 3.1
        * @param aReloadPages if ETrue the current page is reloaded.
        * @return void.
        */
        void reloadPluginsL(TBool reload);

        /**
        * C++ default constructor.
        * @param aEnablePlugin flag to check if plugin support is enabled by Browser Settings
        * @param aWebKitView pointer to CWebKitView
        */
        PluginHandler(TBool enablePlugin);

        /**
        * By default Symbian 2nd phase constructor is private.
        */
        void ConstructL();

        /**
        * Initializes the PluginHandler, possibly asynchronously.
        *
        * @since 3.1
        * @return void.
        */
        static TBool initialize(TAny* pluginHandler);

        /**
        * Loads all the plugins and query them for details. Used during
        * initialization.
        *
        * @since 3.1
        * @return void.
        */
        TBool loadPluginsL();

    private:    // Data

        // Array of information about existing plugins
        RPointerArray<PluginInfo>   m_pluginInfoArray;
        WTF::HashSet<PluginSkin*>   m_pluginObjects;
        TInt                        m_nextHandle;
        TBool                       m_pluginsLoaded;
        TBool                       m_enablePlugins;
        TBool                       m_asyncLoading;      //ETrue for Async scanning of drives
                                                        //EFalse for sync scanning and loading

        CIdle*                      m_idle;              //Active Object to initailise
                                                        //the plugins from drives
        PluginSkin*                 m_pluginToActivate;
        PluginSkin*                 m_activePlugin;
    };


/**
* A private helper class used by PluginHandler which is used
* to interact with individual plugins.
*
* @lib Browser Engine
* @since 3.1
*/
class PluginInfo : public CBase
    {
    public:  // Constructors and destructor

        /**
        * Two-phased constructor.
        */
        static PluginInfo* NewL(const TDesC& mimeDescription, const TDesC& name,
                const TDesC& description, const TDesC& fileName, const TDesC& pathName);

        /**
        * Destructor.
        */
        virtual ~PluginInfo();


    public:  // New functions

        /**
        * Returns ETrue if the plugin should be loaded.
        *
        * @since 3.1
        * @return ETrue or EFalse
        */
        TBool shouldLoad();

        /**
        * Returns ETrue if the plugin should be unloaded.
        *
        * @since 3.1
        * @return ETrue or EFalse
        */
        TBool shouldUnload();

        /**
        * Increments the PluginInfo's reference count.
        *
        * @since 3.1
        * @return void
        */
        void loadInstance();

        /**
        * Decrements the PluginInfo's reference count.
        *
        * @since 3.1
        * @return void
        */
        void unloadInstance();

        /**
        * Copy the mimetypes and file extention from one PluginInfo to another.
        * Called after a rescan of the file system.
        *
        * @since 3.1
        * @param aPluginInfo the instance to move mimetypes and file extentions from.
        * @return void.
        */
        void copyMimeDescription(PluginInfo& pluginInfo);

        /**
        * Getter function.
        *
        * @since 3.1
        * @return The mime types supported by this plugin
        */

        const RPointerArray <HBufC>&  mimeTypes() {return m_mimeTypes;}

        /**
        * Getter function.
        *
        * @since 3.1
        * @return The mime extensions supported by this plugin
        */

        const RPointerArray <HBufC8>&  mimeFileExtensions() {return m_mimeFileExtensions;}

        /**
        * Getter function.
        *
        * @since 3.1
        * @return The mime descriptions supported by this plugin
        */

        const RPointerArray <HBufC>&  mimeDescriptions() {return m_mimeDescriptions;}

        /**
        * Getter function.
        *
        * @since 3.1
        * @return The list of mimeExtensions given the mimeType supported by this plugin
        * The list of mimeExtensions is a comma-delimited string. For example, given
        * the mimeType "text/html", you will receive "html,htm".
        */

        HBufC8* getMimeExtensionsL(const TDesC& mimeType);

        /**
        * Getter function.
        *
        * @since 3.1
        * @return The name of this plugin
        */
        HBufC* name() {return m_name;}

        /**
        * Getter function.
        *
        * @since 3.1
        * @return The description of this plugin
        */
        HBufC* description() {return m_description;}

        /**
        * Getter function.
        *
        * @since 3.1
        * @return The file name of this plugin
        */
        HBufC* fileName() {return m_filename;}

        void parseDefaultDataL(const TDesC8& mimeDescription);
        void parseDisplayNameL(const TDesC& pluginDescription);

    private:  // Private Methods

        /**
        * C++ default constructor.
        */
        PluginInfo();

        /**
        * By default Symbian 2nd phase constructor is private.
        */
    public:   //Data
        CImplementationInformation* m_pluginInfo;  // ECom plugin implementation info

    private:  // Data

        RPointerArray <HBufC>  m_mimeTypes;
        RPointerArray <HBufC8> m_mimeFileExtensions;
        RPointerArray <HBufC>  m_mimeExtensionToTypeMap;
        RPointerArray <HBufC>  m_mimeDescriptions;


        HBufC*                 m_name;
        HBufC*                 m_description;
        TInt                   m_ref;
        TInt                   m_handle;
        NPPluginFuncs*         m_nppFuncs;
        HBufC*                 m_filename;

        TUid                   m_uid;
        CEcomBrowserPluginInterface* m_pluginInterface;

    private:  // Friend classes

        friend class PluginHandler;
    };

#endif      // PluginHandler_H

// End of File

