hxpluginmanager.cpp

linux下的一款播放器

STDMETHODIMP
HXPluginManager::FindPluginUsingValues( IHXValues* pCriteria,
					REF(IUnknown*) pIUnkResult,
					IUnknown* pIUnkOuter )
{
    DPRINTF(D_INFO, ("HXPluginManager()::FindPluginUsingValues()\n"));

    // out
    pIUnkResult = NULL;

    CHXSimpleList   matches;
    CHXSimpleList::Iterator iter = m_plugins.Begin();
    for(; iter != m_plugins.End(); ++iter)
    {
	HXPlugin* pPlugin = (HXPlugin*) *iter;
	if (pPlugin->DoesMatch(pCriteria))
	{
	    matches.AddTail(pPlugin);
	}
    }

    HX_RESULT hr = HXR_FAIL;

    if (matches.GetCount() > 0)
    {
        // return first match by default
        HXPlugin* pPlug = (HXPlugin*) *(matches.Begin());

#if (0)
        if (matches.GetCount() > 1)
        {
            //
            // strategy:
            //
            // with multiple matching plugins, pick first one with description "RealNetworks"
            //
	    for(iter = matches.Begin(); iter != matches.End(); ++iter)
	    {
                HXPlugin* pThisPlugin = (HXPlugin*) *iter;
                if( IsRealNetworksPlugin(pThisPlugin) )
                {
                    // use this one
                    pPlug = pThisPlugin;
                    break;
	            
                }
	    }
        }
#endif

        hr = pPlug->GetInstance( pIUnkResult, pIUnkOuter );
    }

    return hr;
}


STDMETHODIMP
HXPluginManager::FindPluginUsingStrings( char* PropName1, char* PropVal1,
					char* PropName2, char* PropVal2,
					char* PropName3, char* PropVal3,
					REF(IUnknown*) pIUnkResult,
					IUnknown* pIUnkOuter )
{
    DPRINTF(D_INFO, ("HXPluginManager()::FindPluginUsingStrings()\n"));
    
    // out 
    pIUnkResult = NULL;

    // PropName and PropVal have to to valid tuple
    if ((PropName1 && !PropVal1)    ||
	(PropName2 && !PropVal2)    ||
	(PropName3 && !PropVal3)    ||
	(!PropName1 && PropVal1)    ||
	(!PropName2 && PropVal2)    ||
	(!PropName3 && PropVal3))
	return HXR_FAIL;

    IHXValues* pValues;
    HX_RESULT   retVal = HXR_FAIL;

    CHXHeader* pHeader = new CHXHeader();
    pHeader->QueryInterface(IID_IHXValues,  (void**)&pValues);
    AddToValues(pValues, PropName1, PropVal1, eString);
    AddToValues(pValues, PropName2, PropVal2, eString);
    AddToValues(pValues, PropName3, PropVal3, eString);
    retVal = FindPluginUsingValues( pValues, pIUnkResult, pIUnkOuter );
    pValues->Release();
    return retVal;
}


//
// Call Unload() on each plugins (library unloads only if no plugin references)
//
void
HXPluginManager::UnloadDeadDLLs()
{
    DPRINTF(D_INFO, ("HXPluginManager()::UnloadDeadDLLs()\n"));
    
    for(CHXSimpleList::Iterator iter = m_pluginDlls.Begin(); iter != m_pluginDlls.End(); ++iter)
    {
	HXPluginDLL* pPlugDLL = (HXPluginDLL*) *iter;
	pPlugDLL->Unload();
    }
}


STDMETHODIMP
HXPluginManager::GetPlugin( ULONG32 ulIndex, REF(IUnknown*) pIUnkResult,
					    IUnknown* pIUnkOuter )
{
    if( ulIndex <= (ULONG32)(m_plugins.GetCount()-1) && m_plugins.GetCount() )
    {
	LISTPOSITION pPos = m_plugins.FindIndex( ulIndex );
	if (pPos)
	{
	    HXPlugin* pPlugin = (HXPlugin*) m_plugins.GetAt( pPos );
	    if( pPlugin )
	    {
		return pPlugin->GetInstance( pIUnkResult, pIUnkOuter );
	    }
	}
    }
    return HXR_FAIL;

}


