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

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

Symbian

开发平台：

C/C++

hxpluginmanager.cpp：源码内容
  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. #include "hxtypes.h"
  37. #include "hxassert.h"
  38. #include "debug.h"
  39. #include "hxcom.h"
  40. #include "hxccf.h"      // IHXCommonClassFactory
  41. #include "ihxpckts.h"   // IHXBuffer
  42. #include "hxplugn.h"    // IHXComponentPlugin
  43. #include "hxprefs.h" // IHXPreferences
  44. #include "hxprefutil.h"
  45. #include "findfile.h"
  46. #include "chxpckts.h"   // CHXHeader
  47. #include "dllacces.h"
  48. #include "dllpath.h"
  49. #include "pathutil.h"
  50. #include "hxver.h"
  52. #include "hxheap.h"
  53. #ifdef _DEBUG
  54. #undef HX_THIS_FILE
  55. static const char HX_THIS_FILE[] = __FILE__;
  56. #endif
  58. #if defined(_STATICALLY_LINKED)
  59. #include "staticff.h"
  60. #endif
  62. #include "hxpluginarchive.h"
  63. #include "hxplugindll.h"
  64. #include "hxplugin.h"
  65. #include "hxpluginmanager.h"
  68. #if(0)
  69. // helper
  70. static bool IsRealNetworksPlugin(HXPlugin* pPlugin)
  71. {
  72.     bool isRNPlugin = false;
  74.     HX_ASSERT(pPlugin);
  75.     IHXValues* pval = 0;
  76.     if (SUCCEEDED(pPlugin->GetPluginInfo(pval)))
  77.     {
  78.         IHXBuffer* pbuff = 0;
  79. if (SUCCEEDED(pval->GetPropertyCString(PLUGIN_DESCRIPTION2, pbuff)))
  80. {
  81.     isRNPlugin =  (0 != strstr((const char*)pbuff->GetBuffer(), "RealNetworks"));
  82.             HX_RELEASE(pbuff);
  83.         }
  84.         HX_RELEASE(pval);
  85.     }
  87.     return isRNPlugin;
  88. }
  89. #endif
  92. IMPLEMENT_COM_CREATE_FUNCS( HXPluginManager )
  94. BEGIN_INTERFACE_LIST_NOCREATE( HXPluginManager )
  95.     INTERFACE_LIST_ENTRY_SIMPLE( IHXPluginEnumerator )
  96.     INTERFACE_LIST_ENTRY_SIMPLE( IHXPlugin2Handler )
  97.     INTERFACE_LIST_ENTRY_SIMPLE( IHXPluginHandler3 )
  98. END_INTERFACE_LIST
  100. HXPluginManager::HXPluginManager() 
  101. : m_pContext(0)
  102. , m_pClassFactory(0)
  103. {
  104. }
  106. HXPluginManager::~HXPluginManager()
  107. {
  108.     Close();
  109. }
  111. STDMETHODIMP HXPluginManager::Init(IUnknown* pContext)
  112. {
  113.     DPRINTF(D_INFO, ("HXPluginManager::Init()n"));
  114.     HX_RESULT result = HXR_FAIL;
  116.     if( SUCCEEDED( result = RegisterContext( pContext ) ) )
  117.     {
  118. result = ReadFromRegistry();
  119.     }
  121.     return result;
  122. }
  125. STDMETHODIMP_(ULONG32) HXPluginManager::GetNumOfPlugins2()
  126. {
  127.     return m_plugins.GetCount();
  128. }
  131. STDMETHODIMP
  132. HXPluginManager::GetPluginInfo(UINT32 unIndex, REF(IHXValues*) /*OUT*/ pValues)
  133. {
  134.     return HXR_NOTIMPL;
  135. }
  137. ///////////////////////////////////////////////////////////////////////////////
  138. //
  139. HX_RESULT HXPluginManager::ReloadPluginsNoPropagate()
  140. {
  141.     return ReloadPlugins();
  142. }
  144. ///////////////////////////////////////////////////////////////////////////////
  145. //
  146. HX_RESULT HXPluginManager::ReloadPlugins()
  147. {
  148.     DPRINTF(D_INFO, ("HXPluginManager()::ReloadPlugins()n"));
  150.     HX_RESULT result = HXR_OK;
  152.     // reload plugins for all mountpoints
  153.     for(CHXMapStringToString::Iterator iter = m_mountPoints.Begin(); iter != m_mountPoints.End(); ++iter)
  154.     {
  155. const char* pMountPoint = (const char*) *iter;
  156. if( FAILED( ReloadPlugins( pMountPoint ) ) )
  157. {
  158.     result = HXR_FAIL;
  159. }
  160.     }
  162.     return result;
  163. }
  165. /////////////////////////////////
  166. //
  167. // do we already have the given dll in our collection?
  168. //
  169. // we use case insensitive match in all OS/filesystem cases (even if technically inappropriate)
  170. //
  171. bool HXPluginManager::DoesDLLExist(const char* pszName, const char* pszMountPoint)
  172. {
  173.     CHXSimpleList::Iterator iter;
  174.     for(iter = m_pluginDlls.Begin(); iter != m_pluginDlls.End(); ++iter)
  175.     {
  176. HXPluginDLL* pLib = (HXPluginDLL*) *iter;
  178.         if( !pLib->GetFileName().CompareNoCase(pszName) && !pLib->GetMountPoint().CompareNoCase(pszMountPoint) )
  179.         {
  180.             DPRINTF(D_INFO, ("HXPluginManager::DoesDLLExist(): plugin dll exists '%s'n", (const char*)pLib->GetFileName()));
  181.             return true;
  182.         }
  183.     }
  185.     for(iter = m_otherDlls.Begin(); iter != m_otherDlls.End(); ++iter)
  186.     {
  187. HXOtherDLL* pLib = (HXOtherDLL*) *iter;
  188.         if( !pLib->GetFileName().CompareNoCase(pszName) && !pLib->GetMountPoint().CompareNoCase(pszMountPoint) )
  189.         {
  190.             DPRINTF(D_INFO, ("HXPluginManager::DoesDLLExist(): other dll exists '%s'n", (const char*)pLib->GetFileName()));
  191.             return true;
  192.         }
  193.     }
  194.     return false;
  195. }
  197. HX_RESULT HXPluginManager::SaveToArchive(const char* pszArchiveFile)
  198. {
  199.     DPRINTF(D_INFO, ("SaveToArchive(): writing '%s' (%d plugin dlls; %d other dlls)n", pszArchiveFile, m_pluginDlls.GetCount(), m_otherDlls.GetCount()));
  200.     HXPluginArchiveWriter ar;
  201.     HX_RESULT hr = ar.Open(m_pContext, pszArchiveFile);
  202.     if(SUCCEEDED(hr))
  203.     {
  204.         CHXSimpleList::Iterator iter;
  205.         for(iter = m_pluginDlls.Begin(); iter != m_pluginDlls.End(); ++iter)
  206.         {
  207.             HXPluginDLL* pLib = (HXPluginDLL*) *iter;
  208.             pLib->Archive(ar);
  209.         }
  210.         for(iter = m_otherDlls.Begin(); iter != m_otherDlls.End(); ++iter)
  211.         {
  212.             HXOtherDLL* pLib = (HXOtherDLL*) *iter;
  213.             pLib->Archive(ar);
  214.         }
  215.     }
  216.     ar.Close();
  217.     return hr;
  218. }
  220. HX_RESULT HXPluginManager::LoadPluginDLLFromArchive(const char* pszMountPoint, HXPluginArchiveReader& ar)
  221. {
  222.     HXPluginDLL* pPluginDLL = new HXPluginDLL(m_pContext, pszMountPoint, ar);
  223.     if( !pPluginDLL )
  224.     {
  225.         return HXR_OUTOFMEMORY;
  226.     }
  227.     pPluginDLL->AddRef();
  229.     HX_ASSERT(!DoesDLLExist(pPluginDLL->GetFileName(), pPluginDLL->GetMountPoint()));
  231.     // no need to load! that's the point of the archive
  232.     HX_ASSERT(pPluginDLL->GetNumPlugins() > 0);
  234.     m_pluginDlls.AddTail(pPluginDLL);
  236.     return HXR_OK;
  237. }
  239. HX_RESULT HXPluginManager::LoadOtherDLLFromArchive(const char* pszMountPoint, HXPluginArchiveReader& ar)
  240. {
  241.     HXOtherDLL* pOtherDLL = new HXOtherDLL(pszMountPoint, ar);
  242.     if( !pOtherDLL )
  243.     {
  244.         return HXR_OUTOFMEMORY;
  245.     }
  247.     pOtherDLL->AddRef();
  248.     HX_ASSERT(!DoesDLLExist(pOtherDLL->GetFileName(), pOtherDLL->GetMountPoint()));
  249.     m_otherDlls.AddTail(pOtherDLL);
  251.     return HXR_OK;
  252. }
  254. //
  255. // Try to re-construct plugin dll and associated plugin objects
  256. // from saved archive for faster plugin discovery
  257. //
  258. // If you want to override this (i.e., after new dlls installed), delete the archive
  259. //
  260. HX_RESULT HXPluginManager::LoadFromArchive(const char* pszArchiveFile, const char* pszMountPoint)
  261. {
  262.     DPRINTF(D_INFO, ("LoadFromArchive(): looking for '%s'n", pszArchiveFile));
  263.     HXPluginArchiveReader ar;
  264.     HX_RESULT hr = ar.Open(m_pContext, pszArchiveFile);
  265.     if(SUCCEEDED(hr))
  266.     {
  267.         while(SUCCEEDED(hr) && !ar.AtEnd())
  268.         {
  269.             UINT32 type;
  270.             ar.Read(type);
  271.             switch(type)
  272.             {
  273.             case ARCHIVE_ID_PLUGIN_DLL:
  274.                 hr = LoadPluginDLLFromArchive(pszMountPoint,ar);
  275.                 break;
  276.             case ARCHIVE_ID_OTHER_DLL:
  277.                 hr = LoadOtherDLLFromArchive(pszMountPoint, ar);
  278.                 break;
  279.             default:
  280.                 hr = HXR_FAIL;
  281.                 break;
  282.             }
  283.         }
  284.     
  285.         ar.Close();
  287.         DPRINTF(D_INFO, ("LoadFromArchive(): found %ld plugin dlls, %ld other dllsn", m_pluginDlls.GetCount(), m_otherDlls.GetCount()));
  288.     }
  289.     else
  290.     {
  291.         DPRINTF(D_INFO, ("LoadFromArchive(): archive missingn"));
  292.     }
  294.     return hr;
  295. }
  297. ///////////////////////////////////////////////////////////////////////////////
  298. //
  299. // 'query plugin dlls'
  300. //
  301. // load all plugin dlls and determine associated plugin attributes
  302. //
  303. // called when:
  304. //
  305. //   1) a mount point is added
  306. //   2) a mount point is removed and re-added (e.g., dynamic re-load)
  307. //
  308. // does nothing if dlls for mount point have already been loaded and queried
  309. //
  310. HX_RESULT HXPluginManager::ReloadPluginsWithFindFile(
  311.                const char* pMountPoint, CFindFile* pFileFinder,
  312.                IHXBuffer* pPathBuffer, const char* pszPluginDir)
  313. {
  314.     DPRINTF(D_INFO, ("HXPluginManager()::ReloadPluginsWithFindFile()n"));
  315.   
  316.     CHXString strArchiveFile;
  317.     IHXPreferences* pPrefs = 0;
  318.     m_pContext->QueryInterface(IID_IHXPreferences, (void**) &pPrefs);
  319.     HX_RESULT hr = ReadPrefCSTRING(pPrefs, "PluginArchiveFileName", strArchiveFile);
  320.     HX_RELEASE(pPrefs);
  321.     if(SUCCEEDED(hr))
  322.     {
  323.         // first try to recreate dll and plugin state from archive
  324.         hr = LoadFromArchive(strArchiveFile, pMountPoint); 
  325.     }
  326.     if(HXR_OUTOFMEMORY == hr)
  327.     {
  328.         return hr;
  329.     }
  330.     
  331.     // iterate files in this plugin directory
  332.     hr = HXR_OK;
  333.     bool bWriteArchive = false;
  334.     const char* pszDllName = pFileFinder->FindFirst();
  335.     for (; pszDllName; pszDllName = pFileFinder->FindNext())
  336.     {
  337.         if( DoesDLLExist(pszDllName, pMountPoint) )
  338.         {
  339.             // we already have info about this dll (perhaps from achive)
  340.             continue;
  341.         }
  343.         // since we found a dll we don't know about yet we need to update the archive
  344.         bWriteArchive = true;
  346.         // create plugin dll wrapper, assuming this is a plugin dll
  347.         HXPluginDLL* pPluginDll  = new HXPluginDLL(m_pContext, pszDllName, pMountPoint);
  348.         if(!pPluginDll)
  349.         {
  350.             // oom
  351.     hr = HXR_OUTOFMEMORY;
  352.             break;
  353.         }
  354.         pPluginDll->AddRef();
  356.         // load dll to force query of supported plugins
  357.         hr = pPluginDll->Load();
  358.         if (SUCCEEDED(hr))
  359.         {
  360.             // add successfully loaded dll to list
  361.             pPluginDll->AddRef();
  362.             m_pluginDlls.AddTail(pPluginDll);
  364.             // Unload the dll. The dll was loaded only to query supported plugin 
  365.             // info. It will be re-loaded only when actually needed, i.e., when
  366.             // an instance of a plugin that it implements is requested.
  367.             pPluginDll->Unload();
  368.         }
  369.         HX_RELEASE(pPluginDll);
  370.         if (FAILED(hr))
  371.         {
  372.             if(HXR_OUTOFMEMORY == hr)
  373.             {
  374.                 break;
  375.             }
  377.             // lib load attempt failed; add this to 'other' dll list (maybe it is a codec dll, e.g.)
  378.             HXOtherDLL* pOtherDll  = new HXOtherDLL(pszDllName, pMountPoint);
  379.             if( !pOtherDll)
  380.             {
  381.                 //oom
  382.                 hr = HXR_OUTOFMEMORY;
  383.                 break;
  384.             }
  385.             pOtherDll->AddRef();
  386.             m_otherDlls.AddTail(pOtherDll);
  387.             bWriteArchive = true;
  388.         }
  389.     }
  391.     RebuildPluginList();
  393.     // write archive now if it needs updating
  394.     if(bWriteArchive)
  395.     {
  396.         SaveToArchive(strArchiveFile);
  397.     }
  399.     return hr;
  400. }
  402. ///////////////////////////////////////////////////////////////////////////////
  403. //
  404. HX_RESULT HXPluginManager::ReloadPlugins( const char* pMountPoint )
  405. {
  406.     CFindFile* pFileFinder = NULL;
  407.     IHXBuffer* pPathBuffer = NULL;
  409.     HX_RESULT hr = HXR_FAIL;
  411.     HX_ASSERT(m_pContext);
  412.     if (m_pContext)
  413.     {
  414. #if defined(_STATICALLY_LINKED) && !defined(HELIX_CONFIG_CONSOLIDATED_CORE)
  415.         const char* const pszPluginDir = "";
  416.         pFileFinder = CStaticFindFile::CreateFindFile(pszPluginDir,0, OS_DLL_PATTERN_STRING);
  417. #else
  418.         const char* const pszPluginDir = pMountPoint;
  419.         pFileFinder = CFindFile::CreateFindFile(pszPluginDir, 0, OS_DLL_PATTERN_STRING);
  420. #endif
  421.         
  422.         if (pFileFinder)
  423.         {
  424.             hr = ReloadPluginsWithFindFile(pMountPoint, pFileFinder, pPathBuffer, pszPluginDir);
  425.             HX_DELETE(pFileFinder);
  426.         }
  427.     }
  429.     return hr;
  430. }
  432. STDMETHODIMP HXPluginManager::FindIndexUsingValues(IHXValues* pValues,REF(UINT32) unIndex)
  433. {
  434.     return HXR_NOTIMPL;
  435. }
  437. STDMETHODIMP HXPluginManager::GetInstance (UINT32 index, REF(IUnknown*) pUnknown)
  438. {
  439.     pUnknown = NULL;
  440.     LISTPOSITION pPos = m_plugins.FindIndex(index);
  441.     if (pPos)
  442.     {
  443. HXPlugin* pPlugin = (HXPlugin*) m_plugins.GetAt(pPos);
  444. if (pPlugin)
  445. {
  446.     return pPlugin->GetInstance(pUnknown);
  447. }
  448.     }
  449.     return HXR_FAIL;
  450. }
  452. STDMETHODIMP HXPluginManager::FindIndexUsingStrings (char* PropName1,
  453.     char* PropVal1,
  454.     char* PropName2,
  455.     char* PropVal2,
  456.     char* PropName3,
  457.     char* PropVal3,
  458.     REF(UINT32) unIndex)
  459. {
  460.     return HXR_NOTIMPL;
  461. }
  464. STDMETHODIMP HXPluginManager::FindPluginUsingValues(IHXValues* pValues,REF(IUnknown*) pUnk)
  465. {
  466.     return FindPluginUsingValues( pValues, pUnk, NULL );
  467. }
  469. HX_RESULT HXPluginManager::FindGroupOfPluginsUsingStrings(char* PropName1,
  470.     char* PropVal1,
  471.     char* PropName2,
  472.     char* PropVal2,
  473.     char* PropName3,
  474.     char* PropVal3,
  475.     REF(HXPluginEnumerator*) pEnumerator)
  476. {
  477.     DPRINTF(D_INFO, ("HXPluginManager()::FindGroupOfPluginsUsingStrings(): '%s' = '%s', etc.n", PropName1, PropVal1));
  479.     // PropName and PropVal have to to valid tuple
  480.     if ((PropName1 && !PropVal1)    ||
  481. (PropName2 && !PropVal2)    ||
  482. (PropName3 && !PropVal3)    ||
  483. (!PropName1 && PropVal1)    ||
  484. (!PropName2 && PropVal2)    ||
  485. (!PropName3 && PropVal3))
  486. return HXR_FAIL;
  488.     IHXValues* pValues;
  489.     HX_RESULT   retVal = HXR_FAIL;
  491.     CHXHeader* pHeader = new CHXHeader;
  492.     pHeader->QueryInterface(IID_IHXValues,  (void**)&pValues);
  493.     AddToValues(pValues, PropName1, PropVal1, eString);
  494.     AddToValues(pValues, PropName2, PropVal2, eString);
  495.     AddToValues(pValues, PropName3, PropVal3, eString);
  496.     retVal = FindGroupOfPluginsUsingValues(pValues, pEnumerator);
  497.     pValues->Release();
  498.     return retVal;
  499. }
  501. HX_RESULT HXPluginManager::FindGroupOfPluginsUsingValues(IHXValues* pValues,
  502. REF(HXPluginEnumerator*) pEnumerator)
  503. {
  504.     
  505.     HX_RESULT hr = HXR_FAIL;
  506.     pEnumerator = NULL;
  508.     for(CHXSimpleList::Iterator iter = m_plugins.Begin();
  509.         iter != m_plugins.End(); ++iter)
  510.     {
  511. HXPlugin* pPlugin = (HXPlugin*) *iter;
  513. if (pPlugin->DoesMatch(pValues))
  514. {
  515.     if (!pEnumerator)
  516.     {
  517. pEnumerator = new HXPluginEnumerator();
  518.                 if(pEnumerator)
  519.                 {
  520.                     hr = HXR_OK;
  521.                 }
  522.                 else
  523.                 {
  524.                     hr = HXR_OUTOFMEMORY;
  525.                     break;
  526.                 }
  527.     }
  528.     
  529.             pEnumerator->Add(pPlugin); 
  530.         }
  531.     }
  533.     return hr;
  534. }
  537. // IHXPluginHandler3
  538. STDMETHODIMP
  539. HXPluginManager::RegisterContext( IUnknown* pContext )
  540. {
  541.     HX_ASSERT(pContext);
  542.     if( !pContext )
  543.     {
  544. return HXR_INVALID_PARAMETER;
  545.     }
  547.     if( m_pContext )
  548.     {
  549. return HXR_UNEXPECTED;
  550.     }
  552.     m_pContext = pContext;
  553.     m_pContext->AddRef();
  555.     m_pContext->QueryInterface(IID_IHXCommonClassFactory, (void**)&m_pClassFactory);
  557.     return HXR_OK;
  558. }
  560. // IHXPluginHandler3
  561. STDMETHODIMP
  562. HXPluginManager::AddPluginMountPoint( const char* pName, UINT32 majorVersion, UINT32 minorVersion, IHXBuffer* pPath )
  563. {
  564.     DPRINTF(D_INFO, ("HXPluginManager()::AddPluginMountPoint(): name = '%s'n", pName));
  566.     const char* pMPKey = pName ? pName : (const char*) pPath->GetBuffer();
  568.     // Make sure this mount point is in the list
  569.     CHXString strMountPoint;
  570.     if( !m_mountPoints.Lookup(pMPKey, strMountPoint) && pPath )
  571.     {
  572.         strMountPoint = (const char*)pPath->GetBuffer();
  573.         
  574.         // Put new mount point in list
  575.         m_mountPoints.SetAt( pMPKey, strMountPoint );
  576.     }
  578.     // Load information from registry, and sync DLLs that aren't up to date
  579.     return ReloadPlugins( strMountPoint );
  580. }
  582. // IHXPluginHandler3
  583. STDMETHODIMP
  584. HXPluginManager::RefreshPluginMountPoint( const char* pName )
  585. {
  586.     HX_RESULT result = HXR_FAIL;
  588.     CHXString strMountPoint;
  589.     if( m_mountPoints.Lookup( pName, strMountPoint ) )
  590.     {
  591. result = ReloadPlugins( strMountPoint );
  592.     }
  594.     return result;
  595. }
  597. // IHXPluginHandler3
  598. STDMETHODIMP
  599. HXPluginManager::RemovePluginMountPoint( const char* pName )
  600. {
  601.     HX_RESULT hr = HXR_FAIL;
  603.     CHXString strMountPoint;
  604.     if( m_mountPoints.Lookup( pName, strMountPoint ) )
  605.     {
  606. // Clean up plugin dlls associated with mountpoint
  607. LISTPOSITION listPos = m_pluginDlls.GetHeadPosition();
  608. while( listPos )
  609. {
  610.     LISTPOSITION curPos = listPos;
  611.     HXPluginDLL* pLibrary = (HXPluginDLL*) m_pluginDlls.GetNext( listPos );
  612.     if( pLibrary && ( pLibrary->GetMountPoint() == strMountPoint ) )
  613.     {
  614. m_pluginDlls.RemoveAt( curPos ); 
  615.                 pLibrary->Unload(); // just in case; this should be last ref
  616. HX_RELEASE( pLibrary );
  617.     }
  618. }
  620.         
  621.         // Clean up 'other' dlls associated with mountpoint
  622.         listPos = m_otherDlls.GetHeadPosition();
  623. while( listPos )
  624. {
  625.     LISTPOSITION curPos = listPos;
  626.     HXOtherDLL* pLibrary = (HXOtherDLL*) m_otherDlls.GetNext( listPos );
  627.     if( pLibrary && ( pLibrary->GetMountPoint() == strMountPoint ) )
  628.     {
  629. m_otherDlls.RemoveAt( curPos ); 
  630. HX_RELEASE( pLibrary );
  631.     }
  632. }
  633.        
  634. m_mountPoints.RemoveKey( pName );
  636.         // Plugin list must be rebuilt
  637.         RebuildPluginList();
  639.         hr = HXR_OK;
  641.     }
  643.     return hr;
  644. }
  646. //
  647. // called every time dll list has been altered (we could be more efficient in many cases)
  648. //
  649. void HXPluginManager::RebuildPluginList()
  650. {
  651.     DPRINTF(D_INFO, ("HXPluginManager()::RebuildPluginList()n"));
  653.     CHXSimpleList::Iterator iter;
  654.         
  655.     // clean up (now invalid) plugin list
  656.     for(iter = m_plugins.Begin(); iter != m_plugins.End(); ++iter)
  657.     {
  658. HXPlugin* pPlugin = (HXPlugin*) *iter;
  659. pPlugin->Release();
  660.     }
  661.     m_plugins.RemoveAll();
  663.     // rebuild list of plugins we can instanciate
  664.     for(iter = m_pluginDlls.Begin(); iter != m_pluginDlls.End(); ++iter)
  665.     {
  666. HXPluginDLL* pLibrary = (HXPluginDLL*) *iter;
  667.         pLibrary->AddPlugins(m_plugins);
  668.     }
  669. }
  672. STDMETHODIMP
  673. HXPluginManager::FindImplementationFromClassID( REFGUID GUIDClassID, REF(IUnknown*) pIUnknownInstance,
  674.     IUnknown* pIUnkOuter, IUnknown* pContext )
  675. {
  676.     DPRINTF(D_INFO, ("HXPluginManager()::FindImplementationFromClassID()n"));
  677.     HX_RESULT     rc = HXR_OK;
  678.     IUnknown*     pUnknown = NULL;
  679.     IHXPlugin*     pPlugin = NULL;
  680.     IHXCommonClassFactory*     pFactory = NULL;
  681.     IHXPluginSearchEnumerator*     pPluginEnumerator = NULL;
  683.     // a much simpler version than Plugin2Handler, it's not as efficient as Plugin2Handler but it
  684.     // should be good enough for static build.
  686.     
  687.     pIUnknownInstance = NULL;
  689.     rc = FindGroupOfPluginsUsingStrings(PLUGIN_CLASS, PLUGIN_CLASS_FACTORY_TYPE,
  690. NULL, NULL, NULL, NULL, pPluginEnumerator);
  692.     if (SUCCEEDED(rc))
  693.     {
  694.         while (HXR_OK == pPluginEnumerator->GetNextPlugin(pUnknown, NULL) && pUnknown)
  695.         {
  696.     if (HXR_OK == pUnknown->QueryInterface(IID_IHXPlugin, (void**)&pPlugin))
  697.     {
  698.         pPlugin->InitPlugin(pContext);
  700.         if (HXR_OK == pUnknown->QueryInterface(IID_IHXCommonClassFactory, (void**)&pFactory))
  701.         {
  702.     if (HXR_OK == pFactory->CreateInstance(GUIDClassID, (void**)&pIUnknownInstance) &&
  703.         pIUnknownInstance)
  704.     {
  705.         break;
  706.     }
  707.     HX_RELEASE(pIUnknownInstance);
  708.         }
  709.         HX_RELEASE(pFactory);
  710.     }
  711.     HX_RELEASE(pPlugin);
  712.     HX_RELEASE(pUnknown);
  713.         }
  715.         if (!pIUnknownInstance)
  716.         {
  717.     rc = HXR_FAILED;
  718.         }
  719.     }
  721.     // cleanup
  722.     HX_RELEASE(pFactory);
  723.     HX_RELEASE(pPlugin);
  724.     HX_RELEASE(pUnknown);
  725.     HX_RELEASE(pPluginEnumerator);
  727.     return rc;
  728. }
  731. STDMETHODIMP
  732. HXPluginManager::FindCLSIDFromName( const char* pName, REF(IHXBuffer*) pCLSID )
  733. {
  734.     return HXR_NOTIMPL;
  735. }
  738. STDMETHODIMP
  739. HXPluginManager::FindGroupOfPluginsUsingValues( IHXValues* pValues,
  740. REF(IHXPluginSearchEnumerator*) pIEnumerator)
  741. {
  742.     return HXR_NOTIMPL;
  743. }
  745. STDMETHODIMP
  746. HXPluginManager::FindGroupOfPluginsUsingStrings( char* PropName1, char* PropVal1,
  747. char* PropName2, char* PropVal2,
  748. char* PropName3, char* PropVal3,
  749. REF(IHXPluginSearchEnumerator*) pIEnumerator)
  750. {
  751.     DPRINTF(D_INFO, ("HXPluginManager()::FindGroupOfPluginsUsingStrings()n"));
  752.     // Regardless of how the API can be used, the reality is that this function
  753.     // is essentially the highest level point of access for the core when
  754.     // starting playback of a new stream, so this is a great time to unload
  755.     // all our dead dlls.
  756.     // But the memory efficiency of DLL unloading comes at the expense of
  757.     // setup time, so we probably only want to do this on platforms where
  758.     // memory optimization is our highest priority.
  759. #if defined(HELIX_CONFIG_UNLOAD_DEAD_DLLS)
  760.     UnloadDeadDLLs();
  761. #endif
  763.     // Initialize out params
  764.     pIEnumerator = NULL;
  766.     // Use the internal function to build up an enumerator object
  767.     HXPluginEnumerator* pEnumerator = NULL;
  768.     HX_RESULT result = FindGroupOfPluginsUsingStrings( PropName1, PropVal1,
  769.     PropName2, PropVal2, PropName3, PropVal3, pEnumerator );
  771.     // If we have our enumerator, get the appropriate interface
  772.     if( SUCCEEDED( result ) )
  773.     {
  774. result = pEnumerator->QueryInterface( IID_IHXPluginSearchEnumerator,
  775. (void**) &pIEnumerator );
  776.     }
  778.     return result;
  779. }
  783. STDMETHODIMP
  784. HXPluginManager::FindPluginUsingValues( IHXValues* pCriteria,
  785. REF(IUnknown*) pIUnkResult,
  786. IUnknown* pIUnkOuter )
  787. {
  788.     DPRINTF(D_INFO, ("HXPluginManager()::FindPluginUsingValues()n"));
  790.     // out
  791.     pIUnkResult = NULL;
  793.     CHXSimpleList   matches;
  794.     CHXSimpleList::Iterator iter = m_plugins.Begin();
  795.     for(; iter != m_plugins.End(); ++iter)
  796.     {
  797. HXPlugin* pPlugin = (HXPlugin*) *iter;
  798. if (pPlugin->DoesMatch(pCriteria))
  799. {
  800.     matches.AddTail(pPlugin);
  801. }
  802.     }
  804.     HX_RESULT hr = HXR_FAIL;
  806.     if (matches.GetCount() > 0)
  807.     {
  808.         // return first match by default
  809.         HXPlugin* pPlug = (HXPlugin*) *(matches.Begin());
  811. #if (0)
  812.         if (matches.GetCount() > 1)
  813.         {
  814.             //
  815.             // strategy:
  816.             //
  817.             // with multiple matching plugins, pick first one with description "RealNetworks"
  818.             //
  819.     for(iter = matches.Begin(); iter != matches.End(); ++iter)
  820.     {
  821.                 HXPlugin* pThisPlugin = (HXPlugin*) *iter;
  822.                 if( IsRealNetworksPlugin(pThisPlugin) )
  823.                 {
  824.                     // use this one
  825.                     pPlug = pThisPlugin;
  826.                     break;
  827.             
  828.                 }
  829.     }
  830.         }
  831. #endif
  833.         hr = pPlug->GetInstance( pIUnkResult, pIUnkOuter );
  834.     }
  836.     return hr;
  837. }
  840. STDMETHODIMP
  841. HXPluginManager::FindPluginUsingStrings( char* PropName1, char* PropVal1,
  842. char* PropName2, char* PropVal2,
  843. char* PropName3, char* PropVal3,
  844. REF(IUnknown*) pIUnkResult,
  845. IUnknown* pIUnkOuter )
  846. {
  847.     DPRINTF(D_INFO, ("HXPluginManager()::FindPluginUsingStrings()n"));
  848.     
  849.     // out 
  850.     pIUnkResult = NULL;
  852.     // PropName and PropVal have to to valid tuple
  853.     if ((PropName1 && !PropVal1)    ||
  854. (PropName2 && !PropVal2)    ||
  855. (PropName3 && !PropVal3)    ||
  856. (!PropName1 && PropVal1)    ||
  857. (!PropName2 && PropVal2)    ||
  858. (!PropName3 && PropVal3))
  859. return HXR_FAIL;
  861.     IHXValues* pValues;
  862.     HX_RESULT   retVal = HXR_FAIL;
  864.     CHXHeader* pHeader = new CHXHeader();
  865.     pHeader->QueryInterface(IID_IHXValues,  (void**)&pValues);
  866.     AddToValues(pValues, PropName1, PropVal1, eString);
  867.     AddToValues(pValues, PropName2, PropVal2, eString);
  868.     AddToValues(pValues, PropName3, PropVal3, eString);
  869.     retVal = FindPluginUsingValues( pValues, pIUnkResult, pIUnkOuter );
  870.     pValues->Release();
  871.     return retVal;
  872. }
  875. //
  876. // Call Unload() on each plugins (library unloads only if no plugin references)
  877. //
  878. void
  879. HXPluginManager::UnloadDeadDLLs()
  880. {
  881.     DPRINTF(D_INFO, ("HXPluginManager()::UnloadDeadDLLs()n"));
  882.     
  883.     for(CHXSimpleList::Iterator iter = m_pluginDlls.Begin(); iter != m_pluginDlls.End(); ++iter)
  884.     {
  885. HXPluginDLL* pPlugDLL = (HXPluginDLL*) *iter;
  886. pPlugDLL->Unload();
  887.     }
  888. }
  891. STDMETHODIMP
  892. HXPluginManager::GetPlugin( ULONG32 ulIndex, REF(IUnknown*) pIUnkResult,
  893.     IUnknown* pIUnkOuter )
  894. {
  895.     if( ulIndex <= (ULONG32)(m_plugins.GetCount()-1) && m_plugins.GetCount() )
  896.     {
  897. LISTPOSITION pPos = m_plugins.FindIndex( ulIndex );
  898. if (pPos)
  899. {
  900.     HXPlugin* pPlugin = (HXPlugin*) m_plugins.GetAt( pPos );
  901.     if( pPlugin )
  902.     {
  903. return pPlugin->GetInstance( pIUnkResult, pIUnkOuter );
  904.     }
  905. }
  906.     }
  907.     return HXR_FAIL;
  909. }
  912. STDMETHODIMP
  913. HXPluginManager::UnloadPluginFromClassID(REFGUID GUIDClassID)
  914. {
  915.     return HXR_NOTIMPL;
  916. }
  918. STDMETHODIMP
  919. HXPluginManager::UnloadPackageByName(const char* pName)
  920. {
  921.     return HXR_NOTIMPL;
  922. }
  926. STDMETHODIMP HXPluginManager::FindPluginUsingStrings (char* PropName1,
  927.     char* PropVal1,
  928.     char* PropName2,
  929.     char* PropVal2,
  930.     char* PropName3,
  931.     char* PropVal3,
  932.     REF(IUnknown*) pRetUnk)
  933. {
  934.     return FindPluginUsingStrings( PropName1, PropVal1, PropName2, PropVal2,
  935.    PropName3, PropVal3, pRetUnk, NULL );
  936. }
  939. STDMETHODIMP
  940. HXPluginManager::FindImplementationFromClassID
  941. (
  942.     REFGUID GUIDClassID,
  943.     REF(IUnknown*) pIUnknownInstance
  944. )
  945. {
  946.     return FindImplementationFromClassID( GUIDClassID, pIUnknownInstance, NULL, m_pContext );
  947. }
  949. STDMETHODIMP HXPluginManager::Close()
  950. {
  951.     DPRINTF(D_INFO, ("HXPluginManager()::Close()n"));
  953.     // Release all dlls and associated plugins
  954.    
  955.     CHXSimpleList::Iterator iter;
  956.        
  957.     //HXPlugin
  958.     for(iter = m_plugins.Begin(); iter != m_plugins.End(); ++iter)
  959.     {
  960. HXPlugin* pPlugin = (HXPlugin*) *iter;
  961. pPlugin->Release();
  962.     }
  963.     m_plugins.RemoveAll();
  964.  
  965.     //HXPluginDLL
  966.     for(iter = m_pluginDlls.Begin(); iter != m_pluginDlls.End(); ++iter)
  967.     {
  968. HXPluginDLL* pLib = (HXPluginDLL*) *iter;
  969. pLib->Release();
  970.     }
  971.     m_pluginDlls.RemoveAll();
  973.     //HXOtherDLL
  974.     for(iter = m_otherDlls.Begin(); iter != m_otherDlls.End(); ++iter)
  975.     {
  976. HXOtherDLL* pLib = (HXOtherDLL*) *iter;
  977. pLib->Release();
  978.     }
  979.     m_otherDlls.RemoveAll();
  981.     m_mountPoints.RemoveAll();
  983.     HX_RELEASE(m_pContext);
  984.     HX_RELEASE(m_pClassFactory);
  986.     return HXR_OK;
  987. }
  989. STDMETHODIMP HXPluginManager::SetRequiredPlugins (const char** ppszRequiredPlugins)
  990. {
  991.     return HXR_OK;
  992. }
  995. HX_RESULT HXPluginManager::AddToValues(IHXValues* pValues, char* pPropName, char* pPropVal, eValueTypes eValueType)
  996. {
  997.     if (!pPropName || !pPropVal)
  998. return HXR_FAIL;
  1000.     // trim value
  1001.     CHXString theValue = (pPropVal);
  1002.     theValue.TrimLeft();
  1003.     theValue.TrimRight();
  1005.     HX_RESULT hr = HXR_OK;
  1006.     switch (eValueType)
  1007.     {
  1008. case eString:
  1009. {
  1010.     IHXBuffer* pBuffer;
  1011.     CHXBuffer* pCHXBuffer;
  1012.     pCHXBuffer = new CHXBuffer;
  1013.     pCHXBuffer->QueryInterface(IID_IHXBuffer, (void**) &pBuffer);
  1014.     pBuffer->Set((const unsigned char*)(const char*)theValue, strlen(theValue)+1);
  1015.     pValues->SetPropertyCString(pPropName, pBuffer);
  1016.     pBuffer->Release();
  1017.             break;
  1018. }
  1019. case eInt:
  1020. {
  1021.     int val = atoi(theValue);
  1022.     pValues->SetPropertyULONG32(pPropName, (ULONG32)val);
  1023.     break;
  1024. }
  1025.         default:
  1026.             hr = HXR_NOTIMPL;
  1027.             break;
  1028.     }
  1029.     return hr;
  1030. }
  1032. STDMETHODIMP_(ULONG32) HXPluginManager::GetNumOfPlugins()
  1033. {
  1034.     return m_plugins.GetCount();
  1035. }
  1037. STDMETHODIMP HXPluginManager::GetPlugin(ULONG32 ulIndex, REF(IUnknown*)  /*OUT*/ pInstance)
  1038. {
  1039.     return GetPlugin( ulIndex, pInstance, NULL );
  1040. }
  1043. STDMETHODIMP HXPluginManager::FlushCache()
  1044. {
  1045.     return HXR_OK;
  1046. }
  1048. STDMETHODIMP HXPluginManager::SetCacheSize(ULONG32 nSizeKB)
  1049. {
  1050.     return HXR_OK;
  1051. }
  1053. STDMETHODIMP HXPluginManager::ReadFromRegistry()
  1054. {
  1055.     DPRINTF(D_INFO, ("HXPluginManager()::ReadFromRegistry()n"));
  1056.     HX_RESULT result;
  1057.     IHXBuffer* pBuffer = NULL;
  1059. #if !defined(_STATICALLY_LINKED) || defined(HELIX_CONFIG_CONSOLIDATED_CORE)
  1061.     const char* pPath = GetDLLAccessPath()->GetPath(DLLTYPE_PLUGIN);
  1062.     pBuffer = HXBufferUtil::CreateBuffer(m_pClassFactory, pPath);
  1063. #endif
  1065.     // Set up a mount point with the default plugin location
  1066.     result = AddPluginMountPoint(HXVER_SDK_PRODUCT, 0, 0, pBuffer);
  1068.     HX_RELEASE(pBuffer);
  1070.     return result;
  1071. }
  1074. /********************************************************************
  1075. *
  1076. * Plugin Enumeration
  1077. *
  1078. ********************************************************************/
  1080. BEGIN_INTERFACE_LIST_NOCREATE( HXPluginEnumerator )
  1081.     INTERFACE_LIST_ENTRY_SIMPLE( IHXPluginSearchEnumerator )
  1082. END_INTERFACE_LIST
  1084. HXPluginEnumerator::HXPluginEnumerator() :
  1085.     m_nIndex(0)
  1086. {
  1087. }
  1089. HXPluginEnumerator::~HXPluginEnumerator()
  1090. {
  1091. }
  1094. STDMETHODIMP_( UINT32 )
  1095. HXPluginEnumerator::GetNumPlugins()
  1096. {
  1097.     return m_plugins.GetCount();
  1098. }
  1100. STDMETHODIMP_( void )
  1101. HXPluginEnumerator::GoHead()
  1102. {
  1103.     m_nIndex = 0;
  1104. }
  1107. STDMETHODIMP
  1108. HXPluginEnumerator::GetNextPlugin( REF(IUnknown*) pIUnkResult, IUnknown* pIUnkOuter )
  1109. {
  1110.     // Initialize out params
  1111.     pIUnkResult = NULL;
  1113.     HX_RESULT res = GetPluginAt( m_nIndex, pIUnkResult, pIUnkOuter );
  1114.     m_nIndex++;
  1116.     return res;
  1117. }
  1119. STDMETHODIMP
  1120. HXPluginEnumerator::GetNextPluginInfo( REF(IHXValues*) pRetValues )
  1121. {
  1122.     pRetValues = NULL;
  1124.     HX_RESULT res = GetPluginInfoAt( m_nIndex, pRetValues );
  1125.     m_nIndex++;
  1127.     return res;
  1128. }
  1131. STDMETHODIMP
  1132. HXPluginEnumerator::GetPluginAt( UINT32 index, REF(IUnknown*) pIUnkResult, IUnknown* pIUnkOuter )
  1133. {
  1134.     pIUnkResult = NULL;
  1136.     HX_RESULT res = HXR_FAIL;
  1138.     LISTPOSITION pos = m_plugins.FindIndex(index);
  1139.     if (pos)
  1140.     {
  1141. HXPlugin* pPlugin = (HXPlugin*) m_plugins.GetAt(pos);
  1142. if (pPlugin)
  1143. {
  1144.     res = pPlugin->GetInstance( pIUnkResult, pIUnkOuter );
  1145. }
  1146.     }
  1147.     return res;
  1148. }
  1151. STDMETHODIMP
  1152. HXPluginEnumerator::GetPluginInfoAt( UINT32 index, REF(IHXValues*) pRetValues )
  1153. {
  1154.     // Initialize out params
  1155.     pRetValues = NULL;
  1157.     HX_RESULT res = HXR_FAIL;
  1159.     LISTPOSITION pos = m_plugins.FindIndex(m_nIndex);
  1160.     m_nIndex++;
  1161.     if (pos)
  1162.     {
  1163. HXPlugin* pPlugin = (HXPlugin*) m_plugins.GetAt(pos);
  1164. if (pPlugin)
  1165. {
  1166.     res = pPlugin->GetPluginInfo( pRetValues );
  1167. }
  1168.     }
  1170.     return res;
  1171. }
  1174. void HXPluginEnumerator::Add(HXPlugin* pPlugin)
  1175. {
  1176.     HX_ASSERT(pPlugin);
  1177.     m_plugins.AddTail(pPlugin);
  1178. }