开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
plghand2.h
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：33k
源码类别：

Symbian

开发平台：

C/C++

plghand2.h：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #ifndef _PLGNHAND_H_
  37. #define _PLGNHAND_H_
  39. #include "hxslist.h"
  40. #include "hxplugn.h"
  41. #include "hxstring.h"
  42. #include "hxguidmap.h"
  43. #include "hxprefs.h"
  44. #include "hxengin.h"
  45. #include "hxcomm.h" 
  46. #include "hxerror.h"
  47. #include "hxphand.h"
  49. #include "dbindex.h"
  51. #include "unkimp.h"
  53. typedef HX_RESULT (HXEXPORT_PTR FPCREATEINSTANCE) (IUnknown** /*OUT*/ ppIUnknown);
  54. typedef HX_RESULT (HXEXPORT_PTR FPSHUTDOWN) ();
  55. typedef HX_RESULT (HXEXPORT_PTR FPCANUNLOAD2) ();
  57. typedef ULONG32     (STDMETHODCALLTYPE *FPWatchRef)(void*);
  58. typedef HX_RESULT   (STDMETHODCALLTYPE *FPQueryInterfaceWatch)(void*, REFIID riid,void** ppvObj);
  60. // This is the new and improved plugin handler. 
  61. // What is better in this version 
  62. //  (1) Unified Plugins No longer do you have to modify code in seven places when a bug 
  63. // appears. Simply modify the Plugin Class. It is the heart of the plugin Handler.
  64. //  (2) The plugin handler now has rudimentary ref counting of the DLLs which it loads.
  65. // This means that we cannot (almost) safely shutdown the player. Further, we can
  66. // ALMOST unload DLLs when they are not required anymore. 
  68. class Plugin2Handler;
  69. class DLLAccess;
  70. class CPluginEnumerator;
  71. class CPluginInfoWriter;
  73. // you want GUIDS? WE have GUIDS!
  74. DEFINE_GUID(IID_IHXPluginWatcherResponse, 0x00000C08, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  75. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  77. DECLARE_INTERFACE_(IHXPluginWatcherResponse, IUnknown)
  78. {
  79.     /*
  80.      *  IUnknown methods
  81.      */
  82.     STDMETHOD(QueryInterface) (THIS_
  83. REFIID riid,
  84. void** ppvObj) PURE;
  86.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  88.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  90.     /************************************************************************
  91.      * Method:
  92.      *     IHXPluginWatcherResponse::AllObjectsDeleted
  93.      * Purpose:
  94.      *     This function will be called all objects of the given class are
  95.      *     destroyed. 
  96.      */
  97.     STDMETHOD(AllObjectsDeleted) (THIS_ void*) PURE;
  98. };
  100. class Plugin2Handler : public CUnknownIMP,
  101. public IHXPluginEnumerator, 
  102. public IHXPluginReloader,
  103. public IHXPlugin2Handler,
  104. public IHXPlugin2HandlerEnumeratorInterface,
  105.      public IHXPluginHandler3,
  106.      public IHXPluginDatabase,
  107.      public IHXCallback
  108. {
  109.     // forward declarations?
  110.     // see note below   class PluginMonitor;     
  112.     class PreferenceEnumerator;
  113.     class PluginMountPoint;
  114.     class PluginDLL;
  115.     class Plugin;
  116.     class OtherDLL;
  117.     class PluginSupportingGUID;
  118.     
  119.     friend class CPluginEnumerator;
  120.     friend class PreferenceEnumerator;
  121.     friend class PluginDLL;
  122.     friend class Plugin;
  123.     friend class PluginSupportingGUID;
  124.     friend class OtherDLL;
  126. public:
  127.     enum    Errors
  128.     {
  129. NO_ERRORS = 0,
  130. PLUGIN_NOT_FOUND,
  131. MEMORY_ERROR,
  132. CANT_OPEN_DLL,
  133. BAD_DLL,
  134. CREATE_INSTANCHXR_FAILURE,
  135. CANT_DETERMINE_PLUGIN_DIR,
  136. CANT_OPEN_PLUGIN_DIR,
  137. BAD_PLUGIN,
  138. INVALID_CONTEXT,
  139. CANT_GET_FILE_FORMAT_INFO,
  140. CANT_GET_RENDERER_INFO,
  141. CANT_GET_FILE_SYSTEM_INFO,
  142. CANT_LOAD_INTERFACE,
  143. SHORT_NAME_NOT_FOUND,
  144. PLUGIN_ALREADY_HAS_MOUNT_POINT,
  145. INVALID_SHORT_NAME,
  146. BAD_REGISTRY_HANDLE,
  147. PLUGIN_DIR_NOT_SAME,
  148. REQUIRED_PLUGIN_NOT_LOADED,
  149. NO_HX_CREATE_INSTANCE,
  150. AGGREGATION_NOT_SUPPORTED
  151.     };
  153.     enum eValueTypes
  154.     {
  155. eString,
  156. eBuffer,
  157. eInt
  158.     };
  161.     DECLARE_UNKNOWN_NOCREATE( Plugin2Handler )
  162.     DECLARE_COM_CREATE_FUNCS( Plugin2Handler )
  164.     Plugin2Handler();
  165.     ~Plugin2Handler();
  167.     /*
  168.      * IHXCallback methods
  169.      */
  170.     STDMETHOD ( Func ) ( THIS );
  172.     /*
  173.      * IHXPluginEnumerator methods
  174.      */
  176.     /************************************************************************
  177.      * Method:
  178.      *     IHXPluginEnumerator::GetNumOfPlugins
  179.      *
  180.      * Purpose:    
  181.      *     return the number of plugins available
  182.      *
  183.      */
  184.     STDMETHOD_(ULONG32,GetNumOfPlugins) (THIS);
  186.     /************************************************************************
  187.      * Method:
  188.      *     IHXPluginEnumerator::GetPlugin
  189.      * Purpose:
  190.      *     return an instance(IUnknown) of the plugin
  191.      *
  192.      */
  193.     STDMETHOD(GetPlugin)   (THIS_
  194.     ULONG32     /*IN*/  ulIndex,
  195.     REF(IUnknown*)  /*OUT*/ pPlugin);
  197.     /*
  198.      * IHXPluginReloader methods
  199.      */
  201.     /************************************************************************
  202.      * Method:
  203.      *     IHXPluginReloader::ReloadPlugins
  204.      *
  205.      * Purpose:    
  206.      *     reloads plugins 
  207.      *
  208.      */
  209.     STDMETHOD(ReloadPlugins) (THIS);
  212.     /*
  213.      * IHXPlugin2Handler
  214.      */
  216.      /************************************************************************
  217.      * Method:
  218.      *     IHXPlugin2Handler::Init
  219.      *
  220.      * Purpose:    
  221.      *     Specifies the context and sets the Plugin2Handler in motion.
  222.      *
  223.      */
  224.     STDMETHOD(Init)    (THIS_ IUnknown* pContext);
  226.     /************************************************************************
  227.      * Method:
  228.      *     IHXPlugin2Handler::GetNumPlugins2
  229.      *
  230.      * Purpose:    
  231.      *     Gets the info of a particular plugin.
  232.      *
  233.      */
  234.     STDMETHOD_(ULONG32,GetNumOfPlugins2)    (THIS);
  235.     
  236.     /************************************************************************
  237.      * Method:
  238.      *     IHXPlugin2Handler::GetPluginInfo
  239.      *
  240.      * Purpose:    
  241.      *     Gets the info of a particular plugin.
  242.      *
  243.      */
  245.     STDMETHOD(GetPluginInfo) (THIS_ 
  246. UINT32 unIndex, 
  247. REF(IHXValues*) /*OUT*/ Values) ;
  249.     /************************************************************************
  250.      * Method:
  251.      *     IHXPlugin2Handler::FlushCache()
  252.      *
  253.      * Purpose:    
  254.      *     Flushes the LRU cache -- Unloads all DLLs from memory 
  255.      *     which currenltly have a refcount of 0.
  256.      */
  258.     STDMETHOD(FlushCache) (THIS);
  260.     /************************************************************************
  261.      * Method:
  262.      *     IHXPlugin2Handler::SetCacheSize
  263.      *
  264.      * Purpose:    
  265.      *     This function sets the size of the Cache. The cache is 
  266.      *     initally set to 1000KB. To disable the cache simply set
  267.      * the size to 0.If the cache is disabled a DLL will be 
  268.      *     unloaded whenever it's refcount becomes zero. Which MAY
  269.      * cause performance problems.
  270.      */
  272.     STDMETHOD(SetCacheSize) (THIS_ ULONG32 nSizeKB);
  274.     /************************************************************************
  275.      * Method:
  276.      *     IHXPlugin2Handler::ReadFromRegistry
  277.      *
  278.      * Purpose:    
  279.      *     Reload the DLL information from the registery. It will also 
  280.      *     Check to see if this information is valid, and if 
  281.      */
  282.     STDMETHOD(ReadFromRegistry)(THIS);
  284.     /************************************************************************
  285.      * Method:
  286.      *     IHXPlugin2Handler::GetInstance
  287.      *
  288.      * Purpose:    
  289.      *     
  290.      *     This function will return a plugin instance given a plugin index.
  291.      *
  292.      */
  293.     
  294.     STDMETHOD(GetInstance) (THIS_ UINT32 index, REF(IUnknown*) ppUnknown); 
  295.     
  296.     /************************************************************************
  297.      * Method:
  298.      *     IHXPlugin2Handler::FindReturnIndexUsingValues
  299.      *
  300.      * Purpose:    
  301.      *     Finds a plugin  which matches the set of values given. An index
  302.      *     is returned which can be used to either get the values (using 
  303.      *     GetPluginInfo) or an instance can be created using GetPluing(). 
  304.      * 
  305.      */
  307.     STDMETHOD(FindIndexUsingValues)     (THIS_ IHXValues*, 
  308.     REF(UINT32) unIndex);
  310.     /************************************************************************
  311.      * Method:
  312.      *     IHXPlugin2Handler::FindReturnPluginUsingValues
  313.      *
  314.      * Purpose:    
  315.      *     Finds a plugin  which matches the set of values given. A Plugin
  316.      *     instance is returned. 
  317.      *     
  318.      */
  320.     STDMETHOD(FindPluginUsingValues)     (THIS_ IHXValues*, 
  321.     REF(IUnknown*) pUnk);
  322.     
  323.     /************************************************************************
  324.      * Method:
  325.      *     IHXPlugin2Handler::FindReturnIndexUsingStrings
  326.      *
  327.      * Purpose:    
  328.      *     Finds a plugin  which matches the set of values given. An index
  329.      *     is returned which can be used to either get the values (using 
  330.      *     GetPluginInfo) or an instance can be created using GetPluing(). 
  331.      *     NOTE: that a max of two values may be given.
  332.      */
  333.     STDMETHOD(FindIndexUsingStrings)     (THIS_ char* PropName1, 
  334.     char* PropVal1, 
  335.     char* PropName2, 
  336.     char* PropVal2, 
  337.     char* PropName3, 
  338.     char* PropVal3, 
  339.     REF(UINT32) unIndex);
  341.     /************************************************************************
  342.      * Method:
  343.      *     IHXPlugin2Handler::FindReturnPluginUsingStrings
  344.      *
  345.      * Purpose:    
  346.      *     Finds a plugin  which matches the set of values given. A Plugin
  347.      *     instance is returned. 
  348.      *     NOTE: that a max of two values may be given.
  349.      */
  351.     STDMETHOD(FindPluginUsingStrings)     (THIS_ char* PropName1, 
  352.     char* PropVal1, 
  353.     char* PropName2, 
  354.     char* PropVal2, 
  355.     char* PropName3, 
  356.     char* PropVal3, 
  357.     REF(IUnknown*) pUnk);
  359.     /************************************************************************
  360.      * Method:
  361.      *     IHXPlugin2Handler::FindImplementationFromClassID
  362.      *
  363.      * Purpose:    
  364.      *     Finds a CommonClassFactory plugin which supports the 
  365.      *     ClassID given. An instance of the Class is returned. 
  366.      */
  368.     STDMETHOD(FindImplementationFromClassID)
  369.     (
  370. REFGUID GUIDClassID, 
  371. REF(IUnknown*) pIUnknownInstance
  372.     );
  374.     /************************************************************************
  375.      * Method:
  376.      *     IHXPlugin2Handler::Close
  377.      *
  378.      * Purpose:    
  379.      *     A function which performs all of the functions of delete.
  380.      *     
  381.      *
  382.      */
  383.     
  384.     STDMETHOD(Close) (THIS); 
  386.     /************************************************************************
  387.      * Method:
  388.      *     IHXPlugin2Handler::SetRequiredPlugins
  389.      *
  390.      * Purpose:    
  391.      *     This function sets the required plugin list
  392.      *     
  393.      *
  394.      */
  396.     STDMETHOD(SetRequiredPlugins) (THIS_ const char** ppszRequiredPlugins);
  398.     /************************************************************************
  399.      * Method:
  400.      *     IHXPlugin2HandlerEnumeratorInterface::GetNumPluginsSupporting
  401.      *
  402.      * Purpose:    Required for the plugin enumerator.
  403.      *     
  404.      *     
  405.      *
  406.      */
  408.     STDMETHOD(GetNumPluginsSupporting) (THIS_ REFIID iid, REF(UINT32) nNumPlugins);
  410.     /************************************************************************
  411.      * Method:
  412.      *     IHXPlugin2HandlerEnumeratorInterface::GetPluginIndexSupportingIID
  413.      *
  414.      * Purpose:    Required for the plugin enumerator.
  415.      *     
  416.      *     
  417.      *
  418.      */
  419.     STDMETHOD(GetPluginIndexSupportingIID) (THIS_ REFIID iid, UINT32 nPluginIndex, REF(UINT32) nIndexOut);
  421.     /************************************************************************
  422.      * Method:
  423.      *     IHXPlugin2HandlerEnumeratorInterface::AddSupportedIID
  424.      *
  425.      * Purpose:    Required for the plugin enumerator.
  426.      *     
  427.      *     
  428.      *
  429.      */
  430.     STDMETHOD(AddSupportedIID) (THIS_ REFIID iid);
  434.     /************************************************************************
  435.      * Method:
  436.      *     IHXPluginHandler3::RegisterContext
  437.      *
  438.      * Purpose:    
  439.      *     Sets up the context without loading any plugin info
  440.      *
  441.      */
  442.     STDMETHOD( RegisterContext )( THIS_ IUnknown* pContext );
  444.     /************************************************************************
  445.      * Method:
  446.      *     IHXPluginHandler3::AddPluginMountPoint
  447.      *
  448.      * Purpose:    
  449.      *
  450.      */
  451.     STDMETHOD( AddPluginMountPoint )( THIS_ const char* pName, UINT32 majorVersion,
  452.     UINT32 minorVersion, IHXBuffer* pPath );
  455.     /************************************************************************
  456.      * Method:
  457.      *     IHXPluginHandler3::RefreshPluginMountPoint
  458.      *
  459.      * Purpose:    
  460.      *
  461.      */
  462.     STDMETHOD( RefreshPluginMountPoint )( THIS_ const char* pName );
  465.     /************************************************************************
  466.      * Method:
  467.      *     IHXPluginHandler3::RemovePluginMountPoint
  468.      *
  469.      * Purpose:    
  470.      *
  471.      */
  472.     STDMETHOD( RemovePluginMountPoint )( THIS_ const char* pName );
  475.     /************************************************************************
  476.      * Method:
  477.      *     IHXPluginHandler3::FindImplementationFromClassID
  478.      *
  479.      * Purpose:    
  480.      *     Finds a CommonClassFactory plugin which supports the 
  481.      *     ClassID given. An instance of the Class is returned. 
  482.      *     The plugin instance is initialized with the specified 
  483.      *     context
  484.      */
  486.     STDMETHOD( FindImplementationFromClassID )( THIS_ REFGUID GUIDClassID, 
  487.     REF(IUnknown*) pIUnknownInstance, IUnknown* pIUnkOuter, IUnknown* pContext );
  489.     /************************************************************************
  490.      * Method:
  491.      *     IHXPluginHandler3::FindCLSIDFromName
  492.      *
  493.      * Purpose:    
  494.      *
  495.      *     Maps a text name to a CLSID based on information from 
  496.      *     component plugins
  497.      */
  498.     STDMETHOD( FindCLSIDFromName )( THIS_ const char* pName, REF(IHXBuffer*) pCLSID );
  501.     /************************************************************************
  502.      * Method:
  503.      *     IHXPluginHandler3::FindGroupOfPluginsUsingValues
  504.      *
  505.      * Purpose:    
  506.      *     Builds a collection of plugins that match the criteria
  507.      *
  508.      */
  509.     STDMETHOD(FindGroupOfPluginsUsingValues)(THIS_ IHXValues* pValues, 
  510.     REF(IHXPluginSearchEnumerator*) pIEnumerator);
  512.     /************************************************************************
  513.      * Method:
  514.      *     IHXPluginHandler3::FindGroupOfPluginsUsingStrings
  515.      *
  516.      * Purpose:    
  517.      *     Builds a collection of plugins that match the criteria
  518.      *
  519.      */
  520.     STDMETHOD(FindGroupOfPluginsUsingStrings)(THIS_ char* PropName1, 
  521.     char* PropVal1, 
  522.     char* PropName2, 
  523.     char* PropVal2, 
  524.     char* PropName3, 
  525.     char* PropVal3, 
  526.     REF(IHXPluginSearchEnumerator*) pIEnumerator);
  529.     /************************************************************************
  530.      * Method:
  531.      *     IHXPluginHandler3::GetPlugin
  532.      *
  533.      * Purpose:    
  534.      *     Allocates a plugin based on index.  Supports aggregation
  535.      *
  536.      */
  537.     STDMETHOD(GetPlugin)(THIS_ ULONG32 ulIndex,
  538.     REF(IUnknown*) pIUnkResult,
  539.     IUnknown* pIUnkOuter );
  541.     /************************************************************************
  542.      * Method:
  543.      *     IHXPluginHandler3::FindPluginUsingValues
  544.      *
  545.      * Purpose:    
  546.      *     Allocates a plugin based on criteria.  Supports aggregation
  547.      *
  548.      */
  549.     STDMETHOD(FindPluginUsingValues)(THIS_ IHXValues*, 
  550.     REF(IUnknown*) pIUnkResult, 
  551.     IUnknown* pIUnkOuter );
  554.     /************************************************************************
  555.      * Method:
  556.      *     IHXPluginHandler3::FindPluginUsingStrings
  557.      *
  558.      * Purpose:    
  559.      *     Allocates a plugin based on criteria.  Supports aggregation
  560.      *
  561.      */
  562.     STDMETHOD(FindPluginUsingStrings)(THIS_ char* PropName1, 
  563.     char* PropVal1, 
  564.     char* PropName2, 
  565.     char* PropVal2, 
  566.     char* PropName3, 
  567.     char* PropVal3, 
  568.     REF(IUnknown*) pIUnkResult, 
  569.     IUnknown* pIUnkOuter );
  571.     /************************************************************************
  572.      * Method:
  573.      *     IHXPluginHandler3::UnloadPluginFromClassID
  574.      *
  575.      * Purpose:    
  576.      *     Finds a plugin from the classID and unloads it if it supports CanUnload2
  577.  * and returns TRUE in response to query
  578.      */
  580.     STDMETHOD( UnloadPluginFromClassID )( THIS_ REFGUID GUIDClassID );
  582.     /************************************************************************
  583.      * Method:
  584.      *     IHXPluginHandler3::UnloadPackageByName
  585.      *
  586.      * Purpose:    
  587.      *     finds a package from the name passed in and attempts to unload it.
  588.      */
  589.     STDMETHOD (UnloadPackageByName) (const char* pName);
  592.     //------------------------------------ IHXPluginDatabase interface methods
  593.     STDMETHOD( AddPluginIndex ) ( THIS_ const char* pKeyName, EPluginIndexType indexType, BOOL bScanExisting );
  594.     STDMETHOD( RemovePluginIndex )( THIS_ const char* pKeyName );
  595.     STDMETHOD( FindPluginInfoViaIndex )( THIS_ const char* pKeyName, const void* pValue, IHXValues** ppIInfo );
  596.     STDMETHOD( FindPluginSetViaIndex )( THIS_ const char* pKeyName, const void* pValue, IHXPluginSearchEnumerator** ppIEnumerator );
  597.     STDMETHOD( CreatePluginViaIndex )( THIS_ const char* pKeyName, const void* pValue, IUnknown** ppIUnkPlugin, IUnknown* pIUnkOuter );
  600.     //------------------------------------ Class Methods
  602.     Errors     Stat(const char* pszFilename, struct stat* pStatBuffer);
  603.     IHXBuffer*     ChecksumFile(char* pszFileName, IHXBuffer* pPathBuffer);
  604.     IHXBuffer*     ConvertToAsciiString(char* pBuffer, UINT32 nBuffLen);
  606.     IHXBuffer*     GetPluginDir();
  607.     IHXPreferences*     GetPreferences();
  608.     CHXSimpleList&     GetCanUnload2DllList() { return( m_CanUnload2DllList ); }
  610.     HX_RESULT     FindGroupOfPluginsUsingStrings(char* PropName1, 
  611.     char* PropVal1, 
  612.     char* PropName2, 
  613.     char* PropVal2, 
  614.     char* PropName3, 
  615.     char* PropVal3, 
  616.     REF(CPluginEnumerator*) pEnumerator);
  618.     HX_RESULT     FindGroupOfPluginsUsingValues(IHXValues* pValues, 
  619.     REF(CPluginEnumerator*) pEnumerator);
  621.     void     ReportError( UINT8 severity, const char* pDLLName, const char* pDesc );
  623.     static const char* const zm_pszFileExtension;
  624.     static const char* const zm_pszDirectorySeperator;
  625.     static const char* const zm_pszValueSeperator;
  626.     static const char* const zm_pszListStart;
  627.     static const char* const zm_pszListEnd;
  628.     static const char* const zm_pszValueSeperator2;
  629.     static const char    zm_cDirectorySeperator;
  630.     static const char* const zm_pszKeyNameRegKey;
  631.     static const char* const zm_pszRegKeySeperator;
  632. #if !defined(HELIX_CONFIG_NOSTATICS)
  633.     static BOOL  zm_bFasterPrefs;
  634. #else
  635.     static const BOOL  zm_bFasterPrefs;
  636. #endif
  638.     HX_RESULT AddtoLRU(Plugin2Handler::PluginDLL* pDLL);
  639.     HX_RESULT RemoveFromLRU(Plugin2Handler::PluginDLL* pDLL);
  641.     HX_RESULT UpdateCache();
  642.     HX_RESULT ReloadPluginsNoPropagate();
  643.     HX_RESULT ReloadPluginsNoPropagate( PluginMountPoint* pMountPoint );
  645. private: 
  646.     static HX_RESULT VerifyChecksum_ (const char*);
  648.     void UnloadDeadDLLs(void);
  649.     IHXScheduler*  m_pIScheduler;
  650.     CallbackHandle  m_hScheduler;
  652.     enum
  653.     {
  654. // kPingDuration = 1000 // USE ONLY FOR TESTING
  655. kPingDuration = 60000 // 60000ms = 1 minute
  656.     };
  658.     IHXBuffer*     GetDefaultPluginDir();
  659.     void     WriteSupportedGUIDs();
  661.     HX_RESULT     ConnectPluginToDLL(Plugin2Handler::Plugin * pPlugin);
  662.     Errors     LoadDLL(char* pszDllName, PluginMountPoint* pMountPoint);
  663.     void     LoadPluginsFromComponentDLL( Plugin2Handler::PluginDLL* pPluginDll, 
  664. IHXComponentPlugin* pIIterator );
  666.     // Methods to determine out of data DLLs
  667.     BOOL     FindPlugin(const char* pFileName, UINT32 nDLLIndex, REF(UINT32) nIndex);
  668.     HX_RESULT     AddToValues(IHXValues*, char* pPropName, char* pPropVal, eValueTypes eValueType);
  669.     UINT32     GetNumSupportedGUIDs();
  670.     HX_RESULT     RemoveDLLFromGUIDSupportLists(const char* pszFileName);
  671.     HX_RESULT     GetGUIDForIndex(UINT32 nIndex, REF(CHXString) sGUID);
  672.     HX_RESULT     AddSupportForGUID(const char* pszGUID, PluginDLL* pDLL, UINT32 nIndexInDLL);
  674.     BOOL     GetPluginFileInfo( REF(char*) pszCurrentPos, 
  675.        REF(char*) pszName, 
  676.        REF(char*) pszCheckSum, 
  677.        REF(BOOL) bFactory, 
  678.        REF(int) nDLLSize, 
  679.        REF(int) nNumberPlugins);
  681.     BOOL     GetNameValuePair(REF(char*) pszCurrentPos, REF(char*) pszName, REF(char*) pszValue);
  682.     BOOL     GetPluginFileInfo(REF(char*) pszCurrentPos, REF(Plugin2Handler::Plugin*) pPlugin);
  683.     BOOL     GetNextSupportingFile(REF(char*) pszCurrentPos, REF(char*) pszFileName, REF(UINT32) index);
  684.     BOOL     GetGUIDInfo(REF(char*) pszCurrentPos, PluginMountPoint* pMountPoint, REF(char*) pszGUID, REF(CHXSimpleList*) pList);
  685.     void     ReconnectDLL(const char* pszDLLName, Plugin2Handler::PluginDLL* pNewDLL);
  686.     BOOL     GetNonHXInfo(REF(char*) pszCurrentPos, PluginMountPoint* pMountPoint, REF(Plugin2Handler::OtherDLL*) pOtherData);
  687.     void     WriteHugePref( IHXPreferences* pPrefs, const char* pszKeyName, IHXBuffer* pBigBuffer);
  688.     HX_RESULT     ReadHugePref( IHXPreferences* pPrefs, const char* pszKeyName, REF(IHXBuffer*) pBigBuffer);
  689.     void     DeleteHugePref_ (IHXPreferences*, IHXPreferences3*, const char*);
  691.     // Internal shared code
  692.     HX_RESULT      FindImplementationFromClassIDInternal( 
  693.     REFGUID GUIDClassID, 
  694.     REF(IUnknown*) pIUnknownInstance, 
  695.     IUnknown* pContext );
  698.     // New plugin info loading methods
  699.     HX_RESULT ClearMountPoint_ (PluginMountPoint*);
  701.     HX_RESULT RefreshPluginInfo( PluginMountPoint* pMountPoint );
  702.     HX_RESULT WritePluginInfo( PluginMountPoint* pMountPoint );
  704.     HX_RESULT ReadPluginInfoFast( PluginMountPoint* pMountPoint );
  705.     HX_RESULT WritePluginInfoFast( PluginMountPoint* pMountPoint );
  707.     HX_RESULT ReadPluginInfoSlow( PluginMountPoint* pMountPoint );
  708.     HX_RESULT WritePluginInfoSlow( PluginMountPoint* pMountPoint );
  710.     CPluginDatabaseIndex* FindDBIndex( const char* pKeyName );
  711.     void AddPluginToIndices( Plugin2Handler::Plugin* pPlugin );
  712.     void RemovePluginFromIndices( Plugin2Handler::Plugin* pPlugin );
  715.     CHXMapStringToOb     m_MountPoints;
  716.     CHXSimpleList     m_PluginDLLList;
  717.     CHXSimpleList     m_PluginList;
  718.     CHXSimpleList     m_MiscDLLList;
  719.     CHXSimpleList     m_CanUnload2DllList;
  720.     CHXMapStringToOb     m_GUIDtoSupportList;
  721.     CHXMapStringToOb     m_dbIndices;
  723.     CHXMapStringToOb     m_GUIDSupportListIsValid;
  724.     CHXMapStringToOb     m_FileNameMap;
  725.     
  726.     IHXBuffer*     m_pPluginDir;
  727.     IHXPreferences*     m_pPreferences;
  728.     IHXErrorMessages*     m_pErrorMessages;
  729.     IUnknown*     m_pContext;
  730.     INT32     m_nCacheSizeBites;
  731.     CHXSimpleList     m_DLL_LRUList;
  734.     class PluginMountPoint
  735.     {
  736.     public:
  737. PluginMountPoint( Plugin2Handler* pContext, const char* pName, 
  738.     UINT32 majorVersion, UINT32 minorVersion, 
  739.     IHXBuffer* pPath );
  740. ~PluginMountPoint();
  741.     
  742. STDMETHOD_(ULONG32,AddRef)( THIS );
  743. STDMETHOD_(ULONG32,Release)( THIS );
  744.     
  745. void AddClient();
  746. INT32 RemoveClient();
  748. // XXXND  This is for backward compatibility
  749. BOOL IsHXCompliant();
  751. IHXPreferences* Prefs();
  752. IHXBuffer* Path();
  753.     
  754.     private:
  755. INT32 m_lRefCount;
  756. INT32 m_lClientCount;
  757.     
  758. // XXXND  This is for backward compatibility
  759. BOOL m_bHXCompliant;
  761. IHXPreferences* m_pIPrefs;
  762. IHXBuffer* m_pIPath;
  763.     };
  766.     class PluginDLL : public IUnknown
  767.     {
  768.     public:
  769. PluginDLL(const char* pszFileName, PluginMountPoint* pMountPoint, 
  770.     Plugin2Handler* pPlugin2Handler);
  772. ~PluginDLL();
  774. /*
  775.  * IUnknown methods
  776.  */
  777. STDMETHOD(QueryInterface)(THIS_ REFIID riid, void** ppvObj);
  778. STDMETHOD_(ULONG32,AddRef) (THIS);
  779. STDMETHOD_(ULONG32,Release) (THIS);
  782. Errors Load(IUnknown* pContext);
  783. HX_RESULT Unload(BOOL safe = TRUE);
  784. BOOL IsLoaded();
  786. Errors CreateInstance( IUnknown** ppUnk, UINT32 uIndex );
  788. UINT32 AddDLLReference();
  789. UINT32 ReleaseDLLReference();
  791. void SetPref( int nNumberPlugins, char* pszCheckSum, int nDLLSize, BOOL bFactory );
  792. HX_RESULT WritePref2( REF(CPluginInfoWriter) piw);
  793. HX_RESULT WritePref( PreferenceEnumerator* pPrefEnum );
  794. HX_RESULT ReadPref( PreferenceEnumerator* pPrefs );
  796. // Accessors
  797. void SetHash(char* phash) {m_hash = phash;}
  798. void SetFileSize(INT32 nSize) {m_nSizeBites = nSize;}
  800. PluginMountPoint* GetMountPoint() { return m_pMountPoint; }
  801. IHXBuffer* GetFileName();
  802. INT32 GetFileSize() { return m_nSizeBites; }
  803. void SetNamespace(IHXBuffer* pNamespace);
  804. IHXBuffer* GetNamespace();
  805. const char* GetHash() { return (const char*) m_hash; }
  806. CHXString const& GetPackageName () const { return m_packageName; }
  808. UINT32 GetNumPlugins() { return m_NumOfPlugins; }
  810. BOOL DoesExist() { return m_bDoesExist; }
  812.     private:
  813. FPCREATEINSTANCE m_fpCreateInstance;
  814. FPSHUTDOWN m_fpShutdown;
  815. FPCANUNLOAD2 m_fCanUnload;
  817. PluginMountPoint* m_pMountPoint;
  818. IHXBuffer* m_pFileName;
  819. IHXBuffer* m_pNamespace;
  821. CHXString m_packageName;
  822. CHXString m_hash;
  823. LONG32 m_nSizeBites;
  824. INT32 m_lRefCount;
  825. UINT16 m_NumOfPlugins : 16;
  826. HX_BITFIELD m_bHas_factory : 1;
  827. HX_BITFIELD m_bLoaded : 1;
  828. BOOL m_bDoesExist;
  830. DLLAccess* m_pDLLAccess;
  831. UINT32 m_nActiveReferences; 
  832. Plugin2Handler* m_pPlugin2Handler;
  833.     };
  835.     class Plugin :  public IHXPluginWatcherResponse
  836.     {
  837. public:
  838. STDMETHOD(QueryInterface) (THIS_
  839. REFIID riid,
  840. void** ppvObj);
  842. STDMETHOD_(ULONG32,AddRef) (THIS);
  844. STDMETHOD_(ULONG32,Release) (THIS);
  845. STDMETHOD(AllObjectsDeleted) (THIS_ void*);
  848. Plugin(IUnknown* pContext);
  850. ~Plugin();  
  852. // Exposed to the Plugin2Handler
  853. BOOL     DoesMatch(IHXValues* pValues);
  854. HX_RESULT     WritePref2(REF(CPluginInfoWriter) piw);
  856. HX_RESULT     WritePref(PreferenceEnumerator* pPrefEnum);
  857. HX_RESULT     ReadPref(PreferenceEnumerator* pPrefs);
  859. Errors     GetValuesFromDLL(IHXPlugin* pHXPlugin);
  860. // Creates an instance of the top-level plugin object
  861. Errors     GetPlugin( REF(IUnknown*) ppUnknown );
  862. // Checks to see if this is a component plugin and does the appropriate indirection
  863. Errors     GetInstance(REF(IUnknown*) ppUnknown, IUnknown* pIUnkOuter = NULL );
  864. HX_RESULT     GetPluginInfo(REF(IHXValues*));
  865. IHXBuffer*     GetFileName();
  866. BOOL     IsLoaded();
  867. BOOL     DoesInfoNeedsRefresh() {return m_bInfoNeedsRefresh;}
  868. void     SetInfoNeedsRefresh(BOOL bRefresh) { m_bInfoNeedsRefresh = bRefresh;}
  869. void     SetDLL(PluginDLL * pPluginDll);
  870. PluginDLL*     GetDLL() {return m_pPluginDLL;}
  871. void     SetIndex(UINT16 nIndex);
  872. UINT16     GetIndex() {return m_nPluginIndex;}
  874. void     SetPropertyULONG32(char* , char*);
  875. void     SetPropertyCString(char*, char*);
  876. void     SetPropertyBuffer(char*, BYTE*, UINT32);
  878. // this causes an init plugins should be handled with care.
  879. HX_RESULT     GetBandwidthInfo();
  881. // FIX  This is to support the initialization of component plugins
  882. void InitializeComponentPlugin( IHXPlugin* pIPlugin, IHXValues* pIValues );
  884. // void* because the client doesn't have these
  885. // XXXAH not supported currently...  They were not in the old plugin handler either...
  886. // must be some code in the server that talks directly to this (BLEECH!)
  887. void*     m_process;  
  889.     private:
  890. LONG32     m_lRefCount;
  891. UINT16     m_nPluginIndex;
  892. PluginDLL*     m_pPluginDLL;
  893. IHXValues*     m_pValues;
  894. HX_BITFIELD     m_bCanUnload : 1;
  895. HX_BITFIELD     m_bInfoNeedsRefresh : 1;
  896. IUnknown*     m_pContext;
  899. // Methods to retreive from the DLL
  900. Errors     GetBasicValues(IHXPlugin* pHXPlugin);
  901. Errors     GetExtendedValues(IHXPlugin* pHXPlugin);
  903. // Support Functions
  904. HX_RESULT   CatStrings(     char** pInStrings, 
  905.     REF(IHXBuffer*) pOutBuffer);
  906. HX_RESULT   CatPropertiesULONG32(   REF(IHXBuffer*) pBuffer, 
  907.     const char* pPropName, 
  908.     ULONG32 nValue);
  909. HX_RESULT   CatPropertiesCString(   REF(IHXBuffer*) pBuffer, 
  910.     const char* pPropName, 
  911.     IHXBuffer* pValue);
  912. BOOL     GetNextValueFromString( REF(char*) pszValues, 
  913.     REF(UINT32) nType, 
  914.     REF(IHXBuffer*) pValueNameBuffer, 
  915.     REF(IHXBuffer*) pValueBuffer, 
  916.     REF(ULONG32) nValue);
  917. BOOL     AreBufferEqual(     IHXBuffer* pBigBuff, 
  918.     IHXBuffer* pSmallBuff);
  919. Errors     CreateWatcher(IUnknown* pUnknown);
  920.     };
  922.     class PluginSupportingGUID
  923.     {
  924.     public:
  925.     CHXString m_filename;
  926.     UINT32 m_nIndexInDLL;
  927.     PluginMountPoint* m_pMountPoint;
  928.     };
  930.     class OtherDLL 
  931.     {
  932.     public:
  933.     CHXString m_filename;
  934.     CHXString m_fileChecksum;
  935.     PluginMountPoint* m_pMountPoint;
  936.     };
  938.     class PreferenceEnumerator
  939.     {
  940. public:
  941.     HX_RESULT     BeginSubPref(const char* pszSubPref);
  942.     HX_RESULT     EndSubPref();
  943.     HX_RESULT     WriteSubPref(const char* pszSubName, IHXBuffer* pBuffer);
  944.     HX_RESULT     ReadPref(const char* pszSubName, REF(IHXBuffer*) /*OUT*/ pBuffer);
  945.     HX_RESULT     GetPrefKey(UINT32 nIndex, IHXBuffer*& pBuffer);
  946.     HX_RESULT     ResetPropNameList();
  948.     PreferenceEnumerator(IHXPreferences* pIHXPref);
  949.     ~PreferenceEnumerator();
  952. private:
  954.     CHXString m_RegKey;
  955.     CHXSimpleList m_ListofProps;
  956.     IHXPreferenceEnumerator* m_pPrefEnum;
  957.     IHXPreferences* m_pPreferences;
  958.     };
  959. };
  962. class CPluginEnumerator :
  963.     public CUnknownIMP,
  964.     public IHXPluginSearchEnumerator
  965. {
  966. public: 
  967.     CPluginEnumerator();
  968.     virtual ~CPluginEnumerator();
  970.     DECLARE_UNKNOWN_NOCREATE( CPluginEnumerator )
  972.     /*
  973.      * IHXPluginSearchEnumerator
  974.      */
  975.     STDMETHOD_(UINT32, GetNumPlugins)(THIS);
  977.     STDMETHOD_(void, GoHead)(THIS);
  978.     STDMETHOD(GetNextPlugin)( THIS_ REF(IUnknown*) pIUnkResult, 
  979.     IUnknown* pIUnkOuter );
  981.     STDMETHOD(GetNextPluginInfo)( THIS_ REF(IHXValues*) pRetValues );
  982.     
  984.     STDMETHOD(GetPluginAt)( THIS_ UINT32 index, 
  985.     REF(IUnknown*) pIUnkResult, 
  986.     IUnknown* pIUnkOuter );
  988.     STDMETHOD(GetPluginInfoAt)( THIS_ UINT32 index, 
  989.     REF(IHXValues*) pRetValues );
  991.     //---------------- Class methods
  992.     void Add(Plugin2Handler::Plugin* pPlugin);
  994.     // FIX This is for backwards compatibility, and should be removed
  995.     HX_RESULT GetNext(REF(IUnknown*) pRetUnk);
  997. protected:
  999. private:
  1000.     CHXSimpleList   m_ListOfPlugins;
  1001.     UINT32     m_nIndex;
  1003. };
  1005. // Helper class used to write plugin info to registry...
  1006. class CPluginInfoWriter
  1007. {
  1008. public:
  1009.     CPluginInfoWriter();
  1010.     ~CPluginInfoWriter();
  1011.     HX_RESULT Init(IHXPreferences* pPrefs, const char* pBaseKeyName, IHXBuffer* pIHXBuffer);
  1012.     HX_RESULT Write(IHXBuffer *pBuffer);
  1013.     HX_RESULT Write(const char *pInfo);
  1014.     HX_RESULT Write(const char *pInfo, UINT32 len);
  1015.     HX_RESULT Flush();
  1017. private:
  1018.     void TerminateBuffer();
  1019.     void WriteToRegistry();
  1020.     static BOOL IsAscii7Compliant (const char*, const UINT32 len);
  1022.     IHXBuffer* m_pIHXBuffer; // Contains a pointer to internal buffer
  1023.     IHXPreferences* m_pIHXPreferences; // Used to write to registry
  1024.     UINT32 m_NumWrites;  // Keeps track of how many times we have written to registry during lifetime of class
  1025.     UINT32 m_BufUsed;    // Keeps track of how much we have written to internal buffer between writes to registry
  1026.     UINT32 m_BufSize;    // Size of internal buffer; Used to determine when to write info to registry
  1027.     UINT32 m_Checksum;  // Total size of the data written to the registry across the lifetime of the object.
  1029.     CHXString m_BaseKeyName; // Combined with m_NumWrite to generate the name of the registry key to which we write
  1030. };
  1032. #endif /* _PLGNHAND_H_ */