STDMETHODIMP
HXPluginManager::UnloadPluginFromClassID(REFGUID GUIDClassID)
{
    return HXR_NOTIMPL;
}

STDMETHODIMP
HXPluginManager::UnloadPackageByName(const char* pName)
{
    return HXR_NOTIMPL;
}



STDMETHODIMP HXPluginManager::FindPluginUsingStrings (char* PropName1,
						    char* PropVal1,
						    char* PropName2,
						    char* PropVal2,
						    char* PropName3,
						    char* PropVal3,
						    REF(IUnknown*) pRetUnk)
{
    return FindPluginUsingStrings( PropName1, PropVal1, PropName2, PropVal2,
				   PropName3, PropVal3, pRetUnk, NULL );
}


STDMETHODIMP
HXPluginManager::FindImplementationFromClassID
(
    REFGUID GUIDClassID,
    REF(IUnknown*) pIUnknownInstance
)
{
    return FindImplementationFromClassID( GUIDClassID, pIUnknownInstance, NULL, m_pContext );
}

STDMETHODIMP HXPluginManager::Close()
{
    DPRINTF(D_INFO, ("HXPluginManager()::Close()\n"));

    // Release all dlls and associated plugins
   
    CHXSimpleList::Iterator iter;
       
    //HXPlugin
    for(iter = m_plugins.Begin(); iter != m_plugins.End(); ++iter)
    {
	HXPlugin* pPlugin = (HXPlugin*) *iter;
	pPlugin->Release();
    }
    m_plugins.RemoveAll();
 
    //HXPluginDLL
    for(iter = m_pluginDlls.Begin(); iter != m_pluginDlls.End(); ++iter)
    {
	HXPluginDLL* pLib = (HXPluginDLL*) *iter;
	pLib->Release();
    }
    m_pluginDlls.RemoveAll();

    //HXOtherDLL
    for(iter = m_otherDlls.Begin(); iter != m_otherDlls.End(); ++iter)
    {
	HXOtherDLL* pLib = (HXOtherDLL*) *iter;
	pLib->Release();
    }
    m_otherDlls.RemoveAll();

    m_mountPoints.RemoveAll();

    HX_RELEASE(m_pContext);
    HX_RELEASE(m_pClassFactory);

    return HXR_OK;
}

STDMETHODIMP HXPluginManager::SetRequiredPlugins (const char** ppszRequiredPlugins)
{
    return HXR_OK;
}


HX_RESULT HXPluginManager::AddToValues(IHXValues* pValues, char* pPropName, char* pPropVal, eValueTypes eValueType)
{
    if (!pPropName || !pPropVal)
	return HXR_FAIL;

    // trim value
    CHXString theValue = (pPropVal);
    theValue.TrimLeft();
    theValue.TrimRight();

    HX_RESULT hr = HXR_OK;
    switch (eValueType)
    {
	case eString:
	{
	    IHXBuffer* pBuffer;
	    CHXBuffer*	pCHXBuffer;
	    pCHXBuffer = new CHXBuffer;
	    pCHXBuffer->QueryInterface(IID_IHXBuffer, (void**) &pBuffer);
	    pBuffer->Set((const unsigned char*)(const char*)theValue, strlen(theValue)+1);
	    pValues->SetPropertyCString(pPropName, pBuffer);
	    pBuffer->Release();
            break;
	}
	case eInt:
	{
	    int val = atoi(theValue);
	    pValues->SetPropertyULONG32(pPropName, (ULONG32)val);
	    break;
	}
        default:
            hr = HXR_NOTIMPL;
            break;
    }
    return hr;
}

STDMETHODIMP_(ULONG32) HXPluginManager::GetNumOfPlugins()
{
    return m_plugins.GetCount();
}

