av_upnp.h

Windows CE 6.0 Server 源码

    void    InitDISPIDs();

    HRESULT generic_get_ProtocolInfo(BSTR* pSource, BSTR* pSink);
};


class ContentDirectoryServiceImpl :
    public IUPnPService_ContentDirectory1,
    public ModeratedEventSupport,
    public IEventSinkSupport
{
public:
    ContentDirectoryServiceImpl();
    virtual ~ContentDirectoryServiceImpl();

    // Init() must be called before using this class
    DWORD Init(/* [in] */ IContentDirectory* pContentDirectory);
    
// IEventSink
public:
    virtual DWORD OnStateChanged(
        /*[in]*/ LPCWSTR pszStateVariableName,
        /*[in*/  LPCWSTR pszValue);
        
    virtual DWORD OnStateChanged(
        /*[in]*/ LPCWSTR pszStateVariableName,
        /*[in*/  long nValue);

    virtual DWORD OnStateChanged(
        /*[in]*/  LPCWSTR pszStateVariableName,
        /*[in]*/  LPCWSTR pszChannel,
        /*[in]*/  long nValue);

// TimedEventCallee
public:
    virtual void TimedEventCall();

// IUPnPService_ContentDirectory1
public:
    STDMETHOD(get_TransferIDs)(BSTR* pTransferIDs);

    STDMETHOD(get_A_ARG_TYPE_ObjectID)(BSTR* pA_ARG_TYPE_ObjectID);
    STDMETHOD(get_A_ARG_TYPE_Result)(BSTR* pA_ARG_TYPE_Result);
    STDMETHOD(get_A_ARG_TYPE_SearchCriteria)(BSTR* pA_ARG_TYPE_SearchCriteria);
    STDMETHOD(get_A_ARG_TYPE_BrowseFlag)(BSTR* pA_ARG_TYPE_BrowseFlag);
    STDMETHOD(get_A_ARG_TYPE_Filter)(BSTR* pA_ARG_TYPE_Filter);
    STDMETHOD(get_A_ARG_TYPE_SortCriteria)(BSTR* pA_ARG_TYPE_SortCriteria);
    STDMETHOD(get_A_ARG_TYPE_Index)(unsigned long* pA_ARG_TYPE_Index);
    STDMETHOD(get_A_ARG_TYPE_Count)(unsigned long* pA_ARG_TYPE_Count);
    STDMETHOD(get_A_ARG_TYPE_UpdateID)(unsigned long* pA_ARG_TYPE_UpdateID);
    STDMETHOD(get_A_ARG_TYPE_TransferID)(unsigned long* pA_ARG_TYPE_TransferID);
    STDMETHOD(get_A_ARG_TYPE_TransferStatus)(BSTR* pA_ARG_TYPE_TransferStatus);
    STDMETHOD(get_A_ARG_TYPE_TransferLength)(BSTR* pA_ARG_TYPE_TransferLength);
    STDMETHOD(get_A_ARG_TYPE_TransferTotal)(BSTR* pA_ARG_TYPE_TransferTotal);
    STDMETHOD(get_A_ARG_TYPE_TagValueList)(BSTR* pA_ARG_TYPE_TagValueList);
    STDMETHOD(get_A_ARG_TYPE_URI)(BSTR* pA_ARG_TYPE_URI);

    STDMETHOD(get_SearchCapabilities)(BSTR* pSearchCapabilities);
    STDMETHOD(get_SortCapabilities)(BSTR* pSortCapabilities);
    STDMETHOD(get_SystemUpdateID)(unsigned long* pSystemUpdateID);
    STDMETHOD(get_ContainerUpdateIDs)(BSTR* pContainerUpdateIDs);

    STDMETHOD(GetSearchCapabilities)(BSTR* pSearchCaps);
    STDMETHOD(GetSortCapabilities)(BSTR* pSortCaps);
    STDMETHOD(GetSystemUpdateID)(unsigned long* pId);
    STDMETHOD(Browse)(BSTR          ObjectID,
                      BSTR          BrowseFlag,
                      BSTR          Filter,
                      unsigned long StartingIndex,
                      unsigned long RequestedCount,
                      BSTR          SortCriteria,
                      BSTR*          pResult,
                      unsigned long* pNumberReturned,
                      unsigned long* pTotalMatches,
                      unsigned long* pUpdateID);
    STDMETHOD(Search)(BSTR          ContainerID,
                      BSTR          SearchCriteria,
                      BSTR          Filter,
                      unsigned long StartingIndex,
                      unsigned long RequestedCount,
                      BSTR          SortCriteria,
                      BSTR*          pResult,
                      unsigned long* pNumberReturned,
                      unsigned long* pTotalMatches,
                      unsigned long* pUpdateID);
    STDMETHOD(CreateObject)(BSTR ContainerID,
                            BSTR Elements,
                            BSTR* pObjectID,
                            BSTR* pResult);
    STDMETHOD(DestroyObject)(BSTR ObjectID);
    STDMETHOD(UpdateObject)(BSTR ObjectID,
                            BSTR CurrentTagValue,
                            BSTR NewTagValue);
    STDMETHOD(ImportResource)(BSTR SourceURI,
                              BSTR DestinationURI,
                              unsigned long* pTransferID);
    STDMETHOD(ExportResource)(BSTR SourceURI,
                              BSTR DestinationURI,
                              unsigned long* pTransferID);
    STDMETHOD(StopTransferResource)(unsigned long TransferID);
    STDMETHOD(GetTransferProgress)(unsigned long TransferID,
                                   BSTR* pTransferStatus,
                                   BSTR* pTransferLength,
                                   BSTR* pTransferTotal);
    STDMETHOD(DeleteResource)(BSTR ResourceURI);
    STDMETHOD(CreateReference)(BSTR ContainerID,
                               BSTR ObjectID,
                               BSTR* pNewID);

protected:
    virtual DWORD InvokeVendorAction(
        /* [in] */ LPCWSTR pszActionName,
        /* [in] */ DISPPARAMS* pdispparams, 
        /* [in, out] */ VARIANT* pvarResult);

protected:
    IContentDirectory*      m_pContentDirectory;
    UPnPErrorReporting      m_ErrReport;

private:
    HRESULT InitErrDescrips();
    HRESULT InitToolkitErrs();
    void    InitDISPIDs();

    typedef ce::hash_map<wstring, wstring> ContainerUpdateIDsMap;
        
    ce::critical_section    m_csEvents;
    wstring                 m_strTransferIDs;
    bool                    m_bSystemUpdateIDChanged;
    ContainerUpdateIDsMap   m_mapContainerUpdateIDs;
};


