winamp/Src/devices/deviceManager.cpp

650 lines
15 KiB
C++

#include "main.h"
#include "./deviceManager.h"
#include "./deviceEventManager.h"
static void
DeviceManager_ReleaseDispatchables(Dispatchable** buffer, size_t count)
{
if(NULL == buffer)
return;
while(count--)
{
Dispatchable *object = buffer[count];
if (NULL != object)
object->Release();
}
}
DeviceManager::DeviceManager()
: ref(1),
#pragma warning(push)
#pragma warning(disable:4355)
typeStore(ObjectAddedCallback, ObjectRemovedCallback, this),
connectionStore(ObjectAddedCallback, ObjectRemovedCallback, this),
commandStore(ObjectAddedCallback, ObjectRemovedCallback, this),
deviceStore(ObjectAddedCallback, ObjectRemovedCallback, this)
#pragma warning(pop)
{
InitializeCriticalSection(&eventLock);
InitializeCriticalSection(&providerLock);
}
DeviceManager::~DeviceManager()
{
EnterCriticalSection(&providerLock);
DeviceManager_ReleaseDispatchables((Dispatchable**)(providerList.size() ? &providerList.at(0) : nullptr), providerList.size());
providerList.clear();
LeaveCriticalSection(&providerLock);
DeleteCriticalSection(&providerLock);
EnterCriticalSection(&eventLock);
DeviceManager_ReleaseDispatchables((Dispatchable**)(eventList.size() ? &eventList.at(0) : nullptr), eventList.size());
eventList.clear();
LeaveCriticalSection(&eventLock);
DeleteCriticalSection(&eventLock);
}
HRESULT DeviceManager::CreateInstance(DeviceManager **instance)
{
if (NULL == instance)
return E_POINTER;
*instance = new DeviceManager();
if (NULL == *instance)
return E_OUTOFMEMORY;
return S_OK;
}
size_t DeviceManager::AddRef()
{
return InterlockedIncrement((LONG*)&ref);
}
size_t DeviceManager::Release()
{
if (0 == ref)
return ref;
LONG r = InterlockedDecrement((LONG*)&ref);
if (0 == r)
delete(this);
return r;
}
int DeviceManager::QueryInterface(GUID interface_guid, void **object)
{
if (NULL == object) return E_POINTER;
if (IsEqualIID(interface_guid, DeviceManagerGUID))
*object = static_cast<api_devicemanager*>(this);
else
{
*object = NULL;
return E_NOINTERFACE;
}
if (NULL == *object)
return E_UNEXPECTED;
AddRef();
return S_OK;
}
size_t DeviceManager::TypeRegister(ifc_devicetype **types, size_t count)
{
return typeStore.AddRange((ifc_deviceobject**)types, count);
}
size_t DeviceManager::TypeRegisterIndirect(const char **names, size_t count, DeviceTypeCreator callback, void *user)
{
return typeStore.AddIndirect(names, count, (DeviceObjectCreator)callback, user);
}
HRESULT DeviceManager::TypeUnregister(const char *name)
{
return typeStore.Remove(name);
}
HRESULT DeviceManager::TypeFind(const char *name, ifc_devicetype **type)
{
return typeStore.Find(name, (ifc_deviceobject**)type);
}
HRESULT DeviceManager::TypeEnumerate(ifc_deviceobjectenum **enumerator)
{
return typeStore.Enumerate((DeviceObjectEnum**)enumerator);
}
size_t DeviceManager::ConnectionRegister(ifc_deviceconnection **connections, size_t count)
{
return connectionStore.AddRange((ifc_deviceobject**)connections, count);
}
size_t DeviceManager::ConnectionRegisterIndirect(const char **names, size_t count, DeviceConnectionCreator callback, void *user)
{
return connectionStore.AddIndirect(names, count, (DeviceObjectCreator)callback, user);
}
HRESULT DeviceManager::ConnectionUnregister(const char *name)
{
return connectionStore.Remove(name);
}
HRESULT DeviceManager::ConnectionFind(const char *name, ifc_deviceconnection **connection)
{
return connectionStore.Find(name, (ifc_deviceobject**)connection);
}
HRESULT DeviceManager::ConnectionEnumerate(ifc_deviceobjectenum **enumerator)
{
return connectionStore.Enumerate((DeviceObjectEnum**)enumerator);
}
size_t DeviceManager::CommandRegister(ifc_devicecommand **commands, size_t count)
{
return commandStore.AddRange((ifc_deviceobject**)commands, count);
}
size_t DeviceManager::CommandRegisterIndirect(const char **names, size_t count, DeviceCommandCreator callback, void *user)
{
return commandStore.AddIndirect(names, count, (DeviceObjectCreator)callback, user);
}
HRESULT DeviceManager::CommandUnregister(const char *name)
{
return commandStore.Remove(name);
}
HRESULT DeviceManager::CommandFind(const char *name, ifc_devicecommand **command)
{
return commandStore.Find(name, (ifc_deviceobject**)command);
}
HRESULT DeviceManager::CommandEnumerate(ifc_deviceobjectenum **enumerator)
{
return commandStore.Enumerate((DeviceObjectEnum**)enumerator);
}
size_t DeviceManager::DeviceRegister(ifc_device **devices, size_t count)
{
return deviceStore.AddRange((ifc_deviceobject**)devices, count);
}
HRESULT DeviceManager::DeviceUnregister(const char *name)
{
return deviceStore.Remove(name);
}
HRESULT DeviceManager::DeviceFind(const char *name, ifc_device **device)
{
return deviceStore.Find(name, (ifc_deviceobject**)device);
}
HRESULT DeviceManager::DeviceEnumerate(ifc_deviceobjectenum **enumerator)
{
return deviceStore.Enumerate((DeviceObjectEnum**)enumerator);
}
HRESULT DeviceManager::IsDiscoveryActive()
{
return (FALSE != discoveryMonitor.IsActive()) ? S_OK : S_FALSE;
}
HRESULT DeviceManager::BeginDiscovery()
{
size_t index, started;
EnterCriticalSection(&providerLock);
started = 0;
index = providerList.size();
while(index--)
{
if (providerList[index] && SUCCEEDED(providerList[index]->BeginDiscovery((api_devicemanager*)this)))
started++;
}
LeaveCriticalSection(&providerLock);
return (0 != started) ? S_OK : E_FAIL;
}
HRESULT DeviceManager::CancelDiscovery()
{
size_t index;
EnterCriticalSection(&providerLock);
index = providerList.size();
while(index--)
{
providerList[index]->CancelDiscovery();
}
LeaveCriticalSection(&providerLock);
return S_OK;
}
HRESULT DeviceManager::SetProviderActive(ifc_deviceprovider *provider, BOOL activeState)
{
if (FALSE != activeState)
{
if (FALSE != discoveryMonitor.Register(provider))
EventDiscoveryStarted();
}
else
{
if (FALSE != discoveryMonitor.Unregister(provider))
EventDiscoveryFinished();
}
return S_OK;
}
HRESULT DeviceManager::RegisterProvider(ifc_deviceprovider *provider)
{
HRESULT hr;
size_t index;
if (NULL == provider)
return E_INVALIDARG;
hr = S_OK;
EnterCriticalSection(&providerLock);
index = providerList.size();
while(index--)
{
if (provider == providerList[index])
{
hr = S_FALSE;
break;
}
}
if(S_OK == hr)
{
providerList.push_back(provider);
provider->AddRef();
SetProviderActive(provider, (S_OK == provider->GetActive()));
}
LeaveCriticalSection(&providerLock);
return hr;
}
HRESULT DeviceManager::UnregisterProvider(ifc_deviceprovider *provider)
{
HRESULT hr;
size_t index;
if (NULL == provider)
return E_INVALIDARG;
hr = S_FALSE;
EnterCriticalSection(&providerLock);
index = providerList.size();
while(index--)
{
if (provider == providerList[index])
{
ifc_deviceprovider *object;
object = providerList[index];
SetProviderActive(object, (S_OK == object->GetActive()));
providerList.erase(providerList.begin() + index);
object->Release();
hr = S_OK;
break;
}
}
LeaveCriticalSection(&providerLock);
return hr;
}
HRESULT DeviceManager::Advise(ifc_devicemanagerevent *handler)
{
HRESULT hr;
size_t index;
if (NULL == handler)
return E_INVALIDARG;
hr = S_OK;
EnterCriticalSection(&eventLock);
index = eventList.size();
while(index--)
{
if (handler == eventList[index])
{
hr = S_FALSE;
break;
}
}
if(S_OK == hr)
{
eventList.push_back(handler);
handler->AddRef();
}
LeaveCriticalSection(&eventLock);
return hr;
}
HRESULT DeviceManager::Unadvise(ifc_devicemanagerevent *handler)
{
HRESULT hr;
size_t index;
if (NULL == handler)
return E_INVALIDARG;
hr = S_FALSE;
EnterCriticalSection(&eventLock);
index = eventList.size();
while(index--)
{
if (handler == eventList[index])
{
ifc_devicemanagerevent *object;
object = eventList[index];
eventList.erase(eventList.begin() + index);
object->Release();
hr = S_OK;
break;
}
}
LeaveCriticalSection(&eventLock);
return hr;
}
HRESULT DeviceManager::CreateDeviceEventManager(ifc_deviceeventmanager **eventManager)
{
return DeviceEventManager::CreateInstance(
reinterpret_cast<DeviceEventManager**>(eventManager));
}
HRESULT DeviceManager::CreateSupportedCommandStore(ifc_devicesupportedcommandstore **store)
{
return DeviceSupportedCommandStore::CreateInstance(
reinterpret_cast<DeviceSupportedCommandStore**>(store));
}
HRESULT DeviceManager::CreateSupportedCommandEnum(ifc_devicesupportedcommand **commands, size_t count, ifc_devicesupportedcommandenum **enumerator)
{
return DeviceSupportedCommandEnum::CreateInstance(commands, count,
reinterpret_cast<DeviceSupportedCommandEnum**>(enumerator));
}
HRESULT DeviceManager::CreateIconStore(ifc_deviceiconstore **store)
{
return DeviceIconStore::CreateInstance(
reinterpret_cast<DeviceIconStore**>(store));
}
HRESULT DeviceManager::CreateType(const char *name, ifc_devicetype **type)
{
return DeviceType::CreateInstance(name, reinterpret_cast<DeviceType**>(type));
}
HRESULT DeviceManager::CreateCommand(const char *name, ifc_devicecommand **command)
{
return DeviceCommand::CreateInstance(name, reinterpret_cast<DeviceCommand**>(command));
}
HRESULT DeviceManager::CreateConnection(const char *name, ifc_deviceconnection **connection)
{
return DeviceConnection::CreateInstance(name, reinterpret_cast<DeviceConnection**>(connection));
}
void
DeviceManager::ObjectAddedCallback(DeviceObjectStore *store, ifc_deviceobject *object, void *userData)
{
DeviceManager *manager;
manager = (DeviceManager*)userData;
if (NULL == manager)
return;
if (store == &manager->typeStore)
manager->EventTypeAdded((ifc_devicetype*)object);
else if (store == &manager->connectionStore)
manager->EventConnectionAdded((ifc_deviceconnection*)object);
else if (store == &manager->commandStore)
manager->EventCommandAdded((ifc_devicecommand*)object);
else if (store == &manager->deviceStore)
manager->EventDeviceAdded((ifc_device*)object);
}
void
DeviceManager::ObjectRemovedCallback(DeviceObjectStore *store, ifc_deviceobject *object, void *userData)
{
DeviceManager *manager;
manager = (DeviceManager*)userData;
if (NULL == manager)
return;
if (store == &manager->typeStore)
manager->EventTypeRemoved((ifc_devicetype*)object);
else if (store == &manager->connectionStore)
manager->EventConnectionRemoved((ifc_deviceconnection*)object);
else if (store == &manager->commandStore)
manager->EventCommandRemoved((ifc_devicecommand*)object);
else if (store == &manager->deviceStore)
manager->EventDeviceRemoved((ifc_device*)object);
}
void DeviceManager::EventTypeAdded(ifc_devicetype *type)
{
EnterCriticalSection(&eventLock);
size_t index = eventList.size();
while(index--)
{
ifc_devicemanagerevent *handler = eventList[index];
handler->TypeAdded((api_devicemanager*)this, type);
}
LeaveCriticalSection(&eventLock);
}
void DeviceManager::EventTypeRemoved(ifc_devicetype *type)
{
EnterCriticalSection(&eventLock);
size_t index = eventList.size();
while(index--)
{
ifc_devicemanagerevent *handler = eventList[index];
handler->TypeRemoved((api_devicemanager*)this, type);
}
LeaveCriticalSection(&eventLock);
}
void DeviceManager::EventConnectionAdded(ifc_deviceconnection *connection)
{
EnterCriticalSection(&eventLock);
size_t index = eventList.size();
while(index--)
{
ifc_devicemanagerevent *handler = eventList[index];
handler->ConnectionAdded((api_devicemanager*)this, connection);
}
LeaveCriticalSection(&eventLock);
}
void DeviceManager::EventConnectionRemoved(ifc_deviceconnection *connection)
{
EnterCriticalSection(&eventLock);
size_t index = eventList.size();
while(index--)
{
ifc_devicemanagerevent *handler = eventList[index];
handler->ConnectionRemoved((api_devicemanager*)this, connection);
}
LeaveCriticalSection(&eventLock);
}
void DeviceManager::EventCommandAdded(ifc_devicecommand *command)
{
EnterCriticalSection(&eventLock);
size_t index = eventList.size();
while(index--)
{
ifc_devicemanagerevent *handler = eventList[index];
handler->CommandAdded((api_devicemanager*)this, command);
}
LeaveCriticalSection(&eventLock);
}
void DeviceManager::EventCommandRemoved(ifc_devicecommand *command)
{
EnterCriticalSection(&eventLock);
size_t index = eventList.size();
while(index--)
{
ifc_devicemanagerevent *handler = eventList[index];
handler->CommandRemoved((api_devicemanager*)this, command);
}
LeaveCriticalSection(&eventLock);
}
void DeviceManager::EventDeviceAdded(ifc_device *device)
{
EnterCriticalSection(&eventLock);
size_t index = eventList.size();
while(index--)
{
ifc_devicemanagerevent *handler = eventList[index];
handler->DeviceAdded((api_devicemanager*)this, device);
}
LeaveCriticalSection(&eventLock);
}
void DeviceManager::EventDeviceRemoved(ifc_device *device)
{
EnterCriticalSection(&eventLock);
size_t index = eventList.size();
while(index--)
{
ifc_devicemanagerevent *handler = eventList[index];
handler->DeviceRemoved((api_devicemanager*)this, device);
}
LeaveCriticalSection(&eventLock);
}
void DeviceManager::EventDiscoveryStarted()
{
EnterCriticalSection(&eventLock);
size_t index = eventList.size();
while(index--)
{
ifc_devicemanagerevent *handler = eventList[index];
handler->DiscoveryStarted((api_devicemanager*)this);
}
LeaveCriticalSection(&eventLock);
}
void DeviceManager::EventDiscoveryFinished()
{
EnterCriticalSection(&eventLock);
size_t index = eventList.size();
while(index--)
{
ifc_devicemanagerevent *handler = eventList[index];
handler->DiscoveryFinished((api_devicemanager*)this);
}
LeaveCriticalSection(&eventLock);
}
#define CBCLASS DeviceManager
START_DISPATCH;
CB(ADDREF, AddRef)
CB(RELEASE, Release)
CB(QUERYINTERFACE, QueryInterface)
CB(API_TYPEREGISTER, TypeRegister)
CB(API_TYPEREGISTERINDIRECT, TypeRegisterIndirect)
CB(API_TYPEUNREGISTER, TypeUnregister)
CB(API_TYPEFIND, TypeFind)
CB(API_TYPEENUMERATE, TypeEnumerate)
CB(API_CONNECTIONREGISTER, ConnectionRegister)
CB(API_CONNECTIONREGISTERINDIRECT, ConnectionRegisterIndirect)
CB(API_CONNECTIONUNREGISTER, ConnectionUnregister)
CB(API_CONNECTIONFIND, ConnectionFind)
CB(API_CONNECTIONENUMERATE, ConnectionEnumerate)
CB(API_COMMANDREGISTER, CommandRegister)
CB(API_COMMANDREGISTERINDIRECT, CommandRegisterIndirect)
CB(API_COMMANDUNREGISTER, CommandUnregister)
CB(API_COMMANDFIND, CommandFind)
CB(API_COMMANDENUMERATE, CommandEnumerate)
CB(API_DEVICEREGISTER, DeviceRegister)
CB(API_DEVICEUNREGISTER, DeviceUnregister)
CB(API_DEVICEFIND, DeviceFind)
CB(API_DEVICEENUMERATE, DeviceEnumerate)
CB(API_ISDISCOVERYACTIVE, IsDiscoveryActive)
CB(API_BEGINDISCOVERY, BeginDiscovery)
CB(API_CANCELDISCOVERY, CancelDiscovery)
CB(API_REGISTERPROVIDER, RegisterProvider)
CB(API_UNREGISTERPROVIDER, UnregisterProvider)
CB(API_SETPROVIDERACTIVE, SetProviderActive)
CB(API_ADVISE, Advise)
CB(API_UNADVISE, Unadvise)
CB(API_CREATEDEVICEEVENTMANAGER, CreateDeviceEventManager)
CB(API_CREATESUPPORTEDCOMMANDSTORE, CreateSupportedCommandStore)
CB(API_CREATESUPPORTEDCOMMANDENUM, CreateSupportedCommandEnum)
CB(API_CREATEICONSTORE, CreateIconStore)
CB(API_CREATETYPE, CreateType)
CB(API_CREATECOMMAND, CreateCommand)
CB(API_CREATECONNECTION, CreateConnection)
END_DISPATCH;
#undef CBCLASS