STDMETHODIMP HXPluginManager::GetPlugin(ULONG32 ulIndex, REF(IUnknown*)  /*OUT*/ pInstance)
{
    return GetPlugin( ulIndex, pInstance, NULL );
}


STDMETHODIMP HXPluginManager::FlushCache()
{
    return HXR_OK;
}

STDMETHODIMP HXPluginManager::SetCacheSize(ULONG32 nSizeKB)
{
    return HXR_OK;
}

STDMETHODIMP HXPluginManager::ReadFromRegistry()
{
    DPRINTF(D_INFO, ("HXPluginManager()::ReadFromRegistry()\n"));
    HX_RESULT result;
    IHXBuffer* pBuffer = NULL;

#if !defined(_STATICALLY_LINKED) || defined(HELIX_CONFIG_CONSOLIDATED_CORE)

    const char* pPath = GetDLLAccessPath()->GetPath(DLLTYPE_PLUGIN);
    pBuffer = HXBufferUtil::CreateBuffer(m_pClassFactory, pPath);
#endif

    // Set up a mount point with the default plugin location
    result = AddPluginMountPoint(HXVER_SDK_PRODUCT, 0, 0, pBuffer);

    HX_RELEASE(pBuffer);

    return result;
}


/********************************************************************
*
*	Plugin Enumeration
*
********************************************************************/

BEGIN_INTERFACE_LIST_NOCREATE( HXPluginEnumerator )
    INTERFACE_LIST_ENTRY_SIMPLE( IHXPluginSearchEnumerator )
END_INTERFACE_LIST

HXPluginEnumerator::HXPluginEnumerator() :
    m_nIndex(0)
{
}

HXPluginEnumerator::~HXPluginEnumerator()
{
}


STDMETHODIMP_( UINT32 )
HXPluginEnumerator::GetNumPlugins()
{
    return m_plugins.GetCount();
}

STDMETHODIMP_( void )
HXPluginEnumerator::GoHead()
{
    m_nIndex = 0;
}


STDMETHODIMP
HXPluginEnumerator::GetNextPlugin( REF(IUnknown*) pIUnkResult, IUnknown* pIUnkOuter )
{
    // Initialize out params
    pIUnkResult = NULL;

    HX_RESULT res = GetPluginAt( m_nIndex, pIUnkResult, pIUnkOuter );
    m_nIndex++;

    return res;
}

STDMETHODIMP
HXPluginEnumerator::GetNextPluginInfo( REF(IHXValues*) pRetValues )
{
    pRetValues = NULL;

    HX_RESULT res = GetPluginInfoAt( m_nIndex, pRetValues );
    m_nIndex++;

    return res;
}


STDMETHODIMP
HXPluginEnumerator::GetPluginAt( UINT32 index, REF(IUnknown*) pIUnkResult, IUnknown* pIUnkOuter )
{
    pIUnkResult = NULL;

    HX_RESULT res = HXR_FAIL;

    LISTPOSITION pos = m_plugins.FindIndex(index);
    if (pos)
    {
	HXPlugin* pPlugin = (HXPlugin*) m_plugins.GetAt(pos);
	if (pPlugin)
	{
	    res = pPlugin->GetInstance( pIUnkResult, pIUnkOuter );
	}
    }
    return res;
}


STDMETHODIMP
HXPluginEnumerator::GetPluginInfoAt( UINT32 index, REF(IHXValues*) pRetValues )
{
    // Initialize out params
    pRetValues = NULL;

    HX_RESULT res = HXR_FAIL;

    LISTPOSITION pos = m_plugins.FindIndex(m_nIndex);
    m_nIndex++;
    if (pos)
    {
	HXPlugin* pPlugin = (HXPlugin*) m_plugins.GetAt(pos);
	if (pPlugin)
	{
	    res = pPlugin->GetPluginInfo( pRetValues );
	}
    }

    return res;
}


void HXPluginEnumerator::Add(HXPlugin* pPlugin)
{
    HX_ASSERT(pPlugin);
    m_plugins.AddTail(pPlugin);
}