//
// IDispatchVendorActionsImpl
//
template <class T, const IID* piid, const GUID* plibid, WORD wMajor = 1, WORD wMinor = 0, class tihclass = CComTypeInfoHolder>
class ATL_NO_VTABLE IDispatchVendorActionsImpl : public IDispatchImpl<T, piid, plibid, wMajor, wMinor, tihclass>
{
    typedef IDispatchImpl<T, piid, plibid, wMajor, wMinor, tihclass> _Mybase;
    
    static const DISPID nVendorActionDispidBase = 0x10000000;
    
public:
    // GetIDsOfNames
    STDMETHOD(GetIDsOfNames)(REFIID riid, LPOLESTR* rgszNames, UINT cNames,
		                     LCID lcid, DISPID* rgdispid)
	{
		HRESULT hr = _Mybase::GetIDsOfNames(riid, rgszNames, cNames, lcid, rgdispid);
		
		if(DISP_E_MEMBERNOTFOUND == hr || DISP_E_UNKNOWNNAME == hr)
		{
		    // Only support query for action name, not named parameters
		    assert(cNames == 1);
		    
		    // Look for action with given name
		    for(unsigned i = 0; i < m_VendorActions.size(); ++i)
		        if(m_VendorActions[i] == *rgszNames)
		        {
		            rgdispid[0] = i + nVendorActionDispidBase;
		            return S_OK;
		        }
		    
		    //
		    // Add the action to the array of vendor actions.
		    // Note that UPnP host will only call GetIDsOfNames for
		    // actions that are in the service description so there is 
		    // no danger of growing m_VendorActions array indefinitly.
		    //
		    if(m_VendorActions.push_back(*rgszNames))
		    {
		        rgdispid[0] = i + nVendorActionDispidBase;
		        return S_OK;
		    }
		    else
		        return E_OUTOFMEMORY;
		}
		
		return hr;
	}
    
    // Invoke
    STDMETHOD(Invoke)(DISPID dispidMember, REFIID riid,
		              LCID lcid, WORD wFlags, DISPPARAMS* pdispparams, VARIANT* pvarResult,
		              EXCEPINFO* pexcepinfo, UINT* puArgErr)
	{
		if(dispidMember >= nVendorActionDispidBase)
		{
		    assert((DISPID)m_VendorActions.size() > dispidMember - nVendorActionDispidBase);
		    
		    // Invoke vendor action by name
		    DWORD dw = InvokeVendorAction(m_VendorActions[dispidMember - nVendorActionDispidBase], pdispparams, pvarResult);
		    
		    if(SUCCESS_AV != dw)
		    {
		        CComPtr<IErrorInfo> pErrorInfo;
		        HRESULT             hr = m_ErrReport.ReportError(dw);
    		    
		        // Fill pexcepinfo if the action failed
		        GetErrorInfo(0, &pErrorInfo);
    		    
		        if(pErrorInfo)
		        {
		            pErrorInfo->GetDescription(&pexcepinfo->bstrDescription);
		            pErrorInfo->GetSource(&pexcepinfo->bstrSource);
		        }
		    }
		    
		    return S_OK;
		}
		else
		    return _Mybase::Invoke(dispidMember, riid, lcid,
		                           wFlags, pdispparams, pvarResult, pexcepinfo, puArgErr);
	}
	
protected:
    ce::vector<ce::wistring> m_VendorActions;
};


