305 lines
10 KiB
C++
305 lines
10 KiB
C++
#ifndef _NULLSOFT_WINAMP_DEVICES_DEVICE_MANAGER_INTERFACE_HEADER
|
|
#define _NULLSOFT_WINAMP_DEVICES_DEVICE_MANAGER_INTERFACE_HEADER
|
|
|
|
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
|
#pragma once
|
|
#endif
|
|
|
|
#include <bfc/platform/guid.h>
|
|
|
|
// {CB360A8F-0636-4a0d-9374-3BBCC18C8B40}
|
|
static const GUID DeviceManagerGUID =
|
|
{ 0xcb360a8f, 0x636, 0x4a0d, { 0x93, 0x74, 0x3b, 0xbc, 0xc1, 0x8c, 0x8b, 0x40 } };
|
|
|
|
|
|
#include <bfc/dispatch.h>
|
|
#include "ifc_device.h"
|
|
#include "ifc_deviceobjectenum.h"
|
|
#include "ifc_devicetype.h"
|
|
#include "ifc_devicetypeeditor.h"
|
|
#include "ifc_devicecommand.h"
|
|
#include "ifc_devicecommandeditor.h"
|
|
#include "ifc_deviceconnection.h"
|
|
#include "ifc_deviceconnectioneditor.h"
|
|
#include "ifc_devicemanagerevent.h"
|
|
#include "ifc_deviceprovider.h"
|
|
#include "ifc_deviceeventmanager.h"
|
|
#include "ifc_devicesupportedcommand.h"
|
|
#include "ifc_devicesupportedcommandstore.h"
|
|
#include "ifc_devicesupportedcommandenum.h"
|
|
#include "ifc_deviceiconstore.h"
|
|
#include "ifc_deviceactivity.h"
|
|
|
|
typedef ifc_devicetype *(_cdecl *DeviceTypeCreator)(const char * /*name*/, void * /*user*/);
|
|
typedef ifc_devicecommand *(_cdecl *DeviceCommandCreator)(const char * /*name*/, void * /*user*/);
|
|
typedef ifc_deviceconnection *(_cdecl *DeviceConnectionCreator)(const char * /*name*/, void * /*user*/);
|
|
|
|
|
|
// supports AddRef(), Release(), QueryInterface()
|
|
class __declspec(novtable) api_devicemanager : public Dispatchable
|
|
{
|
|
protected:
|
|
api_devicemanager() {}
|
|
~api_devicemanager() {}
|
|
|
|
public:
|
|
|
|
/* types */
|
|
size_t TypeRegister(ifc_devicetype **types, size_t count); // return number of registered types
|
|
size_t TypeRegisterIndirect(const char **names, size_t count, DeviceTypeCreator callback, void *user);
|
|
HRESULT TypeUnregister(const char *name);
|
|
HRESULT TypeFind(const char *name, ifc_devicetype **type);
|
|
HRESULT TypeEnumerate(ifc_deviceobjectenum **enumerator);
|
|
|
|
/* connections */
|
|
size_t ConnectionRegister(ifc_deviceconnection **connections, size_t count);
|
|
size_t ConnectionRegisterIndirect(const char **names, size_t count, DeviceConnectionCreator callback, void *user);
|
|
HRESULT ConnectionUnregister(const char *name);
|
|
HRESULT ConnectionFind(const char *name, ifc_deviceconnection **connection);
|
|
HRESULT ConnectionEnumerate(ifc_deviceobjectenum **enumerator);
|
|
|
|
/* commmands */
|
|
size_t CommandRegister(ifc_devicecommand **commands, size_t count);
|
|
size_t CommandRegisterIndirect(const char **names, size_t count, DeviceCommandCreator callback, void *user);
|
|
HRESULT CommandUnregister(const char *name);
|
|
HRESULT CommandFind(const char *name, ifc_devicecommand **command);
|
|
HRESULT CommandEnumerate(ifc_deviceobjectenum **enumerator);
|
|
|
|
/* devices */
|
|
size_t DeviceRegister(ifc_device **devices, size_t count);
|
|
HRESULT DeviceUnregister(const char *name);
|
|
HRESULT DeviceFind(const char *name, ifc_device **device);
|
|
HRESULT DeviceEnumerate(ifc_deviceobjectenum **enumerator);
|
|
|
|
/* discovery */
|
|
HRESULT IsDiscoveryActive();
|
|
HRESULT BeginDiscovery();
|
|
HRESULT CancelDiscovery();
|
|
HRESULT RegisterProvider(ifc_deviceprovider *provider);
|
|
HRESULT UnregisterProvider(ifc_deviceprovider *provider);
|
|
HRESULT SetProviderActive(ifc_deviceprovider *provider, BOOL activeState);
|
|
|
|
/* events */
|
|
HRESULT Advise(ifc_devicemanagerevent *handler);
|
|
HRESULT Unadvise(ifc_devicemanagerevent *handler);
|
|
|
|
/* misc helpers */
|
|
HRESULT CreateDeviceEventManager(ifc_deviceeventmanager **eventManager);
|
|
HRESULT CreateSupportedCommandStore(ifc_devicesupportedcommandstore **store);
|
|
HRESULT CreateSupportedCommandEnum(ifc_devicesupportedcommand **commands, size_t count, ifc_devicesupportedcommandenum **enumerator);
|
|
HRESULT CreateIconStore(ifc_deviceiconstore **store);
|
|
HRESULT CreateType(const char *name, ifc_devicetype **type);
|
|
HRESULT CreateCommand(const char *name, ifc_devicecommand **command);
|
|
HRESULT CreateConnection(const char *name, ifc_deviceconnection **connection);
|
|
|
|
public:
|
|
DISPATCH_CODES
|
|
{
|
|
API_TYPEREGISTER = 10,
|
|
API_TYPEREGISTERINDIRECT = 20,
|
|
API_TYPEUNREGISTER = 30,
|
|
API_TYPEFIND = 40,
|
|
API_TYPEENUMERATE = 50,
|
|
API_CONNECTIONREGISTER = 60,
|
|
API_CONNECTIONREGISTERINDIRECT = 70,
|
|
API_CONNECTIONUNREGISTER = 80,
|
|
API_CONNECTIONFIND = 90,
|
|
API_CONNECTIONENUMERATE = 100,
|
|
API_COMMANDREGISTER = 110,
|
|
API_COMMANDREGISTERINDIRECT = 120,
|
|
API_COMMANDUNREGISTER = 130,
|
|
API_COMMANDFIND = 140,
|
|
API_COMMANDENUMERATE = 150,
|
|
API_DEVICEREGISTER = 160,
|
|
API_DEVICEUNREGISTER = 170,
|
|
API_DEVICEFIND = 180,
|
|
API_DEVICEENUMERATE = 190,
|
|
API_ISDISCOVERYACTIVE = 200,
|
|
API_BEGINDISCOVERY = 210,
|
|
API_CANCELDISCOVERY = 220,
|
|
API_REGISTERPROVIDER = 230,
|
|
API_UNREGISTERPROVIDER = 240,
|
|
API_SETPROVIDERACTIVE = 250,
|
|
API_ADVISE = 260,
|
|
API_UNADVISE = 270,
|
|
API_CREATEDEVICEEVENTMANAGER = 400,
|
|
API_CREATESUPPORTEDCOMMANDSTORE = 410,
|
|
API_CREATESUPPORTEDCOMMANDENUM = 420,
|
|
API_CREATEICONSTORE = 430,
|
|
API_CREATETYPE = 440,
|
|
API_CREATECOMMAND = 450,
|
|
API_CREATECONNECTION = 460,
|
|
};
|
|
};
|
|
|
|
inline size_t api_devicemanager::TypeRegister(ifc_devicetype **types, size_t count)
|
|
{
|
|
return _call(API_TYPEREGISTER, (size_t)0, types, count);
|
|
}
|
|
|
|
inline size_t api_devicemanager::TypeRegisterIndirect(const char **names, size_t count, DeviceTypeCreator callback, void *user)
|
|
{
|
|
return _call(API_TYPEREGISTERINDIRECT, (size_t)0, names, count, callback, user);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::TypeUnregister(const char *name)
|
|
{
|
|
return _call(API_TYPEUNREGISTER, (HRESULT)E_NOTIMPL, name);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::TypeFind(const char *name, ifc_devicetype **type)
|
|
{
|
|
return _call(API_TYPEFIND, (HRESULT)E_NOTIMPL, name, type);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::TypeEnumerate(ifc_deviceobjectenum **enumerator)
|
|
{
|
|
return _call(API_TYPEENUMERATE, (HRESULT)E_NOTIMPL, enumerator);
|
|
}
|
|
|
|
inline size_t api_devicemanager::ConnectionRegister(ifc_deviceconnection **connections, size_t count)
|
|
{
|
|
return _call(API_CONNECTIONREGISTER, (size_t)0, connections, count);
|
|
}
|
|
|
|
inline size_t api_devicemanager::ConnectionRegisterIndirect(const char **names, size_t count, DeviceConnectionCreator callback, void *user)
|
|
{
|
|
return _call(API_CONNECTIONREGISTERINDIRECT, (size_t)0, names, count, callback, user);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::ConnectionUnregister(const char *name)
|
|
{
|
|
return _call(API_CONNECTIONUNREGISTER, (HRESULT)E_NOTIMPL, name);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::ConnectionFind(const char *name, ifc_deviceconnection **connection)
|
|
{
|
|
return _call(API_CONNECTIONFIND, (HRESULT)E_NOTIMPL, name, connection);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::ConnectionEnumerate(ifc_deviceobjectenum **enumerator)
|
|
{
|
|
return _call(API_CONNECTIONENUMERATE, (HRESULT)E_NOTIMPL, enumerator);
|
|
}
|
|
|
|
inline size_t api_devicemanager::CommandRegister(ifc_devicecommand **commands, size_t count)
|
|
{
|
|
return _call(API_COMMANDREGISTER, (size_t)0, commands, count);
|
|
}
|
|
|
|
inline size_t api_devicemanager::CommandRegisterIndirect(const char **names, size_t count, DeviceCommandCreator callback, void *user)
|
|
{
|
|
return _call(API_COMMANDREGISTERINDIRECT, (size_t)0, names, count, callback, user);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::CommandUnregister(const char *name)
|
|
{
|
|
return _call(API_COMMANDUNREGISTER, (HRESULT)E_NOTIMPL, name);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::CommandFind(const char *name, ifc_devicecommand **command)
|
|
{
|
|
return _call(API_COMMANDFIND, (HRESULT)E_NOTIMPL, name, command);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::CommandEnumerate(ifc_deviceobjectenum **enumerator)
|
|
{
|
|
return _call(API_COMMANDENUMERATE, (HRESULT)E_NOTIMPL, enumerator);
|
|
}
|
|
|
|
inline size_t api_devicemanager::DeviceRegister(ifc_device **devices, size_t count)
|
|
{
|
|
return _call(API_DEVICEREGISTER, (size_t)0, devices, count);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::DeviceUnregister(const char *name)
|
|
{
|
|
return _call(API_DEVICEUNREGISTER, (HRESULT)E_NOTIMPL, name);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::DeviceFind(const char *name, ifc_device **device)
|
|
{
|
|
return _call(API_DEVICEFIND, (HRESULT)E_NOTIMPL, name, device);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::DeviceEnumerate(ifc_deviceobjectenum **enumerator)
|
|
{
|
|
return _call(API_DEVICEENUMERATE, (HRESULT)E_NOTIMPL, enumerator);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::IsDiscoveryActive()
|
|
{
|
|
return _call(API_ISDISCOVERYACTIVE, (HRESULT)E_NOTIMPL);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::BeginDiscovery()
|
|
{
|
|
return _call(API_BEGINDISCOVERY, (HRESULT)E_NOTIMPL);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::CancelDiscovery()
|
|
{
|
|
return _call(API_CANCELDISCOVERY, (HRESULT)E_NOTIMPL);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::RegisterProvider(ifc_deviceprovider *provider)
|
|
{
|
|
return _call(API_REGISTERPROVIDER, (HRESULT)E_NOTIMPL, provider);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::UnregisterProvider(ifc_deviceprovider *provider)
|
|
{
|
|
return _call(API_UNREGISTERPROVIDER, (HRESULT)E_NOTIMPL, provider);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::SetProviderActive(ifc_deviceprovider *provider, BOOL activeState)
|
|
{
|
|
return _call(API_SETPROVIDERACTIVE, (HRESULT)E_NOTIMPL, provider, activeState);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::Advise(ifc_devicemanagerevent *handler)
|
|
{
|
|
return _call(API_ADVISE, (HRESULT)E_NOTIMPL, handler);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::Unadvise(ifc_devicemanagerevent *handler)
|
|
{
|
|
return _call(API_UNADVISE, (HRESULT)E_NOTIMPL, handler);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::CreateDeviceEventManager(ifc_deviceeventmanager **eventManager)
|
|
{
|
|
return _call(API_CREATEDEVICEEVENTMANAGER, (HRESULT)E_NOTIMPL, eventManager);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::CreateSupportedCommandStore(ifc_devicesupportedcommandstore **store)
|
|
{
|
|
return _call(API_CREATESUPPORTEDCOMMANDSTORE, (HRESULT)E_NOTIMPL, store);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::CreateSupportedCommandEnum(ifc_devicesupportedcommand **commands, size_t count, ifc_devicesupportedcommandenum **enumerator)
|
|
{
|
|
return _call(API_CREATESUPPORTEDCOMMANDENUM, (HRESULT)E_NOTIMPL, commands, count, enumerator);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::CreateIconStore(ifc_deviceiconstore **store)
|
|
{
|
|
return _call(API_CREATEICONSTORE, (HRESULT)E_NOTIMPL, store);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::CreateType(const char *name, ifc_devicetype **type)
|
|
{
|
|
return _call(API_CREATETYPE, (HRESULT)E_NOTIMPL, name, type);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::CreateCommand(const char *name, ifc_devicecommand **command)
|
|
{
|
|
return _call(API_CREATECOMMAND, (HRESULT)E_NOTIMPL, name, command);
|
|
}
|
|
|
|
inline HRESULT api_devicemanager::CreateConnection(const char *name, ifc_deviceconnection **connection)
|
|
{
|
|
return _call(API_CREATECONNECTION, (HRESULT)E_NOTIMPL, name, connection);
|
|
}
|
|
|
|
#endif //_NULLSOFT_WINAMP_DEVICES_DEVICE_MANAGER_INTERFACE_HEADER
|