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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
hxpluginmanager.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：32k
源码类别：

Symbian

开发平台：

Visual C++

hxpluginmanager.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: hxpluginmanager.cpp,v 1.2.2.2 2004/07/09 02:07:27 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #include "hxtypes.h"
  51. #include "hxassert.h"
  52. #include "debug.h"
  53. #include "hxcom.h"
  54. #include "hxccf.h"      // IHXCommonClassFactory
  55. #include "ihxpckts.h"   // IHXBuffer
  56. #include "hxplugn.h"    // IHXComponentPlugin
  57. #include "hxprefs.h" // IHXPreferences
  58. #include "hxprefutil.h"
  59. #include "findfile.h"
  60. #include "chxpckts.h"   // CHXHeader
  61. #include "dllacces.h"
  62. #include "dllpath.h"
  63. #include "pathutil.h"
  64. #include "hxver.h"
  66. #include "hxheap.h"
  67. #ifdef _DEBUG
  68. #undef HX_THIS_FILE
  69. static const char HX_THIS_FILE[] = __FILE__;
  70. #endif
  72. #if defined(_STATICALLY_LINKED)
  73. #include "staticff.h"
  74. #endif
  76. #include "hxpluginarchive.h"
  77. #include "hxplugindll.h"
  78. #include "hxplugin.h"
  79. #include "hxpluginmanager.h"
  82. #if(0)
  83. // helper
  84. static bool IsRealNetworksPlugin(HXPlugin* pPlugin)
  85. {
  86.     bool isRNPlugin = false;
  88.     HX_ASSERT(pPlugin);
  89.     IHXValues* pval = 0;
  90.     if (SUCCEEDED(pPlugin->GetPluginInfo(pval)))
  91.     {
  92.         IHXBuffer* pbuff = 0;
  93. if (SUCCEEDED(pval->GetPropertyCString(PLUGIN_DESCRIPTION2, pbuff)))
  94. {
  95.     isRNPlugin =  (0 != strstr((const char*)pbuff->GetBuffer(), "RealNetworks"));
  96.             HX_RELEASE(pbuff);
  97.         }
  98.         HX_RELEASE(pval);
  99.     }
  101.     return isRNPlugin;
  102. }
  103. #endif
  106. IMPLEMENT_COM_CREATE_FUNCS( HXPluginManager )
  108. BEGIN_INTERFACE_LIST_NOCREATE( HXPluginManager )
  109.     INTERFACE_LIST_ENTRY_SIMPLE( IHXPluginEnumerator )
  110.     INTERFACE_LIST_ENTRY_SIMPLE( IHXPlugin2Handler )
  111.     INTERFACE_LIST_ENTRY_SIMPLE( IHXPluginHandler3 )
  112. END_INTERFACE_LIST
  114. HXPluginManager::HXPluginManager() 
  115. : m_pContext(0)
  116. , m_pClassFactory(0)
  117. {
  118. }
  120. HXPluginManager::~HXPluginManager()
  121. {
  122.     Close();
  123. }
  125. STDMETHODIMP HXPluginManager::Init(IUnknown* pContext)
  126. {
  127.     DPRINTF(D_INFO, ("HXPluginManager::Init()n"));
  128.     HX_RESULT result = HXR_FAIL;
  130.     if( SUCCEEDED( result = RegisterContext( pContext ) ) )
  131.     {
  132. result = ReadFromRegistry();
  133.     }
  135.     return result;
  136. }
  139. STDMETHODIMP_(ULONG32) HXPluginManager::GetNumOfPlugins2()
  140. {
  141.     return m_plugins.GetCount();
  142. }
  145. STDMETHODIMP
  146. HXPluginManager::GetPluginInfo(UINT32 unIndex, REF(IHXValues*) /*OUT*/ pValues)
  147. {
  148.     return HXR_NOTIMPL;
  149. }
  151. ///////////////////////////////////////////////////////////////////////////////
  152. //
  153. HX_RESULT HXPluginManager::ReloadPluginsNoPropagate()
  154. {
  155.     return ReloadPlugins();
  156. }
  158. ///////////////////////////////////////////////////////////////////////////////
  159. //
  160. HX_RESULT HXPluginManager::ReloadPlugins()
  161. {
  162.     DPRINTF(D_INFO, ("HXPluginManager()::ReloadPlugins()n"));
  164.     HX_RESULT result = HXR_OK;
  166.     // reload plugins for all mountpoints
  167.     for(CHXMapStringToString::Iterator iter = m_mountPoints.Begin(); iter != m_mountPoints.End(); ++iter)
  168.     {
  169. const char* pMountPoint = (const char*) *iter;
  170. if( FAILED( ReloadPlugins( pMountPoint ) ) )
  171. {
  172.     result = HXR_FAIL;
  173. }
  174.     }
  176.     return result;
  177. }
  179. /////////////////////////////////
  180. //
  181. // do we already have the given dll in our collection?
  182. //
  183. // we use case insensitive match in all OS/filesystem cases (even if technically inappropriate)
  184. //
  185. bool HXPluginManager::DoesDLLExist(const char* pszName, const char* pszMountPoint)
  186. {
  187.     CHXSimpleList::Iterator iter;
  188.     for(iter = m_pluginDlls.Begin(); iter != m_pluginDlls.End(); ++iter)
  189.     {
  190. HXPluginDLL* pLib = (HXPluginDLL*) *iter;
  192.         if( !pLib->GetFileName().CompareNoCase(pszName) && !pLib->GetMountPoint().CompareNoCase(pszMountPoint) )
  193.         {
  194.             DPRINTF(D_INFO, ("HXPluginManager::DoesDLLExist(): plugin dll exists '%s'n", (const char*)pLib->GetFileName()));
  195.             return true;
  196.         }
  197.     }
  199.     for(iter = m_otherDlls.Begin(); iter != m_otherDlls.End(); ++iter)
  200.     {
  201. HXOtherDLL* pLib = (HXOtherDLL*) *iter;
  202.         if( !pLib->GetFileName().CompareNoCase(pszName) && !pLib->GetMountPoint().CompareNoCase(pszMountPoint) )
  203.         {
  204.             DPRINTF(D_INFO, ("HXPluginManager::DoesDLLExist(): other dll exists '%s'n", (const char*)pLib->GetFileName()));
  205.             return true;
  206.         }
  207.     }
  208.     return false;
  209. }
  211. HX_RESULT HXPluginManager::SaveToArchive(const char* pszArchiveFile)
  212. {
  213.     DPRINTF(D_INFO, ("SaveToArchive(): writing '%s' (%d plugin dlls; %d other dlls)n", pszArchiveFile, m_pluginDlls.GetCount(), m_otherDlls.GetCount()));
  214.     HXPluginArchiveWriter ar;
  215.     HX_RESULT hr = ar.Open(m_pContext, pszArchiveFile);
  216.     if(SUCCEEDED(hr))
  217.     {
  218.         CHXSimpleList::Iterator iter;
  219.         for(iter = m_pluginDlls.Begin(); iter != m_pluginDlls.End(); ++iter)
  220.         {
  221.             HXPluginDLL* pLib = (HXPluginDLL*) *iter;
  222.             pLib->Archive(ar);
  223.         }
  224.         for(iter = m_otherDlls.Begin(); iter != m_otherDlls.End(); ++iter)
  225.         {
  226.             HXOtherDLL* pLib = (HXOtherDLL*) *iter;
  227.             pLib->Archive(ar);
  228.         }
  229.     }
  230.     ar.Close();
  231.     return hr;
  232. }
  234. HX_RESULT HXPluginManager::LoadPluginDLLFromArchive(const char* pszMountPoint, HXPluginArchiveReader& ar)
  235. {
  236.     HXPluginDLL* pPluginDLL = new HXPluginDLL(m_pContext, pszMountPoint, ar);
  237.     if( !pPluginDLL )
  238.     {
  239.         return HXR_OUTOFMEMORY;
  240.     }
  241.     pPluginDLL->AddRef();
  243.     HX_ASSERT(!DoesDLLExist(pPluginDLL->GetFileName(), pPluginDLL->GetMountPoint()));
  245.     // no need to load! that's the point of the archive
  246.     HX_ASSERT(pPluginDLL->GetNumPlugins() > 0);
  248.     m_pluginDlls.AddTail(pPluginDLL);
  250.     return HXR_OK;
  251. }
  253. HX_RESULT HXPluginManager::LoadOtherDLLFromArchive(const char* pszMountPoint, HXPluginArchiveReader& ar)
  254. {
  255.     HXOtherDLL* pOtherDLL = new HXOtherDLL(pszMountPoint, ar);
  256.     if( !pOtherDLL )
  257.     {
  258.         return HXR_OUTOFMEMORY;
  259.     }
  261.     pOtherDLL->AddRef();
  262.     HX_ASSERT(!DoesDLLExist(pOtherDLL->GetFileName(), pOtherDLL->GetMountPoint()));
  263.     m_otherDlls.AddTail(pOtherDLL);
  265.     return HXR_OK;
  266. }
  268. //
  269. // Try to re-construct plugin dll and associated plugin objects
  270. // from saved archive for faster plugin discovery
  271. //
  272. // If you want to override this (i.e., after new dlls installed), delete the archive
  273. //
  274. HX_RESULT HXPluginManager::LoadFromArchive(const char* pszArchiveFile, const char* pszMountPoint)
  275. {
  276.     DPRINTF(D_INFO, ("LoadFromArchive(): looking for '%s'n", pszArchiveFile));
  277.     HXPluginArchiveReader ar;
  278.     HX_RESULT hr = ar.Open(m_pContext, pszArchiveFile);
  279.     if(SUCCEEDED(hr))
  280.     {
  281.         while(SUCCEEDED(hr) && !ar.AtEnd())
  282.         {
  283.             UINT32 type;
  284.             ar.Read(type);
  285.             switch(type)
  286.             {
  287.             case ARCHIVE_ID_PLUGIN_DLL:
  288.                 hr = LoadPluginDLLFromArchive(pszMountPoint,ar);
  289.                 break;
  290.             case ARCHIVE_ID_OTHER_DLL:
  291.                 hr = LoadOtherDLLFromArchive(pszMountPoint, ar);
  292.                 break;
  293.             default:
  294.                 hr = HXR_FAIL;
  295.                 break;
  296.             }
  297.         }
  298.     
  299.         ar.Close();
  301.         DPRINTF(D_INFO, ("LoadFromArchive(): found %ld plugin dlls, %ld other dllsn", m_pluginDlls.GetCount(), m_otherDlls.GetCount()));
  302.     }
  303.     else
  304.     {
  305.         DPRINTF(D_INFO, ("LoadFromArchive(): archive missingn"));
  306.     }
  308.     return hr;
  309. }
  311. ///////////////////////////////////////////////////////////////////////////////
  312. //
  313. // 'query plugin dlls'
  314. //
  315. // load all plugin dlls and determine associated plugin attributes
  316. //
  317. // called when:
  318. //
  319. //   1) a mount point is added
  320. //   2) a mount point is removed and re-added (e.g., dynamic re-load)
  321. //
  322. // does nothing if dlls for mount point have already been loaded and queried
  323. //
  324. HX_RESULT HXPluginManager::ReloadPluginsWithFindFile(
  325.                const char* pMountPoint, CFindFile* pFileFinder,
  326.                IHXBuffer* pPathBuffer, const char* pszPluginDir)
  327. {
  328.     DPRINTF(D_INFO, ("HXPluginManager()::ReloadPluginsWithFindFile()n"));
  329.   
  330.     CHXString strArchiveFile;
  331.     IHXPreferences* pPrefs = 0;
  332.     m_pContext->QueryInterface(IID_IHXPreferences, (void**) &pPrefs);
  333.     HX_RESULT hr = ReadPrefCSTRING(pPrefs, "PluginArchiveFileName", strArchiveFile);
  334.     HX_RELEASE(pPrefs);
  335.     if(SUCCEEDED(hr))
  336.     {
  337.         // first try to recreate dll and plugin state from archive
  338.         hr = LoadFromArchive(strArchiveFile, pMountPoint); 
  339.     }
  340.     if(HXR_OUTOFMEMORY == hr)
  341.     {
  342.         return hr;
  343.     }
  344.     
  345.     // iterate files in this plugin directory
  346.     hr = HXR_OK;
  347.     bool bWriteArchive = false;
  348.     const char* pszDllName = pFileFinder->FindFirst();
  349.     for (; pszDllName; pszDllName = pFileFinder->FindNext())
  350.     {
  351.         if( DoesDLLExist(pszDllName, pMountPoint) )
  352.         {
  353.             // we already have info about this dll (perhaps from achive)
  354.             continue;
  355.         }
  357.         // since we found a dll we don't know about yet we need to update the archive
  358.         bWriteArchive = true;
  360.         // create plugin dll wrapper, assuming this is a plugin dll
  361.         HXPluginDLL* pPluginDll  = new HXPluginDLL(m_pContext, pszDllName, pMountPoint);
  362.         if(!pPluginDll)
  363.         {
  364.             // oom
  365.     hr = HXR_OUTOFMEMORY;
  366.             break;
  367.         }
  368.         pPluginDll->AddRef();
  370.         // load dll to force query of supported plugins
  371.         hr = pPluginDll->Load();
  372.         if (SUCCEEDED(hr))
  373.         {
  374.             // add successfully loaded dll to list
  375.             pPluginDll->AddRef();
  376.             m_pluginDlls.AddTail(pPluginDll);
  378.             // Unload the dll. The dll was loaded only to query supported plugin 
  379.             // info. It will be re-loaded only when actually needed, i.e., when
  380.             // an instance of a plugin that it implements is requested.
  381.             pPluginDll->Unload();
  382.         }
  383.         HX_RELEASE(pPluginDll);
  384.         if (FAILED(hr))
  385.         {
  386.             if(HXR_OUTOFMEMORY == hr)
  387.             {
  388.                 break;
  389.             }
  391.             // lib load attempt failed; add this to 'other' dll list (maybe it is a codec dll, e.g.)
  392.             HXOtherDLL* pOtherDll  = new HXOtherDLL(pszDllName, pMountPoint);
  393.             if( !pOtherDll)
  394.             {
  395.                 //oom
  396.                 hr = HXR_OUTOFMEMORY;
  397.                 break;
  398.             }
  399.             pOtherDll->AddRef();
  400.             m_otherDlls.AddTail(pOtherDll);
  401.             bWriteArchive = true;
  402.         }
  403.     }
  405.     RebuildPluginList();
  407.     // write archive now if it needs updating
  408.     if(bWriteArchive)
  409.     {
  410.         SaveToArchive(strArchiveFile);
  411.     }
  413.     return hr;
  414. }
  416. ///////////////////////////////////////////////////////////////////////////////
  417. //
  418. HX_RESULT HXPluginManager::ReloadPlugins( const char* pMountPoint )
  419. {
  420.     CFindFile* pFileFinder = NULL;
  421.     IHXBuffer* pPathBuffer = NULL;
  423.     HX_RESULT hr = HXR_FAIL;
  425.     HX_ASSERT(m_pContext);
  426.     if (m_pContext)
  427.     {
  428. #if defined(_STATICALLY_LINKED) && !defined(HELIX_CONFIG_CONSOLIDATED_CORE)
  429.         const char* const pszPluginDir = "";
  430.         pFileFinder = CStaticFindFile::CreateFindFile(pszPluginDir,0, OS_DLL_PATTERN_STRING);
  431. #else
  432.         const char* const pszPluginDir = pMountPoint;
  433.         pFileFinder = CFindFile::CreateFindFile(pszPluginDir, 0, OS_DLL_PATTERN_STRING);
  434. #endif
  435.         
  436.         if (pFileFinder)
  437.         {
  438.             hr = ReloadPluginsWithFindFile(pMountPoint, pFileFinder, pPathBuffer, pszPluginDir);
  439.             HX_DELETE(pFileFinder);
  440.         }
  441.     }
  443.     return hr;
  444. }
  446. STDMETHODIMP HXPluginManager::FindIndexUsingValues(IHXValues* pValues,REF(UINT32) unIndex)
  447. {
  448.     return HXR_NOTIMPL;
  449. }
  451. STDMETHODIMP HXPluginManager::GetInstance (UINT32 index, REF(IUnknown*) pUnknown)
  452. {
  453.     pUnknown = NULL;
  454.     LISTPOSITION pPos = m_plugins.FindIndex(index);
  455.     if (pPos)
  456.     {
  457. HXPlugin* pPlugin = (HXPlugin*) m_plugins.GetAt(pPos);
  458. if (pPlugin)
  459. {
  460.     return pPlugin->GetInstance(pUnknown);
  461. }
  462.     }
  463.     return HXR_FAIL;
  464. }
  466. STDMETHODIMP HXPluginManager::FindIndexUsingStrings (char* PropName1,
  467.     char* PropVal1,
  468.     char* PropName2,
  469.     char* PropVal2,
  470.     char* PropName3,
  471.     char* PropVal3,
  472.     REF(UINT32) unIndex)
  473. {
  474.     return HXR_NOTIMPL;
  475. }
  478. STDMETHODIMP HXPluginManager::FindPluginUsingValues(IHXValues* pValues,REF(IUnknown*) pUnk)
  479. {
  480.     return FindPluginUsingValues( pValues, pUnk, NULL );
  481. }
  483. HX_RESULT HXPluginManager::FindGroupOfPluginsUsingStrings(char* PropName1,
  484.     char* PropVal1,
  485.     char* PropName2,
  486.     char* PropVal2,
  487.     char* PropName3,
  488.     char* PropVal3,
  489.     REF(HXPluginEnumerator*) pEnumerator)
  490. {
  491.     DPRINTF(D_INFO, ("HXPluginManager()::FindGroupOfPluginsUsingStrings(): '%s' = '%s', etc.n", PropName1, PropVal1));
  493.     // PropName and PropVal have to to valid tuple
  494.     if ((PropName1 && !PropVal1)    ||
  495. (PropName2 && !PropVal2)    ||
  496. (PropName3 && !PropVal3)    ||
  497. (!PropName1 && PropVal1)    ||
  498. (!PropName2 && PropVal2)    ||
  499. (!PropName3 && PropVal3))
  500. return HXR_FAIL;
  502.     IHXValues* pValues;
  503.     HX_RESULT   retVal = HXR_FAIL;
  505.     CHXHeader* pHeader = new CHXHeader;
  506.     pHeader->QueryInterface(IID_IHXValues,  (void**)&pValues);
  507.     AddToValues(pValues, PropName1, PropVal1, eString);
  508.     AddToValues(pValues, PropName2, PropVal2, eString);
  509.     AddToValues(pValues, PropName3, PropVal3, eString);
  510.     retVal = FindGroupOfPluginsUsingValues(pValues, pEnumerator);
  511.     pValues->Release();
  512.     return retVal;
  513. }
  515. HX_RESULT HXPluginManager::FindGroupOfPluginsUsingValues(IHXValues* pValues,
  516. REF(HXPluginEnumerator*) pEnumerator)
  517. {
  518.     
  519.     HX_RESULT hr = HXR_FAIL;
  520.     pEnumerator = NULL;
  522.     for(CHXSimpleList::Iterator iter = m_plugins.Begin();
  523.         iter != m_plugins.End(); ++iter)
  524.     {
  525. HXPlugin* pPlugin = (HXPlugin*) *iter;
  527. if (pPlugin->DoesMatch(pValues))
  528. {
  529.     if (!pEnumerator)
  530.     {
  531. pEnumerator = new HXPluginEnumerator();
  532.                 if(pEnumerator)
  533.                 {
  534.                     hr = HXR_OK;
  535.                 }
  536.                 else
  537.                 {
  538.                     hr = HXR_OUTOFMEMORY;
  539.                     break;
  540.                 }
  541.     }
  542.     
  543.             pEnumerator->Add(pPlugin); 
  544.         }
  545.     }
  547.     return hr;
  548. }
  551. // IHXPluginHandler3
  552. STDMETHODIMP
  553. HXPluginManager::RegisterContext( IUnknown* pContext )
  554. {
  555.     HX_ASSERT(pContext);
  556.     if( !pContext )
  557.     {
  558. return HXR_INVALID_PARAMETER;
  559.     }
  561.     if( m_pContext )
  562.     {
  563. return HXR_UNEXPECTED;
  564.     }
  566.     m_pContext = pContext;
  567.     m_pContext->AddRef();
  569.     m_pContext->QueryInterface(IID_IHXCommonClassFactory, (void**)&m_pClassFactory);
  571.     return HXR_OK;
  572. }
  574. // IHXPluginHandler3
  575. STDMETHODIMP
  576. HXPluginManager::AddPluginMountPoint( const char* pName, UINT32 majorVersion, UINT32 minorVersion, IHXBuffer* pPath )
  577. {
  578.     DPRINTF(D_INFO, ("HXPluginManager()::AddPluginMountPoint(): name = '%s'n", pName));
  580.     const char* pMPKey = pName ? pName : (const char*) pPath->GetBuffer();
  582.     // Make sure this mount point is in the list
  583.     CHXString strMountPoint;
  584.     if( !m_mountPoints.Lookup(pMPKey, strMountPoint) && pPath )
  585.     {
  586.         strMountPoint = (const char*)pPath->GetBuffer();
  587.         
  588.         // Put new mount point in list
  589.         m_mountPoints.SetAt( pMPKey, strMountPoint );
  590.     }
  592.     // Load information from registry, and sync DLLs that aren't up to date
  593.     return ReloadPlugins( strMountPoint );
  594. }
  596. // IHXPluginHandler3
  597. STDMETHODIMP
  598. HXPluginManager::RefreshPluginMountPoint( const char* pName )
  599. {
  600.     HX_RESULT result = HXR_FAIL;
  602.     CHXString strMountPoint;
  603.     if( m_mountPoints.Lookup( pName, strMountPoint ) )
  604.     {
  605. result = ReloadPlugins( strMountPoint );
  606.     }
  608.     return result;
  609. }
  611. // IHXPluginHandler3
  612. STDMETHODIMP
  613. HXPluginManager::RemovePluginMountPoint( const char* pName )
  614. {
  615.     HX_RESULT hr = HXR_FAIL;
  617.     CHXString strMountPoint;
  618.     if( m_mountPoints.Lookup( pName, strMountPoint ) )
  619.     {
  620. // Clean up plugin dlls associated with mountpoint
  621. LISTPOSITION listPos = m_pluginDlls.GetHeadPosition();
  622. while( listPos )
  623. {
  624.     LISTPOSITION curPos = listPos;
  625.     HXPluginDLL* pLibrary = (HXPluginDLL*) m_pluginDlls.GetNext( listPos );
  626.     if( pLibrary && ( pLibrary->GetMountPoint() == strMountPoint ) )
  627.     {
  628. m_pluginDlls.RemoveAt( curPos ); 
  629.                 pLibrary->Unload(); // just in case; this should be last ref
  630. HX_RELEASE( pLibrary );
  631.     }
  632. }
  634.         
  635.         // Clean up 'other' dlls associated with mountpoint
  636.         listPos = m_otherDlls.GetHeadPosition();
  637. while( listPos )
  638. {
  639.     LISTPOSITION curPos = listPos;
  640.     HXOtherDLL* pLibrary = (HXOtherDLL*) m_otherDlls.GetNext( listPos );
  641.     if( pLibrary && ( pLibrary->GetMountPoint() == strMountPoint ) )
  642.     {
  643. m_otherDlls.RemoveAt( curPos ); 
  644. HX_RELEASE( pLibrary );
  645.     }
  646. }
  647.        
  648. m_mountPoints.RemoveKey( pName );
  650.         // Plugin list must be rebuilt
  651.         RebuildPluginList();
  653.         hr = HXR_OK;
  655.     }
  657.     return hr;
  658. }
  660. //
  661. // called every time dll list has been altered (we could be more efficient in many cases)
  662. //
  663. void HXPluginManager::RebuildPluginList()
  664. {
  665.     DPRINTF(D_INFO, ("HXPluginManager()::RebuildPluginList()n"));
  667.     CHXSimpleList::Iterator iter;
  668.         
  669.     // clean up (now invalid) plugin list
  670.     for(iter = m_plugins.Begin(); iter != m_plugins.End(); ++iter)
  671.     {
  672. HXPlugin* pPlugin = (HXPlugin*) *iter;
  673. pPlugin->Release();
  674.     }
  675.     m_plugins.RemoveAll();
  677.     // rebuild list of plugins we can instanciate
  678.     for(iter = m_pluginDlls.Begin(); iter != m_pluginDlls.End(); ++iter)
  679.     {
  680. HXPluginDLL* pLibrary = (HXPluginDLL*) *iter;
  681.         pLibrary->AddPlugins(m_plugins);
  682.     }
  683. }
  686. STDMETHODIMP
  687. HXPluginManager::FindImplementationFromClassID( REFGUID GUIDClassID, REF(IUnknown*) pIUnknownInstance,
  688.     IUnknown* pIUnkOuter, IUnknown* pContext )
  689. {
  690.     DPRINTF(D_INFO, ("HXPluginManager()::FindImplementationFromClassID()n"));
  691.     HX_RESULT     rc = HXR_OK;
  692.     IUnknown*     pUnknown = NULL;
  693.     IHXPlugin*     pPlugin = NULL;
  694.     IHXCommonClassFactory*     pFactory = NULL;
  695.     IHXPluginSearchEnumerator*     pPluginEnumerator = NULL;
  697.     // a much simpler version than Plugin2Handler, it's not as efficient as Plugin2Handler but it
  698.     // should be good enough for static build.
  700.     
  701.     pIUnknownInstance = NULL;
  703.     rc = FindGroupOfPluginsUsingStrings(PLUGIN_CLASS, PLUGIN_CLASS_FACTORY_TYPE,
  704. NULL, NULL, NULL, NULL, pPluginEnumerator);
  706.     if (SUCCEEDED(rc))
  707.     {
  708.         while (HXR_OK == pPluginEnumerator->GetNextPlugin(pUnknown, NULL) && pUnknown)
  709.         {
  710.     if (HXR_OK == pUnknown->QueryInterface(IID_IHXPlugin, (void**)&pPlugin))
  711.     {
  712.         pPlugin->InitPlugin(pContext);
  714.         if (HXR_OK == pUnknown->QueryInterface(IID_IHXCommonClassFactory, (void**)&pFactory))
  715.         {
  716.     if (HXR_OK == pFactory->CreateInstance(GUIDClassID, (void**)&pIUnknownInstance) &&
  717.         pIUnknownInstance)
  718.     {
  719.         break;
  720.     }
  721.     HX_RELEASE(pIUnknownInstance);
  722.         }
  723.         HX_RELEASE(pFactory);
  724.     }
  725.     HX_RELEASE(pPlugin);
  726.     HX_RELEASE(pUnknown);
  727.         }
  729.         if (!pIUnknownInstance)
  730.         {
  731.     rc = HXR_FAILED;
  732.         }
  733.     }
  735.     // cleanup
  736.     HX_RELEASE(pFactory);
  737.     HX_RELEASE(pPlugin);
  738.     HX_RELEASE(pUnknown);
  739.     HX_RELEASE(pPluginEnumerator);
  741.     return rc;
  742. }
  745. STDMETHODIMP
  746. HXPluginManager::FindCLSIDFromName( const char* pName, REF(IHXBuffer*) pCLSID )
  747. {
  748.     return HXR_NOTIMPL;
  749. }
  752. STDMETHODIMP
  753. HXPluginManager::FindGroupOfPluginsUsingValues( IHXValues* pValues,
  754. REF(IHXPluginSearchEnumerator*) pIEnumerator)
  755. {
  756.     return HXR_NOTIMPL;
  757. }
  759. STDMETHODIMP
  760. HXPluginManager::FindGroupOfPluginsUsingStrings( char* PropName1, char* PropVal1,
  761. char* PropName2, char* PropVal2,
  762. char* PropName3, char* PropVal3,
  763. REF(IHXPluginSearchEnumerator*) pIEnumerator)
  764. {
  765.     DPRINTF(D_INFO, ("HXPluginManager()::FindGroupOfPluginsUsingStrings()n"));
  766.     // Regardless of how the API can be used, the reality is that this function
  767.     // is essentially the highest level point of access for the core when
  768.     // starting playback of a new stream, so this is a great time to unload
  769.     // all our dead dlls.
  770.     // But the memory efficiency of DLL unloading comes at the expense of
  771.     // setup time, so we probably only want to do this on platforms where
  772.     // memory optimization is our highest priority.
  773. #if defined(HELIX_CONFIG_UNLOAD_DEAD_DLLS)
  774.     UnloadDeadDLLs();
  775. #endif
  777.     // Initialize out params
  778.     pIEnumerator = NULL;
  780.     // Use the internal function to build up an enumerator object
  781.     HXPluginEnumerator* pEnumerator = NULL;
  782.     HX_RESULT result = FindGroupOfPluginsUsingStrings( PropName1, PropVal1,
  783.     PropName2, PropVal2, PropName3, PropVal3, pEnumerator );
  785.     // If we have our enumerator, get the appropriate interface
  786.     if( SUCCEEDED( result ) )
  787.     {
  788. result = pEnumerator->QueryInterface( IID_IHXPluginSearchEnumerator,
  789. (void**) &pIEnumerator );
  790.     }
  792.     return result;
  793. }
  797. STDMETHODIMP
  798. HXPluginManager::FindPluginUsingValues( IHXValues* pCriteria,
  799. REF(IUnknown*) pIUnkResult,
  800. IUnknown* pIUnkOuter )
  801. {
  802.     DPRINTF(D_INFO, ("HXPluginManager()::FindPluginUsingValues()n"));
  804.     // out
  805.     pIUnkResult = NULL;
  807.     CHXSimpleList   matches;
  808.     CHXSimpleList::Iterator iter = m_plugins.Begin();
  809.     for(; iter != m_plugins.End(); ++iter)
  810.     {
  811. HXPlugin* pPlugin = (HXPlugin*) *iter;
  812. if (pPlugin->DoesMatch(pCriteria))
  813. {
  814.     matches.AddTail(pPlugin);
  815. }
  816.     }
  818.     HX_RESULT hr = HXR_FAIL;
  820.     if (matches.GetCount() > 0)
  821.     {
  822.         // return first match by default
  823.         HXPlugin* pPlug = (HXPlugin*) *(matches.Begin());
  825. #if (0)
  826.         if (matches.GetCount() > 1)
  827.         {
  828.             //
  829.             // strategy:
  830.             //
  831.             // with multiple matching plugins, pick first one with description "RealNetworks"
  832.             //
  833.     for(iter = matches.Begin(); iter != matches.End(); ++iter)
  834.     {
  835.                 HXPlugin* pThisPlugin = (HXPlugin*) *iter;
  836.                 if( IsRealNetworksPlugin(pThisPlugin) )
  837.                 {
  838.                     // use this one
  839.                     pPlug = pThisPlugin;
  840.                     break;
  841.             
  842.                 }
  843.     }
  844.         }
  845. #endif
  847.         hr = pPlug->GetInstance( pIUnkResult, pIUnkOuter );
  848.     }
  850.     return hr;
  851. }
  854. STDMETHODIMP
  855. HXPluginManager::FindPluginUsingStrings( char* PropName1, char* PropVal1,
  856. char* PropName2, char* PropVal2,
  857. char* PropName3, char* PropVal3,
  858. REF(IUnknown*) pIUnkResult,
  859. IUnknown* pIUnkOuter )
  860. {
  861.     DPRINTF(D_INFO, ("HXPluginManager()::FindPluginUsingStrings()n"));
  862.     
  863.     // out 
  864.     pIUnkResult = NULL;
  866.     // PropName and PropVal have to to valid tuple
  867.     if ((PropName1 && !PropVal1)    ||
  868. (PropName2 && !PropVal2)    ||
  869. (PropName3 && !PropVal3)    ||
  870. (!PropName1 && PropVal1)    ||
  871. (!PropName2 && PropVal2)    ||
  872. (!PropName3 && PropVal3))
  873. return HXR_FAIL;
  875.     IHXValues* pValues;
  876.     HX_RESULT   retVal = HXR_FAIL;
  878.     CHXHeader* pHeader = new CHXHeader();
  879.     pHeader->QueryInterface(IID_IHXValues,  (void**)&pValues);
  880.     AddToValues(pValues, PropName1, PropVal1, eString);
  881.     AddToValues(pValues, PropName2, PropVal2, eString);
  882.     AddToValues(pValues, PropName3, PropVal3, eString);
  883.     retVal = FindPluginUsingValues( pValues, pIUnkResult, pIUnkOuter );
  884.     pValues->Release();
  885.     return retVal;
  886. }
  889. //
  890. // Call Unload() on each plugins (library unloads only if no plugin references)
  891. //
  892. void
  893. HXPluginManager::UnloadDeadDLLs()
  894. {
  895.     DPRINTF(D_INFO, ("HXPluginManager()::UnloadDeadDLLs()n"));
  896.     
  897.     for(CHXSimpleList::Iterator iter = m_pluginDlls.Begin(); iter != m_pluginDlls.End(); ++iter)
  898.     {
  899. HXPluginDLL* pPlugDLL = (HXPluginDLL*) *iter;
  900. pPlugDLL->Unload();
  901.     }
  902. }
  905. STDMETHODIMP
  906. HXPluginManager::GetPlugin( ULONG32 ulIndex, REF(IUnknown*) pIUnkResult,
  907.     IUnknown* pIUnkOuter )
  908. {
  909.     if( ulIndex <= (ULONG32)(m_plugins.GetCount()-1) && m_plugins.GetCount() )
  910.     {
  911. LISTPOSITION pPos = m_plugins.FindIndex( ulIndex );
  912. if (pPos)
  913. {
  914.     HXPlugin* pPlugin = (HXPlugin*) m_plugins.GetAt( pPos );
  915.     if( pPlugin )
  916.     {
  917. return pPlugin->GetInstance( pIUnkResult, pIUnkOuter );
  918.     }
  919. }
  920.     }
  921.     return HXR_FAIL;
  923. }
  926. STDMETHODIMP
  927. HXPluginManager::UnloadPluginFromClassID(REFGUID GUIDClassID)
  928. {
  929.     return HXR_NOTIMPL;
  930. }
  932. STDMETHODIMP
  933. HXPluginManager::UnloadPackageByName(const char* pName)
  934. {
  935.     return HXR_NOTIMPL;
  936. }
  940. STDMETHODIMP HXPluginManager::FindPluginUsingStrings (char* PropName1,
  941.     char* PropVal1,
  942.     char* PropName2,
  943.     char* PropVal2,
  944.     char* PropName3,
  945.     char* PropVal3,
  946.     REF(IUnknown*) pRetUnk)
  947. {
  948.     return FindPluginUsingStrings( PropName1, PropVal1, PropName2, PropVal2,
  949.    PropName3, PropVal3, pRetUnk, NULL );
  950. }
  953. STDMETHODIMP
  954. HXPluginManager::FindImplementationFromClassID
  955. (
  956.     REFGUID GUIDClassID,
  957.     REF(IUnknown*) pIUnknownInstance
  958. )
  959. {
  960.     return FindImplementationFromClassID( GUIDClassID, pIUnknownInstance, NULL, m_pContext );
  961. }
  963. STDMETHODIMP HXPluginManager::Close()
  964. {
  965.     DPRINTF(D_INFO, ("HXPluginManager()::Close()n"));
  967.     // Release all dlls and associated plugins
  968.    
  969.     CHXSimpleList::Iterator iter;
  970.        
  971.     //HXPlugin
  972.     for(iter = m_plugins.Begin(); iter != m_plugins.End(); ++iter)
  973.     {
  974. HXPlugin* pPlugin = (HXPlugin*) *iter;
  975. pPlugin->Release();
  976.     }
  977.     m_plugins.RemoveAll();
  978.  
  979.     //HXPluginDLL
  980.     for(iter = m_pluginDlls.Begin(); iter != m_pluginDlls.End(); ++iter)
  981.     {
  982. HXPluginDLL* pLib = (HXPluginDLL*) *iter;
  983. pLib->Release();
  984.     }
  985.     m_pluginDlls.RemoveAll();
  987.     //HXOtherDLL
  988.     for(iter = m_otherDlls.Begin(); iter != m_otherDlls.End(); ++iter)
  989.     {
  990. HXOtherDLL* pLib = (HXOtherDLL*) *iter;
  991. pLib->Release();
  992.     }
  993.     m_otherDlls.RemoveAll();
  995.     m_mountPoints.RemoveAll();
  997.     HX_RELEASE(m_pContext);
  998.     HX_RELEASE(m_pClassFactory);
  1000.     return HXR_OK;
  1001. }
  1003. STDMETHODIMP HXPluginManager::SetRequiredPlugins (const char** ppszRequiredPlugins)
  1004. {
  1005.     return HXR_OK;
  1006. }
  1009. HX_RESULT HXPluginManager::AddToValues(IHXValues* pValues, char* pPropName, char* pPropVal, eValueTypes eValueType)
  1010. {
  1011.     if (!pPropName || !pPropVal)
  1012. return HXR_FAIL;
  1014.     // trim value
  1015.     CHXString theValue = (pPropVal);
  1016.     theValue.TrimLeft();
  1017.     theValue.TrimRight();
  1019.     HX_RESULT hr = HXR_OK;
  1020.     switch (eValueType)
  1021.     {
  1022. case eString:
  1023. {
  1024.     IHXBuffer* pBuffer;
  1025.     CHXBuffer* pCHXBuffer;
  1026.     pCHXBuffer = new CHXBuffer;
  1027.     pCHXBuffer->QueryInterface(IID_IHXBuffer, (void**) &pBuffer);
  1028.     pBuffer->Set((const unsigned char*)(const char*)theValue, strlen(theValue)+1);
  1029.     pValues->SetPropertyCString(pPropName, pBuffer);
  1030.     pBuffer->Release();
  1031.             break;
  1032. }
  1033. case eInt:
  1034. {
  1035.     int val = atoi(theValue);
  1036.     pValues->SetPropertyULONG32(pPropName, (ULONG32)val);
  1037.     break;
  1038. }
  1039.         default:
  1040.             hr = HXR_NOTIMPL;
  1041.             break;
  1042.     }
  1043.     return hr;
  1044. }
  1046. STDMETHODIMP_(ULONG32) HXPluginManager::GetNumOfPlugins()
  1047. {
  1048.     return m_plugins.GetCount();
  1049. }
  1051. STDMETHODIMP HXPluginManager::GetPlugin(ULONG32 ulIndex, REF(IUnknown*)  /*OUT*/ pInstance)
  1052. {
  1053.     return GetPlugin( ulIndex, pInstance, NULL );
  1054. }
  1057. STDMETHODIMP HXPluginManager::FlushCache()
  1058. {
  1059.     return HXR_OK;
  1060. }
  1062. STDMETHODIMP HXPluginManager::SetCacheSize(ULONG32 nSizeKB)
  1063. {
  1064.     return HXR_OK;
  1065. }
  1067. STDMETHODIMP HXPluginManager::ReadFromRegistry()
  1068. {
  1069.     DPRINTF(D_INFO, ("HXPluginManager()::ReadFromRegistry()n"));
  1070.     HX_RESULT result;
  1071.     IHXBuffer* pBuffer = NULL;
  1073. #if !defined(_STATICALLY_LINKED) || defined(HELIX_CONFIG_CONSOLIDATED_CORE)
  1075.     const char* pPath = GetDLLAccessPath()->GetPath(DLLTYPE_PLUGIN);
  1076.     pBuffer = HXBufferUtil::CreateBuffer(m_pClassFactory, pPath);
  1077. #endif
  1079.     // Set up a mount point with the default plugin location
  1080.     result = AddPluginMountPoint(HXVER_SDK_PRODUCT, 0, 0, pBuffer);
  1082.     HX_RELEASE(pBuffer);
  1084.     return result;
  1085. }
  1088. /********************************************************************
  1089. *
  1090. * Plugin Enumeration
  1091. *
  1092. ********************************************************************/
  1094. BEGIN_INTERFACE_LIST_NOCREATE( HXPluginEnumerator )
  1095.     INTERFACE_LIST_ENTRY_SIMPLE( IHXPluginSearchEnumerator )
  1096. END_INTERFACE_LIST
  1098. HXPluginEnumerator::HXPluginEnumerator() :
  1099.     m_nIndex(0)
  1100. {
  1101. }
  1103. HXPluginEnumerator::~HXPluginEnumerator()
  1104. {
  1105. }
  1108. STDMETHODIMP_( UINT32 )
  1109. HXPluginEnumerator::GetNumPlugins()
  1110. {
  1111.     return m_plugins.GetCount();
  1112. }
  1114. STDMETHODIMP_( void )
  1115. HXPluginEnumerator::GoHead()
  1116. {
  1117.     m_nIndex = 0;
  1118. }
  1121. STDMETHODIMP
  1122. HXPluginEnumerator::GetNextPlugin( REF(IUnknown*) pIUnkResult, IUnknown* pIUnkOuter )
  1123. {
  1124.     // Initialize out params
  1125.     pIUnkResult = NULL;
  1127.     HX_RESULT res = GetPluginAt( m_nIndex, pIUnkResult, pIUnkOuter );
  1128.     m_nIndex++;
  1130.     return res;
  1131. }
  1133. STDMETHODIMP
  1134. HXPluginEnumerator::GetNextPluginInfo( REF(IHXValues*) pRetValues )
  1135. {
  1136.     pRetValues = NULL;
  1138.     HX_RESULT res = GetPluginInfoAt( m_nIndex, pRetValues );
  1139.     m_nIndex++;
  1141.     return res;
  1142. }
  1145. STDMETHODIMP
  1146. HXPluginEnumerator::GetPluginAt( UINT32 index, REF(IUnknown*) pIUnkResult, IUnknown* pIUnkOuter )
  1147. {
  1148.     pIUnkResult = NULL;
  1150.     HX_RESULT res = HXR_FAIL;
  1152.     LISTPOSITION pos = m_plugins.FindIndex(index);
  1153.     if (pos)
  1154.     {
  1155. HXPlugin* pPlugin = (HXPlugin*) m_plugins.GetAt(pos);
  1156. if (pPlugin)
  1157. {
  1158.     res = pPlugin->GetInstance( pIUnkResult, pIUnkOuter );
  1159. }
  1160.     }
  1161.     return res;
  1162. }
  1165. STDMETHODIMP
  1166. HXPluginEnumerator::GetPluginInfoAt( UINT32 index, REF(IHXValues*) pRetValues )
  1167. {
  1168.     // Initialize out params
  1169.     pRetValues = NULL;
  1171.     HX_RESULT res = HXR_FAIL;
  1173.     LISTPOSITION pos = m_plugins.FindIndex(m_nIndex);
  1174.     m_nIndex++;
  1175.     if (pos)
  1176.     {
  1177. HXPlugin* pPlugin = (HXPlugin*) m_plugins.GetAt(pos);
  1178. if (pPlugin)
  1179. {
  1180.     res = pPlugin->GetPluginInfo( pRetValues );
  1181. }
  1182.     }
  1184.     return res;
  1185. }
  1188. void HXPluginEnumerator::Add(HXPlugin* pPlugin)
  1189. {
  1190.     HX_ASSERT(pPlugin);
  1191.     m_plugins.AddTail(pPlugin);
  1192. }