//
// COM classes implementing UPnP services
//

class ATL_NO_VTABLE AVTransportService :
    public CComObjectRootEx<CComMultiThreadModel>,
    public IDispatchVendorActionsImpl<AVTransportServiceImpl, 
                         &IID_IUPnPService_AVTransport1, 
                         &LIBID_UPNPAVTOOLKITlib>
{
    BEGIN_COM_MAP(AVTransportService)
        COM_INTERFACE_ENTRY(IUPnPService_AVTransport1)
        COM_INTERFACE_ENTRY(IDispatch)
        COM_INTERFACE_ENTRY(IUPnPEventSource)
    END_COM_MAP()
};

class ATL_NO_VTABLE RenderingControlService :
    public CComObjectRootEx<CComMultiThreadModel>,
    public IDispatchVendorActionsImpl<RenderingControlServiceImpl,
                         &IID_IUPnPService_RenderingControl1,
                         &LIBID_UPNPAVTOOLKITlib>
{
    BEGIN_COM_MAP(RenderingControlService)
        COM_INTERFACE_ENTRY(IUPnPService_RenderingControl1)
        COM_INTERFACE_ENTRY(IDispatch)
        COM_INTERFACE_ENTRY(IUPnPEventSource)
    END_COM_MAP()
};

class ATL_NO_VTABLE ConnectionManagerService :
    public CComObjectRootEx<CComMultiThreadModel>,
    public IDispatchVendorActionsImpl<ConnectionManagerServiceImpl,
                         &IID_IUPnPService_ConnectionManager1, 
                         &LIBID_UPNPAVTOOLKITlib>
{   
    BEGIN_COM_MAP(ConnectionManagerService)
        COM_INTERFACE_ENTRY(IUPnPService_ConnectionManager1)
        COM_INTERFACE_ENTRY(IDispatch)
        COM_INTERFACE_ENTRY(IUPnPEventSource)
    END_COM_MAP()
};



class ATL_NO_VTABLE ContentDirectoryService :
    public CComObjectRootEx<CComMultiThreadModel>,
    public IDispatchVendorActionsImpl<ContentDirectoryServiceImpl,
                         &IID_IUPnPService_ContentDirectory1, 
                         &LIBID_UPNPAVTOOLKITlib>
{
    BEGIN_COM_MAP(ContentDirectoryService)
        COM_INTERFACE_ENTRY(IUPnPService_ContentDirectory1)
        COM_INTERFACE_ENTRY(IDispatch)
        COM_INTERFACE_ENTRY(IUPnPEventSource)
    END_COM_MAP()
};


// Forward declarations for MediaRendererDevice and MediaServerDevice
namespace details
{
    class ConnectionManagerCtrl;
    class ContentDirectoryCtrl;
};


//
// MediaRendererDevice
//
class MediaRendererDevice
{
public:
    MediaRendererDevice(IUPnPDevice* pDevice);
    ~MediaRendererDevice();

    DWORD GetConnectionManager(
            IConnectionManager** ppConnectionManager,
            wstring*             pstrConnectionmanager);

private:
    ce::critical_section            m_cs;
    CComPtr<IUPnPDevice>            m_pDevice;
    details::ConnectionManagerCtrl* m_pConnectionManager;
    wstring                         m_strUDN;
};


//
// MediaServerDevice
//
class MediaServerDevice
{
public:
    MediaServerDevice(IUPnPDevice* pDevice);
    ~MediaServerDevice();

    DWORD GetConnectionManager(
            IConnectionManager** ppIConnectionManager,
            wstring*             pstrIConnectionManager);

    DWORD GetContentDirectory(
            IContentDirectory** ppContentDirectory);

private:
    ce::critical_section            m_cs;
    CComPtr<IUPnPDevice>            m_pDevice;
    details::ConnectionManagerCtrl* m_pConnectionManager;
    details::ContentDirectoryCtrl*  m_pContentDirectory;
    wstring                         m_strUDN;
};

namespace DIDL_Lite
{

namespace details
{
    class properties;
    class objects;
};

//
// object
//
struct object
{
    object()
        : pProperties(NULL)
    {}
    
    //
    // true if the object is of a container class (object.container.*), 
    // false if the object is of an item class (object.item.*)
    //
    bool            bContainer;

    //
    // required object properties
    //
    wstring         strID;
    wstring         strParentID;
    wstring         strTitle;
    wstring         strClass;
    bool            bRestricted;
    
    //
    // access to optional object properties
    //
    bo