From 95c696f818b6840bcbefe6d376ff01fa02dfd772 Mon Sep 17 00:00:00 2001 From: Jens Lorenz Date: Tue, 3 Jul 2018 17:42:05 +0200 Subject: FOO: Issue #26 fix white space issues and apply new coding style Signed-off-by: Jens Lorenz --- AudioManagerCore/src/CAmCommandReceiver.cpp | 173 +- AudioManagerCore/src/CAmCommandSender.cpp | 323 ++- AudioManagerCore/src/CAmControlReceiver.cpp | 282 +- AudioManagerCore/src/CAmControlSender.cpp | 205 +- AudioManagerCore/src/CAmDatabaseHandlerMap.cpp | 3676 +++++++++++++----------- AudioManagerCore/src/CAmLog.cpp | 85 +- AudioManagerCore/src/CAmRouter.cpp | 1479 +++++----- AudioManagerCore/src/CAmRoutingReceiver.cpp | 314 +- AudioManagerCore/src/CAmRoutingSender.cpp | 1250 ++++---- 9 files changed, 4098 insertions(+), 3689 deletions(-) (limited to 'AudioManagerCore/src') diff --git a/AudioManagerCore/src/CAmCommandReceiver.cpp b/AudioManagerCore/src/CAmCommandReceiver.cpp index 8b60c66..78d8cbe 100644 --- a/AudioManagerCore/src/CAmCommandReceiver.cpp +++ b/AudioManagerCore/src/CAmCommandReceiver.cpp @@ -29,152 +29,151 @@ #include "CAmDltWrapper.h" #include "CAmSocketHandler.h" -#define __METHOD_NAME__ std::string (std::string("CAmCommandReceiver::") + __func__) +#define __METHOD_NAME__ std::string(std::string("CAmCommandReceiver::") + __func__) namespace am { -CAmCommandReceiver::CAmCommandReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler) : - mDatabaseHandler(iDatabaseHandler), - mControlSender(iControlSender), - mDBusWrapper(NULL), - mSocketHandler(iSocketHandler), - handleCount(0), - mListStartupHandles(), - mListRundownHandles(), - mWaitStartup(false), - mWaitRundown(false), - mLastErrorStartup(E_OK), - mLastErrorRundown(E_OK) - -{ - assert(mDatabaseHandler!=NULL); - assert(mSocketHandler!=NULL); - assert(mControlSender!=NULL); -} - -CAmCommandReceiver::CAmCommandReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper) : - mDatabaseHandler(iDatabaseHandler), - mControlSender(iControlSender), - mDBusWrapper(iDBusWrapper), - mSocketHandler(iSocketHandler), - handleCount(0), - mListStartupHandles(), - mListRundownHandles(), - mWaitStartup(false), - mWaitRundown(false), - mLastErrorStartup(E_UNKNOWN), - mLastErrorRundown(E_UNKNOWN) -{ - assert(mDatabaseHandler!=NULL); - assert(mSocketHandler!=NULL); - assert(mControlSender!=NULL); - assert(mDBusWrapper!=NULL); +CAmCommandReceiver::CAmCommandReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler) + : mDatabaseHandler(iDatabaseHandler) + , mControlSender(iControlSender) + , mDBusWrapper(NULL) + , mSocketHandler(iSocketHandler) + , handleCount(0) + , mListStartupHandles() + , mListRundownHandles() + , mWaitStartup(false) + , mWaitRundown(false) + , mLastErrorStartup(E_OK) + , mLastErrorRundown(E_OK) +{ + assert(mDatabaseHandler != NULL); + assert(mSocketHandler != NULL); + assert(mControlSender != NULL); +} + +CAmCommandReceiver::CAmCommandReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper) + : mDatabaseHandler(iDatabaseHandler) + , mControlSender(iControlSender) + , mDBusWrapper(iDBusWrapper) + , mSocketHandler(iSocketHandler) + , handleCount(0) + , mListStartupHandles() + , mListRundownHandles() + , mWaitStartup(false) + , mWaitRundown(false) + , mLastErrorStartup(E_UNKNOWN) + , mLastErrorRundown(E_UNKNOWN) +{ + assert(mDatabaseHandler != NULL); + assert(mSocketHandler != NULL); + assert(mControlSender != NULL); + assert(mDBusWrapper != NULL); } CAmCommandReceiver::~CAmCommandReceiver() { } -am_Error_e CAmCommandReceiver::connect(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t & mainConnectionID) +am_Error_e CAmCommandReceiver::connect(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t &mainConnectionID) { - logInfo(__METHOD_NAME__,"sourceID=", sourceID, "sinkID=", sinkID); + logInfo(__METHOD_NAME__, "sourceID=", sourceID, "sinkID=", sinkID); return (mControlSender->hookUserConnectionRequest(sourceID, sinkID, mainConnectionID)); } am_Error_e CAmCommandReceiver::disconnect(const am_mainConnectionID_t mainConnectionID) { - logInfo(__METHOD_NAME__,"mainConnectionID=", mainConnectionID); + logInfo(__METHOD_NAME__, "mainConnectionID=", mainConnectionID); return (mControlSender->hookUserDisconnectionRequest(mainConnectionID)); } am_Error_e CAmCommandReceiver::setVolume(const am_sinkID_t sinkID, const am_mainVolume_t volume) { - logInfo(__METHOD_NAME__,"sinkID=", sinkID, "volume=", volume); + logInfo(__METHOD_NAME__, "sinkID=", sinkID, "volume=", volume); return (mControlSender->hookUserVolumeChange(sinkID, volume)); } am_Error_e CAmCommandReceiver::volumeStep(const am_sinkID_t sinkID, const int16_t volumeStep) { - logInfo(__METHOD_NAME__,"sinkID=", sinkID, "volumeStep=", volumeStep); + logInfo(__METHOD_NAME__, "sinkID=", sinkID, "volumeStep=", volumeStep); return (mControlSender->hookUserVolumeStep(sinkID, volumeStep)); } am_Error_e CAmCommandReceiver::setSinkMuteState(const am_sinkID_t sinkID, const am_MuteState_e muteState) { - logInfo(__METHOD_NAME__,"sinkID=", sinkID, "muteState=", muteState); + logInfo(__METHOD_NAME__, "sinkID=", sinkID, "muteState=", muteState); return (mControlSender->hookUserSetSinkMuteState(sinkID, muteState)); } -am_Error_e CAmCommandReceiver::setMainSinkSoundProperty(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID) +am_Error_e CAmCommandReceiver::setMainSinkSoundProperty(const am_MainSoundProperty_s &soundProperty, const am_sinkID_t sinkID) { - logInfo(__METHOD_NAME__,"sinkID=", sinkID, "soundPropertyType=", soundProperty.type, "soundPropertyValue=", soundProperty.value); + logInfo(__METHOD_NAME__, "sinkID=", sinkID, "soundPropertyType=", soundProperty.type, "soundPropertyValue=", soundProperty.value); return (mControlSender->hookUserSetMainSinkSoundProperty(sinkID, soundProperty)); } -am_Error_e CAmCommandReceiver::setMainSourceSoundProperty(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID) +am_Error_e CAmCommandReceiver::setMainSourceSoundProperty(const am_MainSoundProperty_s &soundProperty, const am_sourceID_t sourceID) { - logInfo(__METHOD_NAME__,"sourceID=", sourceID, "soundPropertyType=", soundProperty.type, "soundPropertyValue=", soundProperty.value); + logInfo(__METHOD_NAME__, "sourceID=", sourceID, "soundPropertyType=", soundProperty.type, "soundPropertyValue=", soundProperty.value); return (mControlSender->hookUserSetMainSourceSoundProperty(sourceID, soundProperty)); } -am_Error_e CAmCommandReceiver::setSystemProperty(const am_SystemProperty_s & property) +am_Error_e CAmCommandReceiver::setSystemProperty(const am_SystemProperty_s &property) { - logInfo(__METHOD_NAME__,"type=", property.type, "systemPropertyValue=", property.value); + logInfo(__METHOD_NAME__, "type=", property.type, "systemPropertyValue=", property.value); return (mControlSender->hookUserSetSystemProperty(property)); } -am_Error_e CAmCommandReceiver::getVolume(const am_sinkID_t sinkID, am_mainVolume_t& mainVolume) const +am_Error_e CAmCommandReceiver::getVolume(const am_sinkID_t sinkID, am_mainVolume_t &mainVolume) const { return (mDatabaseHandler->getSinkMainVolume(sinkID, mainVolume)); } -am_Error_e CAmCommandReceiver::getListMainConnections(std::vector & listConnections) const +am_Error_e CAmCommandReceiver::getListMainConnections(std::vector &listConnections) const { return (mDatabaseHandler->getListVisibleMainConnections(listConnections)); } -am_Error_e CAmCommandReceiver::getListMainSinks(std::vector& listMainSinks) const +am_Error_e CAmCommandReceiver::getListMainSinks(std::vector &listMainSinks) const { return (mDatabaseHandler->getListMainSinks(listMainSinks)); } -am_Error_e CAmCommandReceiver::getListMainSources(std::vector& listMainSources) const +am_Error_e CAmCommandReceiver::getListMainSources(std::vector &listMainSources) const { return (mDatabaseHandler->getListMainSources(listMainSources)); } -am_Error_e CAmCommandReceiver::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector & listSoundProperties) const +am_Error_e CAmCommandReceiver::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector &listSoundProperties) const { return (mDatabaseHandler->getListMainSinkSoundProperties(sinkID, listSoundProperties)); } -am_Error_e CAmCommandReceiver::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector & listSourceProperties) const +am_Error_e CAmCommandReceiver::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector &listSourceProperties) const { return (mDatabaseHandler->getListMainSourceSoundProperties(sourceID, listSourceProperties)); } -am_Error_e CAmCommandReceiver::getListSourceClasses(std::vector & listSourceClasses) const +am_Error_e CAmCommandReceiver::getListSourceClasses(std::vector &listSourceClasses) const { return (mDatabaseHandler->getListSourceClasses(listSourceClasses)); } -am_Error_e CAmCommandReceiver::getListSinkClasses(std::vector & listSinkClasses) const +am_Error_e CAmCommandReceiver::getListSinkClasses(std::vector &listSinkClasses) const { return (mDatabaseHandler->getListSinkClasses(listSinkClasses)); } -am_Error_e CAmCommandReceiver::getListSystemProperties(std::vector & listSystemProperties) const +am_Error_e CAmCommandReceiver::getListSystemProperties(std::vector &listSystemProperties) const { return (mDatabaseHandler->getListSystemProperties(listSystemProperties)); } -am_Error_e CAmCommandReceiver::getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t & delay) const +am_Error_e CAmCommandReceiver::getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t &delay) const { return (mDatabaseHandler->getTimingInformation(mainConnectionID, delay)); } -am_Error_e CAmCommandReceiver::getDBusConnectionWrapper(CAmDbusWrapper*& dbusConnectionWrapper) const +am_Error_e CAmCommandReceiver::getDBusConnectionWrapper(CAmDbusWrapper * &dbusConnectionWrapper) const { #ifdef WITH_DBUS_WRAPPER dbusConnectionWrapper = mDBusWrapper; @@ -185,81 +184,91 @@ am_Error_e CAmCommandReceiver::getDBusConnectionWrapper(CAmDbusWrapper*& dbusCon #endif /*WITH_DBUS_WRAPPER*/ } -am_Error_e CAmCommandReceiver::getSocketHandler(CAmSocketHandler *& socketHandler) const +am_Error_e CAmCommandReceiver::getSocketHandler(CAmSocketHandler * &socketHandler) const { socketHandler = mSocketHandler; return (E_OK); } -void CAmCommandReceiver::getInterfaceVersion(std::string & version) const +void CAmCommandReceiver::getInterfaceVersion(std::string &version) const { version = CommandVersion; } void CAmCommandReceiver::confirmCommandReady(const uint16_t handle, const am_Error_e error) { - if (error !=E_OK) - mLastErrorStartup=error; + if (error != E_OK) + { + mLastErrorStartup = error; + } + mListStartupHandles.erase(std::remove(mListStartupHandles.begin(), mListStartupHandles.end(), handle), mListStartupHandles.end()); if (mWaitStartup && mListStartupHandles.empty()) + { mControlSender->confirmCommandReady(mLastErrorStartup); + } } void CAmCommandReceiver::confirmCommandRundown(const uint16_t handle, const am_Error_e error) { - if (error !=E_OK) - mLastErrorRundown=error; + if (error != E_OK) + { + mLastErrorRundown = error; + } + mListRundownHandles.erase(std::remove(mListRundownHandles.begin(), mListRundownHandles.end(), handle), mListRundownHandles.end()); if (mWaitRundown && mListRundownHandles.empty()) + { mControlSender->confirmCommandRundown(mLastErrorRundown); + } } uint16_t CAmCommandReceiver::getStartupHandle() { - uint16_t handle = ++handleCount; //todo: handle overflow + uint16_t handle = ++handleCount; // todo: handle overflow mListStartupHandles.push_back(handle); return (handle); } uint16_t CAmCommandReceiver::getRundownHandle() { - uint16_t handle = ++handleCount; //todo: handle overflow + uint16_t handle = ++handleCount; // todo: handle overflow mListRundownHandles.push_back(handle); return (handle); } void CAmCommandReceiver::waitOnStartup(bool startup) { - mWaitStartup = startup; - mLastErrorStartup=E_OK; + mWaitStartup = startup; + mLastErrorStartup = E_OK; } -am_Error_e CAmCommandReceiver::getListMainSinkNotificationConfigurations(const am_sinkID_t sinkID, std::vector& listMainNotificationConfigurations) const +am_Error_e CAmCommandReceiver::getListMainSinkNotificationConfigurations(const am_sinkID_t sinkID, std::vector &listMainNotificationConfigurations) const { - return (mDatabaseHandler->getListMainSinkNotificationConfigurations(sinkID,listMainNotificationConfigurations)); + return (mDatabaseHandler->getListMainSinkNotificationConfigurations(sinkID, listMainNotificationConfigurations)); } -am_Error_e CAmCommandReceiver::getListMainSourceNotificationConfigurations(const am_sourceID_t sourceID, std::vector& listMainNotificationConfigurations) const +am_Error_e CAmCommandReceiver::getListMainSourceNotificationConfigurations(const am_sourceID_t sourceID, std::vector &listMainNotificationConfigurations) const { - return (mDatabaseHandler->getListMainSourceNotificationConfigurations(sourceID,listMainNotificationConfigurations)); + return (mDatabaseHandler->getListMainSourceNotificationConfigurations(sourceID, listMainNotificationConfigurations)); } -am_Error_e CAmCommandReceiver::setMainSinkNotificationConfiguration(const am_sinkID_t sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration) +am_Error_e CAmCommandReceiver::setMainSinkNotificationConfiguration(const am_sinkID_t sinkID, const am_NotificationConfiguration_s &mainNotificationConfiguration) { - logInfo(__METHOD_NAME__,"sinkID=", sinkID, " type=",mainNotificationConfiguration.type, " parameter=", mainNotificationConfiguration.parameter, "status=",mainNotificationConfiguration.status); - return (mControlSender->hookUserSetMainSinkNotificationConfiguration(sinkID,mainNotificationConfiguration)); + logInfo(__METHOD_NAME__, "sinkID=", sinkID, " type=", mainNotificationConfiguration.type, " parameter=", mainNotificationConfiguration.parameter, "status=", mainNotificationConfiguration.status); + return (mControlSender->hookUserSetMainSinkNotificationConfiguration(sinkID, mainNotificationConfiguration)); } -am_Error_e CAmCommandReceiver::setMainSourceNotificationConfiguration(const am_sourceID_t sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration) +am_Error_e CAmCommandReceiver::setMainSourceNotificationConfiguration(const am_sourceID_t sourceID, const am_NotificationConfiguration_s &mainNotificationConfiguration) { - logInfo(__METHOD_NAME__,"sourceID=", sourceID, " type=",mainNotificationConfiguration.type, " parameter=", mainNotificationConfiguration.parameter, "status=",mainNotificationConfiguration.status); - return (mControlSender->hookUserSetMainSourceNotificationConfiguration(sourceID,mainNotificationConfiguration)); + logInfo(__METHOD_NAME__, "sourceID=", sourceID, " type=", mainNotificationConfiguration.type, " parameter=", mainNotificationConfiguration.parameter, "status=", mainNotificationConfiguration.status); + return (mControlSender->hookUserSetMainSourceNotificationConfiguration(sourceID, mainNotificationConfiguration)); } void CAmCommandReceiver::waitOnRundown(bool rundown) { - mWaitRundown = rundown; - mLastErrorStartup=E_OK; + mWaitRundown = rundown; + mLastErrorStartup = E_OK; } } diff --git a/AudioManagerCore/src/CAmCommandSender.cpp b/AudioManagerCore/src/CAmCommandSender.cpp index 1a61883..d1a4a22 100644 --- a/AudioManagerCore/src/CAmCommandSender.cpp +++ b/AudioManagerCore/src/CAmCommandSender.cpp @@ -35,7 +35,7 @@ #include "CAmDltWrapper.h" #include "audiomanagerconfig.h" -#define __METHOD_NAME__ std::string (std::string("CAmCommandSender::") + __func__) +#define __METHOD_NAME__ std::string(std::string("CAmCommandSender::") + __func__) namespace am { @@ -43,135 +43,143 @@ namespace am /** * macro to call all interfaces */ -#define CALL_ALL_INTERFACES(...) \ - std::vector::iterator iter = mListInterfaces.begin(); \ - std::vector::iterator iterEnd = mListInterfaces.end(); \ - for (; iter__VA_ARGS__; \ - } - -CAmCommandSender::CAmCommandSender(const std::vector& listOfPluginDirectories, CAmSocketHandler *iSocketHandler) : - CAmDatabaseHandlerMap::AmDatabaseObserverCallbacks(), - mListInterfaces(), - mListLibraryHandles(), - mListLibraryNames(), - mCommandReceiver(), - mSerializer(iSocketHandler) +#define CALL_ALL_INTERFACES(...) \ + std::vector::iterator iter = mListInterfaces.begin(); \ + std::vector::iterator iterEnd = mListInterfaces.end(); \ + for (; iter < iterEnd; ++iter) \ + { \ + (*iter)->__VA_ARGS__; \ + } + +CAmCommandSender::CAmCommandSender(const std::vector &listOfPluginDirectories, CAmSocketHandler *iSocketHandler) + : CAmDatabaseHandlerMap::AmDatabaseObserverCallbacks() + , mListInterfaces() + , mListLibraryHandles() + , mListLibraryNames() + , mCommandReceiver() + , mSerializer(iSocketHandler) { loadPlugins(listOfPluginDirectories); - dboNewMainConnection = [&](const am_MainConnectionType_s& mainConnection) { - mSerializer.asyncCall(this, &CAmCommandSender::cbNewMainConnection, mainConnection); - }; + dboNewMainConnection = [&](const am_MainConnectionType_s &mainConnection) { + mSerializer.asyncCall(this, &CAmCommandSender::cbNewMainConnection, mainConnection); + }; dboRemovedMainConnection = [&](const am_mainConnectionID_t mainConnection) { - mSerializer.asyncCall(this, &CAmCommandSender::cbRemovedMainConnection, mainConnection); - }; - dboNewSink = [&](const am_Sink_s& sink) { - if (sink.visible) - { - am_SinkType_s s; - s.availability = sink.available; - s.muteState = sink.muteState; - s.name = sink.name; - s.sinkClassID = sink.sinkClassID; - s.sinkID = sink.sinkID; - s.volume = sink.mainVolume; - typedef void(CAmCommandSender::*TMeth)(am::am_SinkType_s); - mSerializer.asyncCall(this, &CAmCommandSender::cbNewSink, s); - } - }; - dboNewSource = [&](const am_Source_s& source) { - if (source.visible) - { - am_SourceType_s s; - s.availability = source.available; - s.name = source.name; - s.sourceClassID = source.sourceClassID; - s.sourceID = source.sourceID; - typedef void(CAmCommandSender::*TMeth)(am::am_SourceType_s); - mSerializer.asyncCall(this, &CAmCommandSender::cbNewSource, s); - } - }; + mSerializer.asyncCall(this, &CAmCommandSender::cbRemovedMainConnection, mainConnection); + }; + dboNewSink = [&](const am_Sink_s &sink) { + if (sink.visible) + { + am_SinkType_s s; + s.availability = sink.available; + s.muteState = sink.muteState; + s.name = sink.name; + s.sinkClassID = sink.sinkClassID; + s.sinkID = sink.sinkID; + s.volume = sink.mainVolume; + typedef void (CAmCommandSender::*TMeth)(am::am_SinkType_s); + mSerializer.asyncCall(this, &CAmCommandSender::cbNewSink, s); + } + }; + dboNewSource = [&](const am_Source_s &source) { + if (source.visible) + { + am_SourceType_s s; + s.availability = source.available; + s.name = source.name; + s.sourceClassID = source.sourceClassID; + s.sourceID = source.sourceID; + typedef void (CAmCommandSender::*TMeth)(am::am_SourceType_s); + mSerializer.asyncCall(this, &CAmCommandSender::cbNewSource, s); + } + }; dboRemovedSink = [&](const am_sinkID_t sinkID, const bool visible) { - if (visible) - mSerializer.asyncCall(this, &CAmCommandSender::cbRemovedSink, sinkID); - }; + if (visible) + { + mSerializer.asyncCall(this, &CAmCommandSender::cbRemovedSink, sinkID); + } + }; dboRemovedSource = [&](const am_sourceID_t sourceID, const bool visible) { - if (visible) - mSerializer.asyncCall(this, &CAmCommandSender::cbRemovedSource, sourceID); - }; + if (visible) + { + mSerializer.asyncCall(this, &CAmCommandSender::cbRemovedSource, sourceID); + } + }; dboNumberOfSinkClassesChanged = [&]() { - mSerializer.asyncCall(this, &CAmCommandSender::cbNumberOfSinkClassesChanged); - }; + mSerializer.asyncCall(this, &CAmCommandSender::cbNumberOfSinkClassesChanged); + }; dboNumberOfSourceClassesChanged = [&]() { - mSerializer.asyncCall(this, &CAmCommandSender::cbNumberOfSourceClassesChanged); - }; + mSerializer.asyncCall(this, &CAmCommandSender::cbNumberOfSourceClassesChanged); + }; dboMainConnectionStateChanged = [&](const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState) { - mSerializer.asyncCall(this, &CAmCommandSender::cbMainConnectionStateChanged, connectionID, connectionState); - }; - dboMainSinkSoundPropertyChanged = [&](const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty) { - mSerializer.asyncCall(this, &CAmCommandSender::cbMainSinkSoundPropertyChanged, sinkID, SoundProperty); - }; - dboMainSourceSoundPropertyChanged = [&](const am_sourceID_t sourceID, const am_MainSoundProperty_s& SoundProperty) { - mSerializer.asyncCall(this, &CAmCommandSender::cbMainSourceSoundPropertyChanged, sourceID, SoundProperty); - }; - dboSinkAvailabilityChanged = [&](const am_sinkID_t sinkID, const am_Availability_s & availability) { - mSerializer.asyncCall(this, &CAmCommandSender::cbSinkAvailabilityChanged, sinkID, availability); - }; - dboSourceAvailabilityChanged = [&](const am_sourceID_t sourceID, const am_Availability_s & availability) { - mSerializer.asyncCall(this, &CAmCommandSender::cbSourceAvailabilityChanged, sourceID, availability); - }; + mSerializer.asyncCall(this, &CAmCommandSender::cbMainConnectionStateChanged, connectionID, connectionState); + }; + dboMainSinkSoundPropertyChanged = [&](const am_sinkID_t sinkID, const am_MainSoundProperty_s &SoundProperty) { + mSerializer.asyncCall(this, &CAmCommandSender::cbMainSinkSoundPropertyChanged, sinkID, SoundProperty); + }; + dboMainSourceSoundPropertyChanged = [&](const am_sourceID_t sourceID, const am_MainSoundProperty_s &SoundProperty) { + mSerializer.asyncCall(this, &CAmCommandSender::cbMainSourceSoundPropertyChanged, sourceID, SoundProperty); + }; + dboSinkAvailabilityChanged = [&](const am_sinkID_t sinkID, const am_Availability_s &availability) { + mSerializer.asyncCall(this, &CAmCommandSender::cbSinkAvailabilityChanged, sinkID, availability); + }; + dboSourceAvailabilityChanged = [&](const am_sourceID_t sourceID, const am_Availability_s &availability) { + mSerializer.asyncCall(this, &CAmCommandSender::cbSourceAvailabilityChanged, sourceID, availability); + }; dboVolumeChanged = [&](const am_sinkID_t sinkID, const am_mainVolume_t volume) { - mSerializer.asyncCall(this, &CAmCommandSender::cbVolumeChanged, sinkID, volume); - }; + mSerializer.asyncCall(this, &CAmCommandSender::cbVolumeChanged, sinkID, volume); + }; dboSinkMuteStateChanged = [&](const am_sinkID_t sinkID, const am_MuteState_e muteState) { - mSerializer.asyncCall(this, &CAmCommandSender::cbSinkMuteStateChanged, sinkID, muteState); - }; - dboSystemPropertyChanged = [&](const am_SystemProperty_s& SystemProperty) { - mSerializer.asyncCall(this, &CAmCommandSender::cbSystemPropertyChanged, SystemProperty); - }; + mSerializer.asyncCall(this, &CAmCommandSender::cbSinkMuteStateChanged, sinkID, muteState); + }; + dboSystemPropertyChanged = [&](const am_SystemProperty_s &SystemProperty) { + mSerializer.asyncCall(this, &CAmCommandSender::cbSystemPropertyChanged, SystemProperty); + }; dboTimingInformationChanged = [&](const am_mainConnectionID_t mainConnection, const am_timeSync_t time) { - mSerializer.asyncCall(this, &CAmCommandSender::cbTimingInformationChanged, mainConnection, time); - }; - dboSinkUpdated = [&](const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector& listMainSoundProperties, const bool visible) { - if (visible) - mSerializer.asyncCall(this, &CAmCommandSender::cbSinkUpdated, sinkID, sinkClassID, listMainSoundProperties); - }; - dboSourceUpdated = [&](const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector& listMainSoundProperties, const bool visible) { - if (visible) - mSerializer.asyncCall(this, &CAmCommandSender::cbSinkUpdated, sourceID, sourceClassID, listMainSoundProperties); - }; + mSerializer.asyncCall(this, &CAmCommandSender::cbTimingInformationChanged, mainConnection, time); + }; + dboSinkUpdated = [&](const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector &listMainSoundProperties, const bool visible) { + if (visible) + { + mSerializer.asyncCall(this, &CAmCommandSender::cbSinkUpdated, sinkID, sinkClassID, listMainSoundProperties); + } + }; + dboSourceUpdated = [&](const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector &listMainSoundProperties, const bool visible) { + if (visible) + { + mSerializer.asyncCall(this, &CAmCommandSender::cbSinkUpdated, sourceID, sourceClassID, listMainSoundProperties); + } + }; dboSinkMainNotificationConfigurationChanged = [&](const am_sinkID_t sinkID, const am_NotificationConfiguration_s mainNotificationConfiguration) { - mSerializer.asyncCall(this, &CAmCommandSender::cbSinkMainNotificationConfigurationChanged, sinkID, mainNotificationConfiguration); - }; + mSerializer.asyncCall(this, &CAmCommandSender::cbSinkMainNotificationConfigurationChanged, sinkID, mainNotificationConfiguration); + }; dboSourceMainNotificationConfigurationChanged = [&](const am_sourceID_t sourceID, const am_NotificationConfiguration_s mainNotificationConfiguration) { - mSerializer.asyncCall(this, &CAmCommandSender::cbSourceMainNotificationConfigurationChanged, sourceID, mainNotificationConfiguration); - }; + mSerializer.asyncCall(this, &CAmCommandSender::cbSourceMainNotificationConfigurationChanged, sourceID, mainNotificationConfiguration); + }; } -void CAmCommandSender::loadPlugins(const std::vector& listOfPluginDirectories) +void CAmCommandSender::loadPlugins(const std::vector &listOfPluginDirectories) { if (listOfPluginDirectories.empty()) { - logError(__METHOD_NAME__,"List of commandplugins is empty"); + logError(__METHOD_NAME__, "List of commandplugins is empty"); } - std::vector sharedLibraryNameList; - std::vector::const_iterator dirIter = listOfPluginDirectories.begin(); + std::vector sharedLibraryNameList; + std::vector::const_iterator dirIter = listOfPluginDirectories.begin(); std::vector::const_iterator dirIterEnd = listOfPluginDirectories.end(); // search communicator plugins in configured directories for (; dirIter < dirIterEnd; ++dirIter) { - const char* directoryName = dirIter->c_str(); - logInfo(__METHOD_NAME__,"Searching for CommandPlugins in", *dirIter); + const char *directoryName = dirIter->c_str(); + logInfo(__METHOD_NAME__, "Searching for CommandPlugins in", *dirIter); DIR *directory = opendir(directoryName); if (!directory) { - logError(__METHOD_NAME__,"Error opening directory ", *dirIter); + logError(__METHOD_NAME__, "Error opening directory ", *dirIter); continue; } @@ -180,10 +188,10 @@ void CAmCommandSender::loadPlugins(const std::vector& listOfPluginD while ((itemInDirectory = readdir(directory))) { unsigned char entryType = itemInDirectory->d_type; - std::string entryName = itemInDirectory->d_name; - std::string fullName = *dirIter + "/" + entryName; + std::string entryName = itemInDirectory->d_name; + std::string fullName = *dirIter + "/" + entryName; - bool regularFile = (entryType == DT_REG || entryType == DT_LNK); + bool regularFile = (entryType == DT_REG || entryType == DT_LNK); bool sharedLibExtension = ("so" == entryName.substr(entryName.find_last_of(".") + 1)); // Handle cases where readdir() could not determine the file type @@ -193,7 +201,7 @@ void CAmCommandSender::loadPlugins(const std::vector& listOfPluginD if (stat(fullName.c_str(), &buf)) { - logInfo(__METHOD_NAME__,"Failed to stat file: ", entryName, errno); + logInfo(__METHOD_NAME__, "Failed to stat file: ", entryName, errno); continue; } @@ -206,36 +214,37 @@ void CAmCommandSender::loadPlugins(const std::vector& listOfPluginD sharedLibraryNameList.push_back(name + "/" + entryName); } } + closedir(directory); } // iterate all communicator plugins and start them - std::vector::iterator iter = sharedLibraryNameList.begin(); + std::vector::iterator iter = sharedLibraryNameList.begin(); std::vector::iterator iterEnd = sharedLibraryNameList.end(); for (; iter < iterEnd; ++iter) { - logInfo(__METHOD_NAME__,"Loading CommandSender plugin", *iter); - IAmCommandSend* (*createFunc)(); - void* tempLibHandle = NULL; - createFunc = getCreateFunction(*iter, tempLibHandle); + logInfo(__METHOD_NAME__, "Loading CommandSender plugin", *iter); + IAmCommandSend *(*createFunc)(); + void *tempLibHandle = NULL; + createFunc = getCreateFunction(*iter, tempLibHandle); if (!createFunc) { - logInfo(__METHOD_NAME__,"Entry point of CommandPlugin not found", *iter); + logInfo(__METHOD_NAME__, "Entry point of CommandPlugin not found", *iter); continue; } - IAmCommandSend* commander = createFunc(); + IAmCommandSend *commander = createFunc(); if (!commander) { - logInfo(__METHOD_NAME__,"CommandPlugin initialization failed. Entry Function not callable"); + logInfo(__METHOD_NAME__, "CommandPlugin initialization failed. Entry Function not callable"); dlclose(tempLibHandle); continue; } - //check libversion + // check libversion std::string version, cVersion(CommandVersion); commander->getInterfaceVersion(version); uint16_t minorVersion, majorVersion, cMinorVersion, cMajorVersion; @@ -246,7 +255,7 @@ void CAmCommandSender::loadPlugins(const std::vector& listOfPluginD if (majorVersion < cMajorVersion || ((majorVersion == cMajorVersion) && (minorVersion > cMinorVersion))) { - logError(__METHOD_NAME__,"CommandInterface initialization failed. Version of Interface to old"); + logError(__METHOD_NAME__, "CommandInterface initialization failed. Version of Interface to old"); dlclose(tempLibHandle); continue; } @@ -259,7 +268,7 @@ void CAmCommandSender::loadPlugins(const std::vector& listOfPluginD CAmCommandSender::~CAmCommandSender() { - //unloadLibraries(); + // unloadLibraries(); } am_Error_e CAmCommandSender::startupInterfaces(CAmCommandReceiver *iCommandReceiver) @@ -267,8 +276,8 @@ am_Error_e CAmCommandSender::startupInterfaces(CAmCommandReceiver *iCommandRecei mCommandReceiver = iCommandReceiver; am_Error_e returnError = E_OK; - std::vector::iterator iter = mListInterfaces.begin(); - std::vector::iterator iterEnd = mListInterfaces.end(); + std::vector::iterator iter = mListInterfaces.begin(); + std::vector::iterator iterEnd = mListInterfaces.end(); for (; iter < iterEnd; ++iter) { am_Error_e error = (*iter)->startupInterface(iCommandReceiver); @@ -277,6 +286,7 @@ am_Error_e CAmCommandSender::startupInterfaces(CAmCommandReceiver *iCommandRecei returnError = error; } } + return (returnError); } @@ -292,47 +302,47 @@ void CAmCommandSender::cbNumberOfSourceClassesChanged() void CAmCommandSender::cbMainConnectionStateChanged(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState) { - CALL_ALL_INTERFACES(cbMainConnectionStateChanged(connectionID,connectionState)) + CALL_ALL_INTERFACES(cbMainConnectionStateChanged(connectionID, connectionState)) } -void CAmCommandSender::cbMainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty) +void CAmCommandSender::cbMainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s &SoundProperty) { - CALL_ALL_INTERFACES(cbMainSinkSoundPropertyChanged(sinkID,SoundProperty)) + CALL_ALL_INTERFACES(cbMainSinkSoundPropertyChanged(sinkID, SoundProperty)) } -void CAmCommandSender::cbMainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s& SoundProperty) +void CAmCommandSender::cbMainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s &SoundProperty) { - CALL_ALL_INTERFACES(cbMainSourceSoundPropertyChanged(sourceID,SoundProperty)) + CALL_ALL_INTERFACES(cbMainSourceSoundPropertyChanged(sourceID, SoundProperty)) } -void CAmCommandSender::cbSinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s & availability) +void CAmCommandSender::cbSinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s &availability) { - CALL_ALL_INTERFACES(cbSinkAvailabilityChanged(sinkID,availability)) + CALL_ALL_INTERFACES(cbSinkAvailabilityChanged(sinkID, availability)) } -void CAmCommandSender::cbSourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s & availability) +void CAmCommandSender::cbSourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s &availability) { - CALL_ALL_INTERFACES(cbSourceAvailabilityChanged(sourceID,availability)) + CALL_ALL_INTERFACES(cbSourceAvailabilityChanged(sourceID, availability)) } void CAmCommandSender::cbVolumeChanged(const am_sinkID_t sinkID, const am_mainVolume_t volume) { - CALL_ALL_INTERFACES(cbVolumeChanged(sinkID,volume)) + CALL_ALL_INTERFACES(cbVolumeChanged(sinkID, volume)) } void CAmCommandSender::cbSinkMuteStateChanged(const am_sinkID_t sinkID, const am_MuteState_e muteState) { - CALL_ALL_INTERFACES(cbSinkMuteStateChanged(sinkID,muteState)) + CALL_ALL_INTERFACES(cbSinkMuteStateChanged(sinkID, muteState)) } -void CAmCommandSender::cbSystemPropertyChanged(const am_SystemProperty_s & SystemProperty) +void CAmCommandSender::cbSystemPropertyChanged(const am_SystemProperty_s &SystemProperty) { CALL_ALL_INTERFACES(cbSystemPropertyChanged(SystemProperty)) } void CAmCommandSender::cbTimingInformationChanged(const am_mainConnectionID_t mainConnection, const am_timeSync_t time) { - CALL_ALL_INTERFACES(cbTimingInformationChanged(mainConnection,time)) + CALL_ALL_INTERFACES(cbTimingInformationChanged(mainConnection, time)) } void CAmCommandSender::cbNewMainConnection(const am_MainConnectionType_s mainConnection) @@ -369,20 +379,20 @@ void CAmCommandSender::setCommandReady() { mCommandReceiver->waitOnStartup(false); - //create a list of handles + // create a list of handles std::vector listStartupHandles; for (size_t i = 0; i < mListInterfaces.size(); i++) { listStartupHandles.push_back(mCommandReceiver->getStartupHandle()); } - //set the receiver ready to wait for replies + // set the receiver ready to wait for replies mCommandReceiver->waitOnStartup(true); - //now do the calls - std::vector::iterator iter = mListInterfaces.begin(); - std::vector::iterator iterEnd = mListInterfaces.end(); - std::vector::const_iterator handleIter(listStartupHandles.begin()); + // now do the calls + std::vector::iterator iter = mListInterfaces.begin(); + std::vector::iterator iterEnd = mListInterfaces.end(); + std::vector::const_iterator handleIter(listStartupHandles.begin()); for (; iter < iterEnd; ++iter) { (*iter)->setCommandReady(*(handleIter++)); @@ -392,74 +402,75 @@ void CAmCommandSender::setCommandReady() void CAmCommandSender::setCommandRundown() { mCommandReceiver->waitOnRundown(false); - //create a list of handles + // create a list of handles std::vector listStartupHandles; for (size_t i = 0; i < mListInterfaces.size(); i++) { listStartupHandles.push_back(mCommandReceiver->getRundownHandle()); } - //set the receiver ready to wait for replies + // set the receiver ready to wait for replies mCommandReceiver->waitOnRundown(true); - //now do the calls - std::vector::iterator iter = mListInterfaces.begin(); - std::vector::iterator iterEnd = mListInterfaces.end(); - std::vector::const_iterator handleIter(listStartupHandles.begin()); + // now do the calls + std::vector::iterator iter = mListInterfaces.begin(); + std::vector::iterator iterEnd = mListInterfaces.end(); + std::vector::const_iterator handleIter(listStartupHandles.begin()); for (; iter < iterEnd; ++iter) { (*iter)->setCommandRundown(*(handleIter++)); } } -void CAmCommandSender::getInterfaceVersion(std::string & version) const +void CAmCommandSender::getInterfaceVersion(std::string &version) const { version = CommandVersion; } -am_Error_e am::CAmCommandSender::getListPlugins(std::vector & interfaces) const +am_Error_e am::CAmCommandSender::getListPlugins(std::vector &interfaces) const { interfaces = mListLibraryNames; return (E_OK); } -void CAmCommandSender::cbSinkUpdated(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector& listMainSoundProperties) +void CAmCommandSender::cbSinkUpdated(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector &listMainSoundProperties) { - CALL_ALL_INTERFACES(cbSinkUpdated(sinkID,sinkClassID,listMainSoundProperties)); + CALL_ALL_INTERFACES(cbSinkUpdated(sinkID, sinkClassID, listMainSoundProperties)); } -void CAmCommandSender::cbSourceUpdated(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector& listMainSoundProperties) +void CAmCommandSender::cbSourceUpdated(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector &listMainSoundProperties) { - CALL_ALL_INTERFACES(cbSourceUpdated(sourceID,sourceClassID,listMainSoundProperties)); + CALL_ALL_INTERFACES(cbSourceUpdated(sourceID, sourceClassID, listMainSoundProperties)); } -void CAmCommandSender::cbSinkNotification(const am_sinkID_t sinkID, const am_NotificationPayload_s& notification) +void CAmCommandSender::cbSinkNotification(const am_sinkID_t sinkID, const am_NotificationPayload_s ¬ification) { - CALL_ALL_INTERFACES(cbSinkNotification(sinkID,notification)); + CALL_ALL_INTERFACES(cbSinkNotification(sinkID, notification)); } -void CAmCommandSender::cbSourceNotification(const am_sourceID_t sourceID, const am_NotificationPayload_s& notification) +void CAmCommandSender::cbSourceNotification(const am_sourceID_t sourceID, const am_NotificationPayload_s ¬ification) { - CALL_ALL_INTERFACES(cbSourceNotification(sourceID,notification)); + CALL_ALL_INTERFACES(cbSourceNotification(sourceID, notification)); } -void CAmCommandSender::cbSinkMainNotificationConfigurationChanged(const am_sinkID_t sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration) +void CAmCommandSender::cbSinkMainNotificationConfigurationChanged(const am_sinkID_t sinkID, const am_NotificationConfiguration_s &mainNotificationConfiguration) { - CALL_ALL_INTERFACES(cbMainSinkNotificationConfigurationChanged(sinkID,mainNotificationConfiguration)); + CALL_ALL_INTERFACES(cbMainSinkNotificationConfigurationChanged(sinkID, mainNotificationConfiguration)); } -void CAmCommandSender::cbSourceMainNotificationConfigurationChanged(const am_sourceID_t sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration) +void CAmCommandSender::cbSourceMainNotificationConfigurationChanged(const am_sourceID_t sourceID, const am_NotificationConfiguration_s &mainNotificationConfiguration) { - CALL_ALL_INTERFACES(cbMainSourceNotificationConfigurationChanged(sourceID,mainNotificationConfiguration)); + CALL_ALL_INTERFACES(cbMainSourceNotificationConfigurationChanged(sourceID, mainNotificationConfiguration)); } void CAmCommandSender::unloadLibraries(void) { - std::vector::iterator iterator = mListLibraryHandles.begin(); + std::vector::iterator iterator = mListLibraryHandles.begin(); for (; iterator < mListLibraryHandles.end(); ++iterator) { dlclose(*iterator); } + mListLibraryHandles.clear(); } diff --git a/AudioManagerCore/src/CAmControlReceiver.cpp b/AudioManagerCore/src/CAmControlReceiver.cpp index 3280c04..6fec509 100644 --- a/AudioManagerCore/src/CAmControlReceiver.cpp +++ b/AudioManagerCore/src/CAmControlReceiver.cpp @@ -35,78 +35,78 @@ namespace am { -#define __METHOD_NAME__ std::string (std::string("CAmControlReceiver::") + __func__) +#define __METHOD_NAME__ std::string(std::string("CAmControlReceiver::") + __func__) -CAmControlReceiver::CAmControlReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmCommandSender *iCommandSender, CAmSocketHandler *iSocketHandler, CAmRouter* iRouter) : - mDatabaseHandler(iDatabaseHandler), - mRoutingSender(iRoutingSender), - mCommandSender(iCommandSender), - mSocketHandler(iSocketHandler), - mRouter(iRouter), - mNodeStateCommunicator(NULL) +CAmControlReceiver::CAmControlReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmCommandSender *iCommandSender, CAmSocketHandler *iSocketHandler, CAmRouter *iRouter) + : mDatabaseHandler(iDatabaseHandler) + , mRoutingSender(iRoutingSender) + , mCommandSender(iCommandSender) + , mSocketHandler(iSocketHandler) + , mRouter(iRouter) + , mNodeStateCommunicator(NULL) { - assert(mDatabaseHandler!=NULL); - assert(mRoutingSender!=NULL); - assert(mCommandSender!=NULL); - assert(mSocketHandler!=NULL); - assert(mRouter!=NULL); + assert(mDatabaseHandler != NULL); + assert(mRoutingSender != NULL); + assert(mCommandSender != NULL); + assert(mSocketHandler != NULL); + assert(mRouter != NULL); } CAmControlReceiver::~CAmControlReceiver() { } -am_Error_e CAmControlReceiver::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector & returnList) +am_Error_e CAmControlReceiver::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector &returnList) { return (mRouter->getRoute(onlyfree, sourceID, sinkID, returnList)); } -am_Error_e CAmControlReceiver::connect(am_Handle_s & handle, am_connectionID_t & connectionID, const am_CustomConnectionFormat_t format, const am_sourceID_t sourceID, const am_sinkID_t sinkID) +am_Error_e CAmControlReceiver::connect(am_Handle_s &handle, am_connectionID_t &connectionID, const am_CustomConnectionFormat_t format, const am_sourceID_t sourceID, const am_sinkID_t sinkID) { - return (mRoutingSender->asyncConnect(handle, connectionID, sourceID, sinkID, format)); + return (mRoutingSender->asyncConnect(handle, connectionID, sourceID, sinkID, format)); } -am_Error_e CAmControlReceiver::disconnect(am_Handle_s & handle, const am_connectionID_t connectionID) +am_Error_e CAmControlReceiver::disconnect(am_Handle_s &handle, const am_connectionID_t connectionID) { return (mRoutingSender->asyncDisconnect(handle, connectionID)); } -am_Error_e CAmControlReceiver::crossfade(am_Handle_s & handle, const am_HotSink_e hotSource, const am_crossfaderID_t crossfaderID, const am_CustomRampType_t rampType, const am_time_t rampTime) +am_Error_e CAmControlReceiver::crossfade(am_Handle_s &handle, const am_HotSink_e hotSource, const am_crossfaderID_t crossfaderID, const am_CustomRampType_t rampType, const am_time_t rampTime) { return (mRoutingSender->asyncCrossFade(handle, crossfaderID, hotSource, rampType, rampTime)); } -am_Error_e CAmControlReceiver::setSourceState(am_Handle_s & handle, const am_sourceID_t sourceID, const am_SourceState_e state) +am_Error_e CAmControlReceiver::setSourceState(am_Handle_s &handle, const am_sourceID_t sourceID, const am_SourceState_e state) { return (mRoutingSender->asyncSetSourceState(handle, sourceID, state)); } -am_Error_e CAmControlReceiver::setSinkVolume(am_Handle_s & handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_CustomRampType_t ramp, const am_time_t time) +am_Error_e CAmControlReceiver::setSinkVolume(am_Handle_s &handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_CustomRampType_t ramp, const am_time_t time) { return (mRoutingSender->asyncSetSinkVolume(handle, sinkID, volume, ramp, time)); } -am_Error_e CAmControlReceiver::setSourceVolume(am_Handle_s & handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_CustomRampType_t rampType, const am_time_t time) +am_Error_e CAmControlReceiver::setSourceVolume(am_Handle_s &handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_CustomRampType_t rampType, const am_time_t time) { return (mRoutingSender->asyncSetSourceVolume(handle, sourceID, volume, rampType, time)); } -am_Error_e CAmControlReceiver::setSinkSoundProperty(am_Handle_s & handle, const am_sinkID_t sinkID, const am_SoundProperty_s & soundProperty) +am_Error_e CAmControlReceiver::setSinkSoundProperty(am_Handle_s &handle, const am_sinkID_t sinkID, const am_SoundProperty_s &soundProperty) { return (mRoutingSender->asyncSetSinkSoundProperty(handle, sinkID, soundProperty)); } -am_Error_e CAmControlReceiver::setSinkSoundProperties(am_Handle_s & handle, const am_sinkID_t sinkID, const std::vector & listSoundProperties) +am_Error_e CAmControlReceiver::setSinkSoundProperties(am_Handle_s &handle, const am_sinkID_t sinkID, const std::vector &listSoundProperties) { return (mRoutingSender->asyncSetSinkSoundProperties(handle, listSoundProperties, sinkID)); } -am_Error_e CAmControlReceiver::setSourceSoundProperty(am_Handle_s & handle, const am_sourceID_t sourceID, const am_SoundProperty_s & soundProperty) +am_Error_e CAmControlReceiver::setSourceSoundProperty(am_Handle_s &handle, const am_sourceID_t sourceID, const am_SoundProperty_s &soundProperty) { return (mRoutingSender->asyncSetSourceSoundProperty(handle, sourceID, soundProperty)); } -am_Error_e CAmControlReceiver::setSourceSoundProperties(am_Handle_s & handle, const am_sourceID_t sourceID, const std::vector & listSoundProperties) +am_Error_e CAmControlReceiver::setSourceSoundProperties(am_Handle_s &handle, const am_sourceID_t sourceID, const std::vector &listSoundProperties) { return (mRoutingSender->asyncSetSourceSoundProperties(handle, listSoundProperties, sourceID)); } @@ -121,57 +121,57 @@ am_Error_e CAmControlReceiver::abortAction(const am_Handle_s handle) return (mRoutingSender->asyncAbort(handle)); } -am_Error_e CAmControlReceiver::enterDomainDB(const am_Domain_s & domainData, am_domainID_t & domainID) +am_Error_e CAmControlReceiver::enterDomainDB(const am_Domain_s &domainData, am_domainID_t &domainID) { return (mDatabaseHandler->enterDomainDB(domainData, domainID)); } -am_Error_e CAmControlReceiver::enterMainConnectionDB(const am_MainConnection_s & mainConnectionData, am_mainConnectionID_t & connectionID) +am_Error_e CAmControlReceiver::enterMainConnectionDB(const am_MainConnection_s &mainConnectionData, am_mainConnectionID_t &connectionID) { return (mDatabaseHandler->enterMainConnectionDB(mainConnectionData, connectionID)); } -am_Error_e CAmControlReceiver::enterSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID) +am_Error_e CAmControlReceiver::enterSinkDB(const am_Sink_s &sinkData, am_sinkID_t &sinkID) { return (mDatabaseHandler->enterSinkDB(sinkData, sinkID)); } -am_Error_e CAmControlReceiver::enterCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID) +am_Error_e CAmControlReceiver::enterCrossfaderDB(const am_Crossfader_s &crossfaderData, am_crossfaderID_t &crossfaderID) { return (mDatabaseHandler->enterCrossfaderDB(crossfaderData, crossfaderID)); } -am_Error_e CAmControlReceiver::enterGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID) +am_Error_e CAmControlReceiver::enterGatewayDB(const am_Gateway_s &gatewayData, am_gatewayID_t &gatewayID) { return (mDatabaseHandler->enterGatewayDB(gatewayData, gatewayID)); } -am_Error_e CAmControlReceiver::enterConverterDB(const am_Converter_s & converterData, am_converterID_t & converterID) +am_Error_e CAmControlReceiver::enterConverterDB(const am_Converter_s &converterData, am_converterID_t &converterID) { return (mDatabaseHandler->enterConverterDB(converterData, converterID)); } -am_Error_e CAmControlReceiver::enterSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID) +am_Error_e CAmControlReceiver::enterSourceDB(const am_Source_s &sourceData, am_sourceID_t &sourceID) { return (mDatabaseHandler->enterSourceDB(sourceData, sourceID)); } -am_Error_e CAmControlReceiver::enterSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID) +am_Error_e CAmControlReceiver::enterSinkClassDB(const am_SinkClass_s &sinkClass, am_sinkClass_t &sinkClassID) { return (mDatabaseHandler->enterSinkClassDB(sinkClass, sinkClassID)); } -am_Error_e CAmControlReceiver::enterSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass) +am_Error_e CAmControlReceiver::enterSourceClassDB(am_sourceClass_t &sourceClassID, const am_SourceClass_s &sourceClass) { return (mDatabaseHandler->enterSourceClassDB(sourceClassID, sourceClass)); } -am_Error_e CAmControlReceiver::enterSystemPropertiesListDB(const std::vector & listSystemProperties) +am_Error_e CAmControlReceiver::enterSystemPropertiesListDB(const std::vector &listSystemProperties) { return (mDatabaseHandler->enterSystemProperties(listSystemProperties)); } -am_Error_e CAmControlReceiver::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector& listConnectionID) +am_Error_e CAmControlReceiver::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector &listConnectionID) { return (mDatabaseHandler->changeMainConnectionRouteDB(mainconnectionID, listConnectionID)); } @@ -186,7 +186,7 @@ am_Error_e CAmControlReceiver::changeSinkMainVolumeDB(const am_mainVolume_t main return (mDatabaseHandler->changeSinkMainVolumeDB(mainVolume, sinkID)); } -am_Error_e CAmControlReceiver::changeSinkAvailabilityDB(const am_Availability_s & availability, const am_sinkID_t sinkID) +am_Error_e CAmControlReceiver::changeSinkAvailabilityDB(const am_Availability_s &availability, const am_sinkID_t sinkID) { return (mDatabaseHandler->changeSinkAvailabilityDB(availability, sinkID)); } @@ -201,22 +201,22 @@ am_Error_e CAmControlReceiver::changeSinkMuteStateDB(const am_MuteState_e muteSt return (mDatabaseHandler->changeSinkMuteStateDB(muteState, sinkID)); } -am_Error_e CAmControlReceiver::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID) +am_Error_e CAmControlReceiver::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s &soundProperty, const am_sinkID_t sinkID) { return (mDatabaseHandler->changeMainSinkSoundPropertyDB(soundProperty, sinkID)); } -am_Error_e CAmControlReceiver::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID) +am_Error_e CAmControlReceiver::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s &soundProperty, const am_sourceID_t sourceID) { return (mDatabaseHandler->changeMainSourceSoundPropertyDB(soundProperty, sourceID)); } -am_Error_e CAmControlReceiver::changeSourceAvailabilityDB(const am_Availability_s & availability, const am_sourceID_t sourceID) +am_Error_e CAmControlReceiver::changeSourceAvailabilityDB(const am_Availability_s &availability, const am_sourceID_t sourceID) { return (mDatabaseHandler->changeSourceAvailabilityDB(availability, sourceID)); } -am_Error_e CAmControlReceiver::changeSystemPropertyDB(const am_SystemProperty_s & property) +am_Error_e CAmControlReceiver::changeSystemPropertyDB(const am_SystemProperty_s &property) { return (mDatabaseHandler->changeSystemPropertyDB(property)); } @@ -256,138 +256,137 @@ am_Error_e CAmControlReceiver::removeDomainDB(const am_domainID_t domainID) return (mDatabaseHandler->removeDomainDB(domainID)); } -am_Error_e CAmControlReceiver::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s & classInfo) const +am_Error_e CAmControlReceiver::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s &classInfo) const { return (mDatabaseHandler->getSourceClassInfoDB(sourceID, classInfo)); } -am_Error_e CAmControlReceiver::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s & sinkClass) const +am_Error_e CAmControlReceiver::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s &sinkClass) const { return (mDatabaseHandler->getSinkClassInfoDB(sinkID, sinkClass)); } -am_Error_e CAmControlReceiver::getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s & sinkData) const +am_Error_e CAmControlReceiver::getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s &sinkData) const { return (mDatabaseHandler->getSinkInfoDB(sinkID, sinkData)); } -am_Error_e CAmControlReceiver::getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s & sourceData) const +am_Error_e CAmControlReceiver::getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s &sourceData) const { return (mDatabaseHandler->getSourceInfoDB(sourceID, sourceData)); } -am_Error_e CAmControlReceiver::getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s & mainConnectionData) const +am_Error_e CAmControlReceiver::getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s &mainConnectionData) const { return (mDatabaseHandler->getMainConnectionInfoDB(mainConnectionID, mainConnectionData)); } -am_Error_e CAmControlReceiver::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s & gatewayData) const +am_Error_e CAmControlReceiver::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s &gatewayData) const { return (mDatabaseHandler->getGatewayInfoDB(gatewayID, gatewayData)); } -am_Error_e CAmControlReceiver::getConverterInfoDB(const am_converterID_t converterID, am_Converter_s & converterData) const +am_Error_e CAmControlReceiver::getConverterInfoDB(const am_converterID_t converterID, am_Converter_s &converterData) const { return (mDatabaseHandler->getConverterInfoDB(converterID, converterData)); } - -am_Error_e CAmControlReceiver::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s & crossfaderData) const +am_Error_e CAmControlReceiver::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s &crossfaderData) const { return (mDatabaseHandler->getCrossfaderInfoDB(crossfaderID, crossfaderData)); } -am_Error_e CAmControlReceiver::getListSinksOfDomain(const am_domainID_t domainID, std::vector & listSinkID) const +am_Error_e CAmControlReceiver::getListSinksOfDomain(const am_domainID_t domainID, std::vector &listSinkID) const { return (mDatabaseHandler->getListSinksOfDomain(domainID, listSinkID)); } -am_Error_e CAmControlReceiver::getListSourcesOfDomain(const am_domainID_t domainID, std::vector & listSourceID) const +am_Error_e CAmControlReceiver::getListSourcesOfDomain(const am_domainID_t domainID, std::vector &listSourceID) const { return (mDatabaseHandler->getListSourcesOfDomain(domainID, listSourceID)); } -am_Error_e CAmControlReceiver::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector & listGatewaysID) const +am_Error_e CAmControlReceiver::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector &listGatewaysID) const { return (mDatabaseHandler->getListCrossfadersOfDomain(domainID, listGatewaysID)); } -am_Error_e CAmControlReceiver::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector & listGatewaysID) const +am_Error_e CAmControlReceiver::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector &listGatewaysID) const { return (mDatabaseHandler->getListGatewaysOfDomain(domainID, listGatewaysID)); } -am_Error_e CAmControlReceiver::getListConvertersOfDomain(const am_domainID_t domainID,std::vector& listConverterID) const +am_Error_e CAmControlReceiver::getListConvertersOfDomain(const am_domainID_t domainID, std::vector &listConverterID) const { - return (mDatabaseHandler->getListConvertersOfDomain(domainID,listConverterID)); + return (mDatabaseHandler->getListConvertersOfDomain(domainID, listConverterID)); } -am_Error_e CAmControlReceiver::getListMainConnections(std::vector & listMainConnections) const +am_Error_e CAmControlReceiver::getListMainConnections(std::vector &listMainConnections) const { return (mDatabaseHandler->getListMainConnections(listMainConnections)); } -am_Error_e CAmControlReceiver::getListDomains(std::vector & listDomains) const +am_Error_e CAmControlReceiver::getListDomains(std::vector &listDomains) const { return (mDatabaseHandler->getListDomains(listDomains)); } -am_Error_e CAmControlReceiver::getListConnections(std::vector & listConnections) const +am_Error_e CAmControlReceiver::getListConnections(std::vector &listConnections) const { return (mDatabaseHandler->getListConnections(listConnections)); } -am_Error_e CAmControlReceiver::getListSinks(std::vector & listSinks) const +am_Error_e CAmControlReceiver::getListSinks(std::vector &listSinks) const { return (mDatabaseHandler->getListSinks(listSinks)); } -am_Error_e CAmControlReceiver::getListSources(std::vector & listSources) const +am_Error_e CAmControlReceiver::getListSources(std::vector &listSources) const { return (mDatabaseHandler->getListSources(listSources)); } -am_Error_e CAmControlReceiver::getListSourceClasses(std::vector & listSourceClasses) const +am_Error_e CAmControlReceiver::getListSourceClasses(std::vector &listSourceClasses) const { return (mDatabaseHandler->getListSourceClasses(listSourceClasses)); } -am_Error_e CAmControlReceiver::getListHandles(std::vector & listHandles) const +am_Error_e CAmControlReceiver::getListHandles(std::vector &listHandles) const { return (mRoutingSender->getListHandles(listHandles)); } -am_Error_e CAmControlReceiver::getListCrossfaders(std::vector & listCrossfaders) const +am_Error_e CAmControlReceiver::getListCrossfaders(std::vector &listCrossfaders) const { return (mDatabaseHandler->getListCrossfaders(listCrossfaders)); } -am_Error_e CAmControlReceiver::getListGateways(std::vector & listGateways) const +am_Error_e CAmControlReceiver::getListGateways(std::vector &listGateways) const { return (mDatabaseHandler->getListGateways(listGateways)); } -am_Error_e CAmControlReceiver::getListConverters(std::vector& listConverters) const +am_Error_e CAmControlReceiver::getListConverters(std::vector &listConverters) const { return (mDatabaseHandler->getListConverters(listConverters)); } -am_Error_e CAmControlReceiver::getListSinkClasses(std::vector & listSinkClasses) const +am_Error_e CAmControlReceiver::getListSinkClasses(std::vector &listSinkClasses) const { return (mDatabaseHandler->getListSinkClasses(listSinkClasses)); } -am_Error_e CAmControlReceiver::getListSystemProperties(std::vector & listSystemProperties) const +am_Error_e CAmControlReceiver::getListSystemProperties(std::vector &listSystemProperties) const { return (mDatabaseHandler->getListSystemProperties(listSystemProperties)); } -am_Error_e CAmControlReceiver::changeSinkClassInfoDB(const am_SinkClass_s & classInfo) +am_Error_e CAmControlReceiver::changeSinkClassInfoDB(const am_SinkClass_s &classInfo) { return (mDatabaseHandler->changeSinkClassInfoDB(classInfo)); } -am_Error_e CAmControlReceiver::changeSourceClassInfoDB(const am_SourceClass_s & classInfo) +am_Error_e CAmControlReceiver::changeSourceClassInfoDB(const am_SourceClass_s &classInfo) { return(mDatabaseHandler->changeSourceClassInfoDB(classInfo)); } @@ -410,32 +409,34 @@ void CAmControlReceiver::setCommandReady() void CAmControlReceiver::setRoutingReady() { - logVerbose(__METHOD_NAME__); + logVerbose(__METHOD_NAME__); mRoutingSender->setRoutingReady(); } void CAmControlReceiver::confirmControllerReady(const am_Error_e error) { - if (error!=E_OK) - logError(__METHOD_NAME__,"controller reported error", error); + if (error != E_OK) + { + logError(__METHOD_NAME__, "controller reported error", error); + } } void CAmControlReceiver::confirmControllerRundown(const am_Error_e error) { - if (error!=E_OK) - { - logError(__METHOD_NAME__,"exited with error ",error); - //we might be blocked here -> so lets better exit right away - throw std::runtime_error("controller Confirmed with error"); - } + if (error != E_OK) + { + logError(__METHOD_NAME__, "exited with error ", error); + // we might be blocked here -> so lets better exit right away + throw std::runtime_error("controller Confirmed with error"); + } - logVerbose (__METHOD_NAME__,"will exit now"); + logVerbose(__METHOD_NAME__, "will exit now"); - //end the mainloop here... - mSocketHandler->exit_mainloop(); + // end the mainloop here... + mSocketHandler->exit_mainloop(); } -am_Error_e CAmControlReceiver::getSocketHandler(CAmSocketHandler *& socketHandler) +am_Error_e CAmControlReceiver::getSocketHandler(CAmSocketHandler * &socketHandler) { socketHandler = mSocketHandler; return (E_OK); @@ -443,7 +444,7 @@ am_Error_e CAmControlReceiver::getSocketHandler(CAmSocketHandler *& socketHandle void CAmControlReceiver::setCommandRundown() { - logInfo(__METHOD_NAME__); + logInfo(__METHOD_NAME__); mCommandSender->setCommandRundown(); } @@ -453,129 +454,128 @@ void CAmControlReceiver::setRoutingRundown() mRoutingSender->setRoutingRundown(); } -void CAmControlReceiver::getInterfaceVersion(std::string & version) const +void CAmControlReceiver::getInterfaceVersion(std::string &version) const { version = ControlVersion; } -am_Error_e CAmControlReceiver::changeSourceDB(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector& listSoundProperties, const std::vector& listConnectionFormats, const std::vector& listMainSoundProperties) +am_Error_e CAmControlReceiver::changeSourceDB(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector &listSoundProperties, const std::vector &listConnectionFormats, const std::vector &listMainSoundProperties) { - return (mDatabaseHandler->changeSourceDB(sourceID,sourceClassID,listSoundProperties,listConnectionFormats,listMainSoundProperties)); + return (mDatabaseHandler->changeSourceDB(sourceID, sourceClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties)); } -am_Error_e CAmControlReceiver::changeSinkDB(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector& listSoundProperties, const std::vector& listConnectionFormats, const std::vector& listMainSoundProperties) +am_Error_e CAmControlReceiver::changeSinkDB(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector &listSoundProperties, const std::vector &listConnectionFormats, const std::vector &listMainSoundProperties) { - return (mDatabaseHandler->changeSinkDB(sinkID,sinkClassID,listSoundProperties,listConnectionFormats,listMainSoundProperties)); + return (mDatabaseHandler->changeSinkDB(sinkID, sinkClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties)); } -am_Error_e CAmControlReceiver::changeGatewayDB(const am_gatewayID_t gatewayID, const std::vector& listSourceConnectionFormats, const std::vector& listSinkConnectionFormats, const std::vector& convertionMatrix) +am_Error_e CAmControlReceiver::changeGatewayDB(const am_gatewayID_t gatewayID, const std::vector &listSourceConnectionFormats, const std::vector &listSinkConnectionFormats, const std::vector &convertionMatrix) { - return (mDatabaseHandler->changeGatewayDB(gatewayID,listSourceConnectionFormats,listSinkConnectionFormats,convertionMatrix)); + return (mDatabaseHandler->changeGatewayDB(gatewayID, listSourceConnectionFormats, listSinkConnectionFormats, convertionMatrix)); } -am_Error_e CAmControlReceiver::changeConverterDB(const am_converterID_t converterID, const std::vector& listSourceConnectionFormats, const std::vector& listSinkConnectionFormats, const std::vector& convertionMatrix) +am_Error_e CAmControlReceiver::changeConverterDB(const am_converterID_t converterID, const std::vector &listSourceConnectionFormats, const std::vector &listSinkConnectionFormats, const std::vector &convertionMatrix) { - return (mDatabaseHandler->changeConverterDB(converterID,listSourceConnectionFormats,listSinkConnectionFormats,convertionMatrix)); + return (mDatabaseHandler->changeConverterDB(converterID, listSourceConnectionFormats, listSinkConnectionFormats, convertionMatrix)); } -am_Error_e CAmControlReceiver::setVolumes(am_Handle_s& handle, const std::vector& listVolumes) +am_Error_e CAmControlReceiver::setVolumes(am_Handle_s &handle, const std::vector &listVolumes) { - return (mRoutingSender->asyncSetVolumes(handle,listVolumes)); + return (mRoutingSender->asyncSetVolumes(handle, listVolumes)); } -am_Error_e CAmControlReceiver::setSinkNotificationConfiguration(am_Handle_s& handle, const am_sinkID_t sinkID, const am_NotificationConfiguration_s& notificationConfiguration) +am_Error_e CAmControlReceiver::setSinkNotificationConfiguration(am_Handle_s &handle, const am_sinkID_t sinkID, const am_NotificationConfiguration_s ¬ificationConfiguration) { - return (mRoutingSender->asyncSetSinkNotificationConfiguration(handle,sinkID,notificationConfiguration)); + return (mRoutingSender->asyncSetSinkNotificationConfiguration(handle, sinkID, notificationConfiguration)); } -am_Error_e CAmControlReceiver::setSourceNotificationConfiguration(am_Handle_s& handle, const am_sourceID_t sourceID, const am_NotificationConfiguration_s& notificationConfiguration) +am_Error_e CAmControlReceiver::setSourceNotificationConfiguration(am_Handle_s &handle, const am_sourceID_t sourceID, const am_NotificationConfiguration_s ¬ificationConfiguration) { - return (mRoutingSender->asyncSetSourceNotificationConfiguration(handle,sourceID,notificationConfiguration)); + return (mRoutingSender->asyncSetSourceNotificationConfiguration(handle, sourceID, notificationConfiguration)); } -void CAmControlReceiver::sendMainSinkNotificationPayload(const am_sinkID_t sinkID, const am_NotificationPayload_s& notificationPayload) +void CAmControlReceiver::sendMainSinkNotificationPayload(const am_sinkID_t sinkID, const am_NotificationPayload_s ¬ificationPayload) { - logVerbose(__METHOD_NAME__,"sinkID=",sinkID,"type=",notificationPayload.type,"value=",notificationPayload.value); - mCommandSender->cbSinkNotification(sinkID,notificationPayload); + logVerbose(__METHOD_NAME__, "sinkID=", sinkID, "type=", notificationPayload.type, "value=", notificationPayload.value); + mCommandSender->cbSinkNotification(sinkID, notificationPayload); } -void CAmControlReceiver::sendMainSourceNotificationPayload(const am_sourceID_t sourceID, const am_NotificationPayload_s& notificationPayload) +void CAmControlReceiver::sendMainSourceNotificationPayload(const am_sourceID_t sourceID, const am_NotificationPayload_s ¬ificationPayload) { - logVerbose(__METHOD_NAME__,"sourceID=",sourceID,"type=",notificationPayload.type,"value=",notificationPayload.value); - mCommandSender->cbSourceNotification(sourceID,notificationPayload); + logVerbose(__METHOD_NAME__, "sourceID=", sourceID, "type=", notificationPayload.type, "value=", notificationPayload.value); + mCommandSender->cbSourceNotification(sourceID, notificationPayload); } -am_Error_e CAmControlReceiver::changeMainSinkNotificationConfigurationDB(const am_sinkID_t sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration) +am_Error_e CAmControlReceiver::changeMainSinkNotificationConfigurationDB(const am_sinkID_t sinkID, const am_NotificationConfiguration_s &mainNotificationConfiguration) { - logVerbose(__METHOD_NAME__,"sinkID", sinkID); - return (mDatabaseHandler->changeMainSinkNotificationConfigurationDB(sinkID,mainNotificationConfiguration)); + logVerbose(__METHOD_NAME__, "sinkID", sinkID); + return (mDatabaseHandler->changeMainSinkNotificationConfigurationDB(sinkID, mainNotificationConfiguration)); } -am_Error_e CAmControlReceiver::changeMainSourceNotificationConfigurationDB(const am_sourceID_t sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration) +am_Error_e CAmControlReceiver::changeMainSourceNotificationConfigurationDB(const am_sourceID_t sourceID, const am_NotificationConfiguration_s &mainNotificationConfiguration) { - logVerbose(__METHOD_NAME__,"sourceID", sourceID); - return (mDatabaseHandler->changeMainSourceNotificationConfigurationDB(sourceID,mainNotificationConfiguration)); + logVerbose(__METHOD_NAME__, "sourceID", sourceID); + return (mDatabaseHandler->changeMainSourceNotificationConfigurationDB(sourceID, mainNotificationConfiguration)); } -am_Error_e CAmControlReceiver::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector& listSoundproperties) const +am_Error_e CAmControlReceiver::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector &listSoundproperties) const { - logVerbose(__METHOD_NAME__,"sinkID", sinkID); - return (mDatabaseHandler->getListMainSinkSoundProperties(sinkID,listSoundproperties)); + logVerbose(__METHOD_NAME__, "sinkID", sinkID); + return (mDatabaseHandler->getListMainSinkSoundProperties(sinkID, listSoundproperties)); } -am_Error_e CAmControlReceiver::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector& listSoundproperties) const +am_Error_e CAmControlReceiver::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector &listSoundproperties) const { - logVerbose(__METHOD_NAME__,"sourceID", sourceID); - return (mDatabaseHandler->getListMainSourceSoundProperties(sourceID, listSoundproperties)); + logVerbose(__METHOD_NAME__, "sourceID", sourceID); + return (mDatabaseHandler->getListMainSourceSoundProperties(sourceID, listSoundproperties)); } -am_Error_e CAmControlReceiver::getListSinkSoundProperties(const am_sinkID_t sinkID, std::vector& listSoundproperties) const +am_Error_e CAmControlReceiver::getListSinkSoundProperties(const am_sinkID_t sinkID, std::vector &listSoundproperties) const { - logVerbose(__METHOD_NAME__,"sinkID", sinkID); - return (mDatabaseHandler->getListSinkSoundProperties(sinkID,listSoundproperties)); + logVerbose(__METHOD_NAME__, "sinkID", sinkID); + return (mDatabaseHandler->getListSinkSoundProperties(sinkID, listSoundproperties)); } -am_Error_e CAmControlReceiver::getListSourceSoundProperties(const am_sourceID_t sourceID, std::vector& listSoundproperties) const +am_Error_e CAmControlReceiver::getListSourceSoundProperties(const am_sourceID_t sourceID, std::vector &listSoundproperties) const { - logVerbose(__METHOD_NAME__,"sourceID", sourceID); - return (mDatabaseHandler->getListSourceSoundProperties(sourceID, listSoundproperties)); + logVerbose(__METHOD_NAME__, "sourceID", sourceID); + return (mDatabaseHandler->getListSourceSoundProperties(sourceID, listSoundproperties)); } -am_Error_e CAmControlReceiver::getMainSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomMainSoundPropertyType_t propertyType, int16_t& value) const +am_Error_e CAmControlReceiver::getMainSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomMainSoundPropertyType_t propertyType, int16_t &value) const { - logVerbose(__METHOD_NAME__,"sinkID", sinkID); - return (mDatabaseHandler->getMainSinkSoundPropertyValue(sinkID,propertyType,value)); + logVerbose(__METHOD_NAME__, "sinkID", sinkID); + return (mDatabaseHandler->getMainSinkSoundPropertyValue(sinkID, propertyType, value)); } -am_Error_e CAmControlReceiver::getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomSoundPropertyType_t propertyType, int16_t& value) const +am_Error_e CAmControlReceiver::getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomSoundPropertyType_t propertyType, int16_t &value) const { - logVerbose(__METHOD_NAME__,"sinkID", sinkID); - return (mDatabaseHandler->getSinkSoundPropertyValue(sinkID,propertyType,value)); + logVerbose(__METHOD_NAME__, "sinkID", sinkID); + return (mDatabaseHandler->getSinkSoundPropertyValue(sinkID, propertyType, value)); } -am_Error_e CAmControlReceiver::getMainSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomMainSoundPropertyType_t propertyType, int16_t& value) const +am_Error_e CAmControlReceiver::getMainSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomMainSoundPropertyType_t propertyType, int16_t &value) const { - logVerbose(__METHOD_NAME__,"sourceID", sourceID); - return (mDatabaseHandler->getMainSourceSoundPropertyValue(sourceID,propertyType,value)); + logVerbose(__METHOD_NAME__, "sourceID", sourceID); + return (mDatabaseHandler->getMainSourceSoundPropertyValue(sourceID, propertyType, value)); } -am_Error_e CAmControlReceiver::getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomSoundPropertyType_t propertyType, int16_t& value) const +am_Error_e CAmControlReceiver::getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomSoundPropertyType_t propertyType, int16_t &value) const { - logVerbose(__METHOD_NAME__,"sourceID", sourceID); - return (mDatabaseHandler->getSourceSoundPropertyValue(sourceID,propertyType,value)); + logVerbose(__METHOD_NAME__, "sourceID", sourceID); + return (mDatabaseHandler->getSourceSoundPropertyValue(sourceID, propertyType, value)); } -am_Error_e CAmControlReceiver::resyncConnectionState(const am_domainID_t domainID,std::vector& listOfExistingConnections) +am_Error_e CAmControlReceiver::resyncConnectionState(const am_domainID_t domainID, std::vector &listOfExistingConnections) { - logInfo(__METHOD_NAME__,"domainID", domainID); - return (mRoutingSender->resyncConnectionState(domainID,listOfExistingConnections)); + logInfo(__METHOD_NAME__, "domainID", domainID); + return (mRoutingSender->resyncConnectionState(domainID, listOfExistingConnections)); } am_Error_e CAmControlReceiver::removeHandle(const am_Handle_s handle) { - logInfo(__METHOD_NAME__,"handle", handle.handle); - return (mRoutingSender->removeHandle(handle)); + logInfo(__METHOD_NAME__, "handle", handle.handle); + return (mRoutingSender->removeHandle(handle)); } } - diff --git a/AudioManagerCore/src/CAmControlSender.cpp b/AudioManagerCore/src/CAmControlSender.cpp index d80460d..1baeb30 100644 --- a/AudioManagerCore/src/CAmControlSender.cpp +++ b/AudioManagerCore/src/CAmControlSender.cpp @@ -37,25 +37,25 @@ namespace am { -#define REQUIRED_INTERFACE_VERSION_MAJOR 1 //!< major interface version. All versions smaller than this will be rejected +#define REQUIRED_INTERFACE_VERSION_MAJOR 1 //!< major interface version. All versions smaller than this will be rejected #define REQUIRED_INTERFACE_VERSION_MINOR 0 //!< minor interface version. All versions smaller than this will be rejected -CAmControlSender* CAmControlSender::mInstance=NULL; +CAmControlSender *CAmControlSender::mInstance = NULL; -CAmControlSender::CAmControlSender(std::string controlPluginFile,CAmSocketHandler* sockethandler) : - receiverCallbackT(this, &CAmControlSender::receiverCallback), - checkerCallbackT(this, &CAmControlSender::checkerCallback), - dispatcherCallbackT(this, &CAmControlSender::dispatcherCallback), - mPipe(), - mlibHandle(NULL), - mController(NULL), - mSignal(0) +CAmControlSender::CAmControlSender(std::string controlPluginFile, CAmSocketHandler *sockethandler) + : receiverCallbackT(this, &CAmControlSender::receiverCallback) + , checkerCallbackT(this, &CAmControlSender::checkerCallback) + , dispatcherCallbackT(this, &CAmControlSender::dispatcherCallback) + , mPipe() + , mlibHandle(NULL) + , mController(NULL) + , mSignal(0) { assert(sockethandler); - //Check if a folder is given, then select the first plugin + // Check if a folder is given, then select the first plugin struct stat buf; - const char* conFile(controlPluginFile.c_str()); + const char *conFile(controlPluginFile.c_str()); stat(conFile, &buf); if (S_ISDIR(buf.st_mode)) { @@ -74,35 +74,38 @@ CAmControlSender::CAmControlSender(std::string controlPluginFile,CAmSocketHandle while ((itemInDirectory = readdir(directory))) { unsigned char entryType = itemInDirectory->d_type; - std::string entryName = itemInDirectory->d_name; - std::string fullName = directoryName + "/" + entryName; + std::string entryName = itemInDirectory->d_name; + std::string fullName = directoryName + "/" + entryName; - bool regularFile = (entryType == DT_REG || entryType == DT_LNK); + bool regularFile = (entryType == DT_REG || entryType == DT_LNK); bool sharedLibExtension = ("so" == entryName.substr(entryName.find_last_of(".") + 1)); // Handle cases where readdir() could not determine the file type - if (entryType == DT_UNKNOWN) { - struct stat buf; + if (entryType == DT_UNKNOWN) + { + struct stat buf; - if (stat(fullName.c_str(), &buf)) { - logInfo(__PRETTY_FUNCTION__,"Failed to stat file: ", entryName, errno); - continue; - } + if (stat(fullName.c_str(), &buf)) + { + logInfo(__PRETTY_FUNCTION__, "Failed to stat file: ", entryName, errno); + continue; + } - regularFile = S_ISREG(buf.st_mode); - } + regularFile = S_ISREG(buf.st_mode); + } if (regularFile && sharedLibExtension) { - controlPluginFile=directoryName + "/" + entryName; - logInfo("Found ControlPlugin:", controlPluginFile); - break; + controlPluginFile = directoryName + "/" + entryName; + logInfo("Found ControlPlugin:", controlPluginFile); + break; } } + closedir(directory); - + } - + std::ifstream isfile(controlPluginFile.c_str()); if (!isfile) { @@ -111,13 +114,13 @@ CAmControlSender::CAmControlSender(std::string controlPluginFile,CAmSocketHandle } else if (!controlPluginFile.empty()) { - mInstance=this; - IAmControlSend* (*createFunc)(); - createFunc = getCreateFunction(controlPluginFile, mlibHandle); - assert(createFunc!=NULL); - mController = createFunc(); + mInstance = this; + IAmControlSend *(*createFunc)(); + createFunc = getCreateFunction(controlPluginFile, mlibHandle); + assert(createFunc != NULL); + mController = createFunc(); mControlPluginFile = controlPluginFile; - //check libversion + // check libversion std::string version, cVersion(ControlVersion); mController->getInterfaceVersion(version); uint16_t minorVersion, majorVersion, cMinorVersion, cMajorVersion; @@ -125,12 +128,10 @@ CAmControlSender::CAmControlSender(std::string controlPluginFile,CAmSocketHandle std::istringstream(version.substr(2, 1)) >> minorVersion; std::istringstream(cVersion.substr(0, 1)) >> cMajorVersion; std::istringstream(cVersion.substr(2, 1)) >> cMinorVersion; - - if (majorVersion < cMajorVersion || ((majorVersion == cMajorVersion) && (minorVersion < cMinorVersion))) { - logError("ControlSender::ControlSender: Interface Version of Controller too old, required version:",ControlVersion," Controller Version:",version,"exiting now"); + logError("ControlSender::ControlSender: Interface Version of Controller too old, required version:", ControlVersion, " Controller Version:", version, "exiting now"); throw std::runtime_error("Interface Version of Controller too old"); } } @@ -139,14 +140,14 @@ CAmControlSender::CAmControlSender(std::string controlPluginFile,CAmSocketHandle logError("ControlSender::ControlSender: No controller loaded !"); } - //here we need a pipe to be able to call the rundown function out of the mainloop + // here we need a pipe to be able to call the rundown function out of the mainloop if (pipe(mPipe) == -1) { logError("CAmControlSender could not create pipe!"); } - //add the pipe to the poll - nothing needs to be proccessed here we just need the pipe to trigger the ppoll - short event = 0; + // add the pipe to the poll - nothing needs to be proccessed here we just need the pipe to trigger the ppoll + short event = 0; sh_pollHandle_t handle; event |= POLLIN; sockethandler->addFDPoll(mPipe[0], event, NULL, &receiverCallbackT, &checkerCallbackT, &dispatcherCallbackT, NULL, handle); @@ -159,8 +160,8 @@ CAmControlSender::~CAmControlSender() if (mlibHandle) { - void (*destroyFunc)(IAmControlSend*); - destroyFunc = getDestroyFunction(mControlPluginFile, mlibHandle); + void (*destroyFunc)(IAmControlSend *); + destroyFunc = getDestroyFunction(mControlPluginFile, mlibHandle); if (destroyFunc) { destroyFunc(mController); @@ -169,11 +170,12 @@ CAmControlSender::~CAmControlSender() { logError("CAmControlSender Dtor: destroyFunc is invalid or not found"); } + dlclose(mlibHandle); } } -am_Error_e CAmControlSender::hookUserConnectionRequest(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t & mainConnectionID) +am_Error_e CAmControlSender::hookUserConnectionRequest(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t &mainConnectionID) { assert(mController); return (mController->hookUserConnectionRequest(sourceID, sinkID, mainConnectionID)); @@ -185,19 +187,19 @@ am_Error_e CAmControlSender::hookUserDisconnectionRequest(const am_mainConnectio return (mController->hookUserDisconnectionRequest(connectionID)); } -am_Error_e CAmControlSender::hookUserSetMainSinkSoundProperty(const am_sinkID_t sinkID, const am_MainSoundProperty_s & soundProperty) +am_Error_e CAmControlSender::hookUserSetMainSinkSoundProperty(const am_sinkID_t sinkID, const am_MainSoundProperty_s &soundProperty) { assert(mController); return (mController->hookUserSetMainSinkSoundProperty(sinkID, soundProperty)); } -am_Error_e CAmControlSender::hookUserSetMainSourceSoundProperty(const am_sourceID_t sourceID, const am_MainSoundProperty_s & soundProperty) +am_Error_e CAmControlSender::hookUserSetMainSourceSoundProperty(const am_sourceID_t sourceID, const am_MainSoundProperty_s &soundProperty) { assert(mController); return (mController->hookUserSetMainSourceSoundProperty(sourceID, soundProperty)); } -am_Error_e CAmControlSender::hookUserSetSystemProperty(const am_SystemProperty_s & property) +am_Error_e CAmControlSender::hookUserSetSystemProperty(const am_SystemProperty_s &property) { assert(mController); return (mController->hookUserSetSystemProperty(property)); @@ -221,7 +223,7 @@ am_Error_e CAmControlSender::hookUserSetSinkMuteState(const am_sinkID_t sinkID, return (mController->hookUserSetSinkMuteState(sinkID, muteState)); } -am_Error_e CAmControlSender::hookSystemRegisterDomain(const am_Domain_s & domainData, am_domainID_t & domainID) +am_Error_e CAmControlSender::hookSystemRegisterDomain(const am_Domain_s &domainData, am_domainID_t &domainID) { assert(mController); return (mController->hookSystemRegisterDomain(domainData, domainID)); @@ -239,7 +241,7 @@ void CAmControlSender::hookSystemDomainRegistrationComplete(const am_domainID_t return (mController->hookSystemDomainRegistrationComplete(domainID)); } -am_Error_e CAmControlSender::hookSystemRegisterSink(const am_Sink_s & sinkData, am_sinkID_t & sinkID) +am_Error_e CAmControlSender::hookSystemRegisterSink(const am_Sink_s &sinkData, am_sinkID_t &sinkID) { assert(mController); return (mController->hookSystemRegisterSink(sinkData, sinkID)); @@ -251,7 +253,7 @@ am_Error_e CAmControlSender::hookSystemDeregisterSink(const am_sinkID_t sinkID) return (mController->hookSystemDeregisterSink(sinkID)); } -am_Error_e CAmControlSender::hookSystemRegisterSource(const am_Source_s & sourceData, am_sourceID_t & sourceID) +am_Error_e CAmControlSender::hookSystemRegisterSource(const am_Source_s &sourceData, am_sourceID_t &sourceID) { assert(mController); return (mController->hookSystemRegisterSource(sourceData, sourceID)); @@ -263,13 +265,13 @@ am_Error_e CAmControlSender::hookSystemDeregisterSource(const am_sourceID_t sour return (mController->hookSystemDeregisterSource(sourceID)); } -am_Error_e CAmControlSender::hookSystemRegisterGateway(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID) +am_Error_e CAmControlSender::hookSystemRegisterGateway(const am_Gateway_s &gatewayData, am_gatewayID_t &gatewayID) { assert(mController); return (mController->hookSystemRegisterGateway(gatewayData, gatewayID)); } -am_Error_e CAmControlSender::hookSystemRegisterConverter(const am_Converter_s& converterData, am_converterID_t& converterID) +am_Error_e CAmControlSender::hookSystemRegisterConverter(const am_Converter_s &converterData, am_converterID_t &converterID) { assert(mController); return (mController->hookSystemRegisterConverter(converterData, converterID)); @@ -287,7 +289,7 @@ am_Error_e CAmControlSender::hookSystemDeregisterConverter(const am_converterID_ return (mController->hookSystemDeregisterConverter(converterID)); } -am_Error_e CAmControlSender::hookSystemRegisterCrossfader(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID) +am_Error_e CAmControlSender::hookSystemRegisterCrossfader(const am_Crossfader_s &crossfaderData, am_crossfaderID_t &crossfaderID) { assert(mController); return (mController->hookSystemRegisterCrossfader(crossfaderData, crossfaderID)); @@ -317,13 +319,13 @@ void CAmControlSender::hookSystemInterruptStateChange(const am_sourceID_t source mController->hookSystemInterruptStateChange(sourceID, interruptState); } -void CAmControlSender::hookSystemSinkAvailablityStateChange(const am_sinkID_t sinkID, const am_Availability_s & availability) +void CAmControlSender::hookSystemSinkAvailablityStateChange(const am_sinkID_t sinkID, const am_Availability_s &availability) { assert(mController); mController->hookSystemSinkAvailablityStateChange(sinkID, availability); } -void CAmControlSender::hookSystemSourceAvailablityStateChange(const am_sourceID_t sourceID, const am_Availability_s & availability) +void CAmControlSender::hookSystemSourceAvailablityStateChange(const am_sourceID_t sourceID, const am_Availability_s &availability) { assert(mController); mController->hookSystemSourceAvailablityStateChange(sourceID, availability); @@ -335,7 +337,7 @@ void CAmControlSender::hookSystemDomainStateChange(const am_domainID_t domainID, mController->hookSystemDomainStateChange(domainID, state); } -void CAmControlSender::hookSystemReceiveEarlyData(const std::vector & data) +void CAmControlSender::hookSystemReceiveEarlyData(const std::vector &data) { assert(mController); mController->hookSystemReceiveEarlyData(data); @@ -403,6 +405,7 @@ am_Error_e CAmControlSender::startupController(IAmControlReceive *controlreceive throw std::runtime_error("ControlSender::startupController: no Controller to startup! Exiting now ..."); return (E_NON_EXISTENT); } + return (mController->startupController(controlreceiveinterface)); } @@ -433,17 +436,17 @@ void CAmControlSender::setControllerReady() void CAmControlSender::setControllerRundown(const int16_t signal) { assert(mController); - logInfo("CAmControlSender::setControllerRundown received, signal=",signal); + logInfo("CAmControlSender::setControllerRundown received, signal=", signal); mController->setControllerRundown(signal); } -am_Error_e am::CAmControlSender::getConnectionFormatChoice(const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_Route_s listRoute, const std::vector listPossibleConnectionFormats, std::vector & listPrioConnectionFormats) +am_Error_e am::CAmControlSender::getConnectionFormatChoice(const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_Route_s listRoute, const std::vector listPossibleConnectionFormats, std::vector &listPrioConnectionFormats) { assert(mController); return (mController->getConnectionFormatChoice(sourceID, sinkID, listRoute, listPossibleConnectionFormats, listPrioConnectionFormats)); } -void CAmControlSender::getInterfaceVersion(std::string & version) const +void CAmControlSender::getInterfaceVersion(std::string &version) const { version = ControlVersion; } @@ -472,116 +475,114 @@ void CAmControlSender::confirmRoutingRundown(const am_Error_e error) mController->confirmRoutingRundown(error); } -am_Error_e CAmControlSender::hookSystemUpdateSink(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector& listSoundProperties, const std::vector& listConnectionFormats, const std::vector& listMainSoundProperties) +am_Error_e CAmControlSender::hookSystemUpdateSink(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector &listSoundProperties, const std::vector &listConnectionFormats, const std::vector &listMainSoundProperties) { assert(mController); - return (mController->hookSystemUpdateSink(sinkID,sinkClassID,listSoundProperties,listConnectionFormats,listMainSoundProperties)); + return (mController->hookSystemUpdateSink(sinkID, sinkClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties)); } -am_Error_e CAmControlSender::hookSystemUpdateSource(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector& listSoundProperties, const std::vector& listConnectionFormats, const std::vector& listMainSoundProperties) +am_Error_e CAmControlSender::hookSystemUpdateSource(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector &listSoundProperties, const std::vector &listConnectionFormats, const std::vector &listMainSoundProperties) { assert(mController); - return (mController->hookSystemUpdateSource(sourceID,sourceClassID,listSoundProperties,listConnectionFormats,listMainSoundProperties)); + return (mController->hookSystemUpdateSource(sourceID, sourceClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties)); } -am_Error_e CAmControlSender::hookSystemUpdateGateway(const am_gatewayID_t gatewayID, const std::vector& listSourceConnectionFormats, const std::vector& listSinkConnectionFromats, const std::vector& convertionMatrix) +am_Error_e CAmControlSender::hookSystemUpdateGateway(const am_gatewayID_t gatewayID, const std::vector &listSourceConnectionFormats, const std::vector &listSinkConnectionFromats, const std::vector &convertionMatrix) { assert(mController); - return (mController->hookSystemUpdateGateway(gatewayID,listSourceConnectionFormats,listSinkConnectionFromats,convertionMatrix)); + return (mController->hookSystemUpdateGateway(gatewayID, listSourceConnectionFormats, listSinkConnectionFromats, convertionMatrix)); } -am_Error_e CAmControlSender::hookSystemUpdateConverter(const am_converterID_t converterID, const std::vector& listSourceConnectionFormats, const std::vector& listSinkConnectionFromats, const std::vector& convertionMatrix) +am_Error_e CAmControlSender::hookSystemUpdateConverter(const am_converterID_t converterID, const std::vector &listSourceConnectionFormats, const std::vector &listSinkConnectionFromats, const std::vector &convertionMatrix) { assert(mController); - return (mController->hookSystemUpdateConverter(converterID,listSourceConnectionFormats,listSinkConnectionFromats,convertionMatrix)); + return (mController->hookSystemUpdateConverter(converterID, listSourceConnectionFormats, listSinkConnectionFromats, convertionMatrix)); } -void CAmControlSender::cbAckSetVolume(const am_Handle_s handle, const std::vector& listVolumes, const am_Error_e error) +void CAmControlSender::cbAckSetVolume(const am_Handle_s handle, const std::vector &listVolumes, const am_Error_e error) { assert(mController); - mController->cbAckSetVolumes(handle,listVolumes,error); + mController->cbAckSetVolumes(handle, listVolumes, error); } void CAmControlSender::cbAckSetSinkNotificationConfiguration(const am_Handle_s handle, const am_Error_e error) { assert(mController); - mController->cbAckSetSinkNotificationConfiguration(handle,error); + mController->cbAckSetSinkNotificationConfiguration(handle, error); } void CAmControlSender::cbAckSetSourceNotificationConfiguration(const am_Handle_s handle, const am_Error_e error) { assert(mController); - mController->cbAckSetSourceNotificationConfiguration(handle,error); + mController->cbAckSetSourceNotificationConfiguration(handle, error); } -void CAmControlSender::hookSinkNotificationDataChanged(const am_sinkID_t sinkID, const am_NotificationPayload_s& payload) +void CAmControlSender::hookSinkNotificationDataChanged(const am_sinkID_t sinkID, const am_NotificationPayload_s &payload) { assert(mController); - mController->hookSinkNotificationDataChanged(sinkID,payload); + mController->hookSinkNotificationDataChanged(sinkID, payload); } -void CAmControlSender::hookSourceNotificationDataChanged(const am_sourceID_t sourceID, const am_NotificationPayload_s& payload) +void CAmControlSender::hookSourceNotificationDataChanged(const am_sourceID_t sourceID, const am_NotificationPayload_s &payload) { assert(mController); - mController->hookSourceNotificationDataChanged(sourceID,payload); + mController->hookSourceNotificationDataChanged(sourceID, payload); } -am_Error_e CAmControlSender::hookUserSetMainSinkNotificationConfiguration(const am_sinkID_t sinkID, const am_NotificationConfiguration_s& notificationConfiguration) +am_Error_e CAmControlSender::hookUserSetMainSinkNotificationConfiguration(const am_sinkID_t sinkID, const am_NotificationConfiguration_s ¬ificationConfiguration) { assert(mController); - return (mController->hookUserSetMainSinkNotificationConfiguration(sinkID,notificationConfiguration)); + return (mController->hookUserSetMainSinkNotificationConfiguration(sinkID, notificationConfiguration)); } -am_Error_e CAmControlSender::hookUserSetMainSourceNotificationConfiguration(const am_sourceID_t sourceID, const am_NotificationConfiguration_s& notificationConfiguration) +am_Error_e CAmControlSender::hookUserSetMainSourceNotificationConfiguration(const am_sourceID_t sourceID, const am_NotificationConfiguration_s ¬ificationConfiguration) { assert(mController); - return (mController->hookUserSetMainSourceNotificationConfiguration(sourceID,notificationConfiguration)); + return (mController->hookUserSetMainSourceNotificationConfiguration(sourceID, notificationConfiguration)); } -void CAmControlSender::receiverCallback(const pollfd pollfd, const sh_pollHandle_t handle, void* userData) +void CAmControlSender::receiverCallback(const pollfd pollfd, const sh_pollHandle_t handle, void *userData) { - (void) handle; - (void) userData; - //get the signal number from the socket - ssize_t result = read(pollfd.fd, &mSignal, sizeof(mSignal)); + (void)handle; + (void)userData; + // get the signal number from the socket + ssize_t result = read(pollfd.fd, &mSignal, sizeof(mSignal)); } -bool CAmControlSender::checkerCallback(const sh_pollHandle_t handle, void* userData) +bool CAmControlSender::checkerCallback(const sh_pollHandle_t handle, void *userData) { - (void) handle; - (void) userData; - return (true); + (void)handle; + (void)userData; + return (true); } void CAmControlSender::hookSystemSingleTimingInformationChanged(const am_connectionID_t connectionID, const am_timeSync_t time) { assert(mController); - mController->hookSystemSingleTimingInformationChanged(connectionID,time); + mController->hookSystemSingleTimingInformationChanged(connectionID, time); } /**for testing only contructor - do not use ! * */ -CAmControlSender::CAmControlSender() : - receiverCallbackT(this, &CAmControlSender::receiverCallback), - checkerCallbackT(this, &CAmControlSender::checkerCallback), - dispatcherCallbackT(this, &CAmControlSender::dispatcherCallback), - mlibHandle(NULL), - mController(NULL), - mSignal(0) +CAmControlSender::CAmControlSender() + : receiverCallbackT(this, &CAmControlSender::receiverCallback) + , checkerCallbackT(this, &CAmControlSender::checkerCallback) + , dispatcherCallbackT(this, &CAmControlSender::dispatcherCallback) + , mlibHandle(NULL) + , mController(NULL) + , mSignal(0) { logInfo("CAmControlSender was loaded in test mode!"); std::memset(mPipe, -1, sizeof(mPipe)); } -bool CAmControlSender::dispatcherCallback(const sh_pollHandle_t handle, void* userData) +bool CAmControlSender::dispatcherCallback(const sh_pollHandle_t handle, void *userData) { - (void)handle; - (void)userData; - setControllerRundown(mSignal); - return (false); + (void)handle; + (void)userData; + setControllerRundown(mSignal); + return (false); } } - - diff --git a/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp b/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp index 895b234..8e5c192 100644 --- a/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp +++ b/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp @@ -33,53 +33,56 @@ #include "CAmRouter.h" #include "CAmDltWrapper.h" -#define __METHOD_NAME__ std::string (std::string("CAmDatabaseHandlerMap::") + __func__) - +#define __METHOD_NAME__ std::string(std::string("CAmDatabaseHandlerMap::") + __func__) #ifdef WITH_DATABASE_CHANGE_CHECK -# define DB_COND_UPDATE_RIE(x,y) \ - if (isDataEqual(x,y)) return (E_NO_CHANGE); else x = y -# define DB_COND_UPDATE_INIT \ - bool modified = false -# define DB_COND_UPDATE(x,y) \ - if (!isDataEqual(x,y)) { x = y; modified = true; } -# define DB_COND_ISMODIFIED \ - (modified == true) -#else -# define DB_COND_UPDATE_RIE(x,y) \ - x = y -# define DB_COND_UPDATE_INIT -# define DB_COND_UPDATE(x,y) \ - x = y -# define DB_COND_ISMODIFIED \ - (true) -#endif - - -#define NOTIFY_OBSERVERS(CALL)\ - for(AmDatabaseObserverCallbacks * nextObserver: mDatabaseObservers)\ - if(nextObserver->CALL)\ - nextObserver->CALL(); - -#define NOTIFY_OBSERVERS1(CALL, ARG1)\ - for(AmDatabaseObserverCallbacks * nextObserver: mDatabaseObservers)\ - if(nextObserver->CALL)\ - nextObserver->CALL(ARG1); - -#define NOTIFY_OBSERVERS2(CALL, ARG1, ARG2)\ - for(AmDatabaseObserverCallbacks * nextObserver: mDatabaseObservers)\ - if(nextObserver->CALL)\ - nextObserver->CALL(ARG1, ARG2); - -#define NOTIFY_OBSERVERS3(CALL, ARG1, ARG2, ARG3)\ - for(AmDatabaseObserverCallbacks * nextObserver: mDatabaseObservers)\ - if(nextObserver->CALL)\ - nextObserver->CALL(ARG1, ARG2, ARG3); - -#define NOTIFY_OBSERVERS4(CALL, ARG1, ARG2, ARG3, ARG4)\ - for(AmDatabaseObserverCallbacks * nextObserver: mDatabaseObservers)\ - if(nextObserver->CALL)\ - nextObserver->CALL(ARG1, ARG2, ARG3, ARG4); +# define DB_COND_UPDATE_RIE(x, y) \ + if (isDataEqual(x, y)) { return (E_NO_CHANGE);} else x = y +# define DB_COND_UPDATE_INIT \ + bool modified = false +# define DB_COND_UPDATE(x, y) \ + if (!isDataEqual(x, y)) { x = y; modified = true; } +# define DB_COND_ISMODIFIED \ + (modified == true) +#else // ifdef WITH_DATABASE_CHANGE_CHECK +# define DB_COND_UPDATE_RIE(x, y) \ + x = y +# define DB_COND_UPDATE_INIT +# define DB_COND_UPDATE(x, y) \ + x = y +# define DB_COND_ISMODIFIED \ + (true) +#endif // ifdef WITH_DATABASE_CHANGE_CHECK + +#define NOTIFY_OBSERVERS(CALL) \ + for (AmDatabaseObserverCallbacks *nextObserver: mDatabaseObservers) { \ + if (nextObserver->CALL) { \ + nextObserver->CALL();} \ + } + +#define NOTIFY_OBSERVERS1(CALL, ARG1) \ + for (AmDatabaseObserverCallbacks *nextObserver: mDatabaseObservers) { \ + if (nextObserver->CALL) { \ + nextObserver->CALL(ARG1);} \ + } + +#define NOTIFY_OBSERVERS2(CALL, ARG1, ARG2) \ + for (AmDatabaseObserverCallbacks *nextObserver: mDatabaseObservers) { \ + if (nextObserver->CALL) { \ + nextObserver->CALL(ARG1, ARG2);} \ + } + +#define NOTIFY_OBSERVERS3(CALL, ARG1, ARG2, ARG3) \ + for (AmDatabaseObserverCallbacks *nextObserver: mDatabaseObservers) { \ + if (nextObserver->CALL) { \ + nextObserver->CALL(ARG1, ARG2, ARG3);} \ + } + +#define NOTIFY_OBSERVERS4(CALL, ARG1, ARG2, ARG3, ARG4) \ + for (AmDatabaseObserverCallbacks *nextObserver: mDatabaseObservers) { \ + if (nextObserver->CALL) { \ + nextObserver->CALL(ARG1, ARG2, ARG3, ARG4);} \ + } namespace am { @@ -87,34 +90,40 @@ namespace am /* * Checks if content of data is equal */ -template bool isDataEqual(const T & left, const T & right) +template +bool isDataEqual(const T &left, const T &right) { - return static_cast(!std::memcmp(&left, &right, sizeof(T))); + return static_cast(!std::memcmp(&left, &right, sizeof(T))); } -template > bool isDataEqual(const L & left, const L & right) +template > +bool isDataEqual(const L &left, const L &right) { - return std::equal(left.begin(), left.end(), right.begin(), isDataEqual); + return std::equal(left.begin(), left.end(), right.begin(), isDataEqual); } - /* * Returns an object for given key */ -template TMapObjectType const * objectForKeyIfExistsInMap(const TMapKeyType & key, const std::unordered_map & map) +template +TMapObjectType const *objectForKeyIfExistsInMap(const TMapKeyType &key, const std::unordered_map &map) { - typename std::unordered_map::const_iterator iter = map.find(key); - if( iter!=map.end() ) - return &iter->second; - return NULL; + typename std::unordered_map::const_iterator iter = map.find(key); + if ( iter != map.end()) + { + return &iter->second; + } + + return NULL; } /* * Checks whether any object with key exists in a given map */ -template bool existsObjectWithKeyInMap(const TMapKeyType & key, const std::unordered_map & map) +template +bool existsObjectWithKeyInMap(const TMapKeyType &key, const std::unordered_map &map) { - return objectForKeyIfExistsInMap(key, map)!=NULL; + return objectForKeyIfExistsInMap(key, map) != NULL; } /** @@ -126,489 +135,515 @@ template bool existsObjectWithKeyIn * @param comparator Search predicate. * @return NULL or pointer to the found object. */ -template const TReturn * objectMatchingPredicate(const std::unordered_map & map, - std::function comparator) -{ - typename std::unordered_map::const_iterator elementIterator = map.begin(); - for (;elementIterator != map.end(); ++elementIterator) - { - if( comparator(elementIterator->second) ) - return &elementIterator->second; - } +template +const TReturn *objectMatchingPredicate(const std::unordered_map &map, + std::function comparator) +{ + typename std::unordered_map::const_iterator elementIterator = map.begin(); + for (; elementIterator != map.end(); ++elementIterator) + { + if ( comparator(elementIterator->second)) + { + return &elementIterator->second; + } + } + return NULL; } - /* Domain */ -void CAmDatabaseHandlerMap::AmDomain::getDescription (std::string & outString) const +void CAmDatabaseHandlerMap::AmDomain::getDescription(std::string &outString) const { - std::ostringstream fmt; - fmt << "Domain(" << name.c_str() << ") id(" << domainID << ")" << std::endl << - "bus name(" << busname.c_str() << - ") node name(" << nodename.c_str() << - ") early(" << early << - ") domainID(" << domainID << - ") complete(" << complete << - ") state(" << state << - ") reserved(" << reserved << ")" << std::endl; - outString = fmt.str(); + std::ostringstream fmt; + fmt << "Domain(" << name.c_str() << ") id(" << domainID << ")" << std::endl << + "bus name(" << busname.c_str() << + ") node name(" << nodename.c_str() << + ") early(" << early << + ") domainID(" << domainID << + ") complete(" << complete << + ") state(" << state << + ") reserved(" << reserved << ")" << std::endl; + outString = fmt.str(); } /* Source */ -void CAmDatabaseHandlerMap::AmSource::getSourceType(am_SourceType_s & sourceType) const -{ - sourceType.name = name; - sourceType.sourceClassID = sourceClassID; - sourceType.availability = available; - sourceType.sourceID = sourceID; -} - -void CAmDatabaseHandlerMap::AmSource::getDescription (std::string & outString) const -{ - std::ostringstream fmt; - fmt << "Source(" << name.c_str() << ") id(" << sourceID << ")" << std::endl << - "sourceClassID(" << sourceClassID << - ") domainID(" << domainID << - ") visible(" << visible << - ") volume(" << volume << - ") interruptState(" << interruptState << - ") sourceState(" << sourceState << - ") reserved(" << reserved << ")" << - ") available([availability:" << available.availability << " availabilityReason:" << available.availabilityReason << "]" - ") listSoundProperties ("; - std::for_each(listSoundProperties.begin(), listSoundProperties.end(), [&](const am_SoundProperty_s & ref) { - fmt << "[type:" << ref.type << " value:" << ref.value <<"]"; - }); - fmt << ") listConnectionFormats ("; - std::for_each(listConnectionFormats.begin(), listConnectionFormats.end(), [&](const am_CustomConnectionFormat_t & ref) { - fmt << "[" << ref << "]"; - }); - fmt << ") listMainSoundProperties ("; - std::for_each(listMainSoundProperties.begin(), listMainSoundProperties.end(), [&](const am_MainSoundProperty_s & ref) { - fmt << "[type:" << ref.type << " value:" << ref.value <<"]"; - }); - fmt << ") listMainNotificationConfigurations ("; - std::for_each(listMainNotificationConfigurations.begin(), listMainNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s & ref) { - fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter <<"]"; - }); - fmt << ") listNotificationConfigurations ("; - std::for_each(listNotificationConfigurations.begin(), listNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s & ref) { - fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter <<"]"; - }); - fmt << ")" << std::endl; - outString = fmt.str(); +void CAmDatabaseHandlerMap::AmSource::getSourceType(am_SourceType_s &sourceType) const +{ + sourceType.name = name; + sourceType.sourceClassID = sourceClassID; + sourceType.availability = available; + sourceType.sourceID = sourceID; +} + +void CAmDatabaseHandlerMap::AmSource::getDescription(std::string &outString) const +{ + std::ostringstream fmt; + fmt << "Source(" << name.c_str() << ") id(" << sourceID << ")" << std::endl << + "sourceClassID(" << sourceClassID << + ") domainID(" << domainID << + ") visible(" << visible << + ") volume(" << volume << + ") interruptState(" << interruptState << + ") sourceState(" << sourceState << + ") reserved(" << reserved << ")" << + ") available([availability:" << available.availability << " availabilityReason:" << available.availabilityReason << "]" + ") listSoundProperties ("; + std::for_each(listSoundProperties.begin(), listSoundProperties.end(), [&](const am_SoundProperty_s &ref) { + fmt << "[type:" << ref.type << " value:" << ref.value << "]"; + }); + fmt << ") listConnectionFormats ("; + std::for_each(listConnectionFormats.begin(), listConnectionFormats.end(), [&](const am_CustomConnectionFormat_t &ref) { + fmt << "[" << ref << "]"; + }); + fmt << ") listMainSoundProperties ("; + std::for_each(listMainSoundProperties.begin(), listMainSoundProperties.end(), [&](const am_MainSoundProperty_s &ref) { + fmt << "[type:" << ref.type << " value:" << ref.value << "]"; + }); + fmt << ") listMainNotificationConfigurations ("; + std::for_each(listMainNotificationConfigurations.begin(), listMainNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s &ref) { + fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter << "]"; + }); + fmt << ") listNotificationConfigurations ("; + std::for_each(listNotificationConfigurations.begin(), listNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s &ref) { + fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter << "]"; + }); + fmt << ")" << std::endl; + outString = fmt.str(); } /* Sink */ -void CAmDatabaseHandlerMap::AmSink::getDescription (std::string & outString) const -{ - std::ostringstream fmt; - fmt << "Sink(" << name.c_str() << ") id(" << sinkID << ")" << std::endl << - "sinkClassID(" << sinkClassID << - ") domainID(" << domainID << - ") visible(" << visible << - ") volume(" << volume << - ") muteState(" << muteState << - ") mainVolume(" << mainVolume << - ") reserved(" << reserved << ")" << - ") available([availability:" << available.availability << " availabilityReason:" << available.availabilityReason << "]" - ") listSoundProperties ("; - std::for_each(listSoundProperties.begin(), listSoundProperties.end(), [&](const am_SoundProperty_s & ref) { - fmt << "[type:" << ref.type << " value:" << ref.value <<"]"; - }); - fmt << ") listConnectionFormats ("; - std::for_each(listConnectionFormats.begin(), listConnectionFormats.end(), [&](const am_CustomConnectionFormat_t & ref) { - fmt << "[" << ref << "]"; - }); - fmt << ") listMainSoundProperties ("; - std::for_each(listMainSoundProperties.begin(), listMainSoundProperties.end(), [&](const am_MainSoundProperty_s & ref) { - fmt << "[type:" << ref.type << " value:" << ref.value <<"]"; - }); - fmt << ") listMainNotificationConfigurations ("; - std::for_each(listMainNotificationConfigurations.begin(), listMainNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s & ref) { - fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter <<"]"; - }); - fmt << ") listNotificationConfigurations ("; - std::for_each(listNotificationConfigurations.begin(), listNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s & ref) { - fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter <<"]"; - }); - fmt << ")" << std::endl; - outString = fmt.str(); -} - -void CAmDatabaseHandlerMap::AmSink::getSinkType(am_SinkType_s & sinkType) const -{ - sinkType.name = name; - sinkType.sinkID = sinkID; - sinkType.availability = available; - sinkType.muteState = muteState; - sinkType.volume = mainVolume; - sinkType.sinkClassID = sinkClassID; +void CAmDatabaseHandlerMap::AmSink::getDescription(std::string &outString) const +{ + std::ostringstream fmt; + fmt << "Sink(" << name.c_str() << ") id(" << sinkID << ")" << std::endl << + "sinkClassID(" << sinkClassID << + ") domainID(" << domainID << + ") visible(" << visible << + ") volume(" << volume << + ") muteState(" << muteState << + ") mainVolume(" << mainVolume << + ") reserved(" << reserved << ")" << + ") available([availability:" << available.availability << " availabilityReason:" << available.availabilityReason << "]" + ") listSoundProperties ("; + std::for_each(listSoundProperties.begin(), listSoundProperties.end(), [&](const am_SoundProperty_s &ref) { + fmt << "[type:" << ref.type << " value:" << ref.value << "]"; + }); + fmt << ") listConnectionFormats ("; + std::for_each(listConnectionFormats.begin(), listConnectionFormats.end(), [&](const am_CustomConnectionFormat_t &ref) { + fmt << "[" << ref << "]"; + }); + fmt << ") listMainSoundProperties ("; + std::for_each(listMainSoundProperties.begin(), listMainSoundProperties.end(), [&](const am_MainSoundProperty_s &ref) { + fmt << "[type:" << ref.type << " value:" << ref.value << "]"; + }); + fmt << ") listMainNotificationConfigurations ("; + std::for_each(listMainNotificationConfigurations.begin(), listMainNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s &ref) { + fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter << "]"; + }); + fmt << ") listNotificationConfigurations ("; + std::for_each(listNotificationConfigurations.begin(), listNotificationConfigurations.end(), [&](const am_NotificationConfiguration_s &ref) { + fmt << "[type:" << ref.type << " status:" << ref.status << " parameter:" << ref.parameter << "]"; + }); + fmt << ")" << std::endl; + outString = fmt.str(); +} + +void CAmDatabaseHandlerMap::AmSink::getSinkType(am_SinkType_s &sinkType) const +{ + sinkType.name = name; + sinkType.sinkID = sinkID; + sinkType.availability = available; + sinkType.muteState = muteState; + sinkType.volume = mainVolume; + sinkType.sinkClassID = sinkClassID; } /* Connection */ -void CAmDatabaseHandlerMap::AmConnection::getDescription (std::string & outString) const +void CAmDatabaseHandlerMap::AmConnection::getDescription(std::string &outString) const { - std::ostringstream fmt; - fmt << "Connection id(" << connectionID << ") " << std::endl << - "sourceID(" << sourceID << - ") sinkID(" << sinkID << - ") delay(" << delay << - ") connectionFormat(" << connectionFormat << - ") reserved(" << reserved << ")" << std::endl; - outString = fmt.str(); + std::ostringstream fmt; + fmt << "Connection id(" << connectionID << ") " << std::endl << + "sourceID(" << sourceID << + ") sinkID(" << sinkID << + ") delay(" << delay << + ") connectionFormat(" << connectionFormat << + ") reserved(" << reserved << ")" << std::endl; + outString = fmt.str(); } /* Main Connection */ -void CAmDatabaseHandlerMap::AmMainConnection::getDescription (std::string & outString) const +void CAmDatabaseHandlerMap::AmMainConnection::getDescription(std::string &outString) const { - std::ostringstream fmt; - fmt << "MainConnection id(" << mainConnectionID << ") " << std::endl << - "connectionState(" << connectionState << - ") sinkID(" << sinkID << - ") sourceID(" << sourceID << - ") delay(" << delay << - ") listConnectionID ("; - std::for_each(listConnectionID.begin(), listConnectionID.end(), [&](const am_connectionID_t & connID) { - fmt << "["<< connID << "]"; - }); - fmt << ")" << std::endl; - outString = fmt.str(); + std::ostringstream fmt; + fmt << "MainConnection id(" << mainConnectionID << ") " << std::endl << + "connectionState(" << connectionState << + ") sinkID(" << sinkID << + ") sourceID(" << sourceID << + ") delay(" << delay << + ") listConnectionID ("; + std::for_each(listConnectionID.begin(), listConnectionID.end(), [&](const am_connectionID_t &connID) { + fmt << "[" << connID << "]"; + }); + fmt << ")" << std::endl; + outString = fmt.str(); } -void CAmDatabaseHandlerMap::am_MainConnection_Database_s::getMainConnectionType(am_MainConnectionType_s & connectionType) const +void CAmDatabaseHandlerMap::am_MainConnection_Database_s::getMainConnectionType(am_MainConnectionType_s &connectionType) const { - connectionType.mainConnectionID = mainConnectionID; - connectionType.sourceID = sourceID; - connectionType.sinkID = sinkID; - connectionType.connectionState = connectionState; - connectionType.delay = delay; + connectionType.mainConnectionID = mainConnectionID; + connectionType.sourceID = sourceID; + connectionType.sinkID = sinkID; + connectionType.connectionState = connectionState; + connectionType.delay = delay; } /* Source Class */ -void CAmDatabaseHandlerMap::AmSourceClass::getDescription (std::string & outString) const +void CAmDatabaseHandlerMap::AmSourceClass::getDescription(std::string &outString) const { - std::ostringstream fmt; - fmt << "Source class(" << name.c_str() << ") id(" << sourceClassID << ")\n" << - ") listClassProperties ("; - std::for_each(listClassProperties.begin(), listClassProperties.end(), [&](const am_ClassProperty_s & ref) { - fmt << "[classProperty:" << ref.classProperty << " value:" << ref.value << "]"; - }); - fmt << ")" << std::endl; - outString = fmt.str(); + std::ostringstream fmt; + fmt << "Source class(" << name.c_str() << ") id(" << sourceClassID << ")\n" << + ") listClassProperties ("; + std::for_each(listClassProperties.begin(), listClassProperties.end(), [&](const am_ClassProperty_s &ref) { + fmt << "[classProperty:" << ref.classProperty << " value:" << ref.value << "]"; + }); + fmt << ")" << std::endl; + outString = fmt.str(); } /* Sink Class */ -void CAmDatabaseHandlerMap::AmSinkClass::getDescription (std::string & outString) const +void CAmDatabaseHandlerMap::AmSinkClass::getDescription(std::string &outString) const { - std::ostringstream fmt; - fmt << "Sink class(" << name.c_str() << ") id(" << sinkClassID << ")\n" << - ") listClassProperties ("; - std::for_each(listClassProperties.begin(), listClassProperties.end(), [&](const am_ClassProperty_s & ref) { - fmt << "[classProperty:" << ref.classProperty << " value:" << ref.value << "]"; - }); - fmt << ")" << std::endl; - outString = fmt.str(); + std::ostringstream fmt; + fmt << "Sink class(" << name.c_str() << ") id(" << sinkClassID << ")\n" << + ") listClassProperties ("; + std::for_each(listClassProperties.begin(), listClassProperties.end(), [&](const am_ClassProperty_s &ref) { + fmt << "[classProperty:" << ref.classProperty << " value:" << ref.value << "]"; + }); + fmt << ")" << std::endl; + outString = fmt.str(); } - /* Gateway */ -void CAmDatabaseHandlerMap::AmGateway::getDescription (std::string & outString) const -{ - std::ostringstream fmt; - fmt << "Gateway(" << name.c_str() << ") id(" << gatewayID << ")\n" << - "sinkID(" << sinkID << - ") sourceID(" << sourceID << - ") domainSinkID(" << domainSinkID << - ") domainSourceID(" << domainSourceID << - ") controlDomainID(" << controlDomainID << - ") listSourceFormats ("; - std::for_each(listSourceFormats.begin(), listSourceFormats.end(), [&](const am_CustomConnectionFormat_t & ref) { - fmt << "[" << ref << "]"; - }); - fmt << ") listSinkFormats ("; - std::for_each(listSinkFormats.begin(), listSinkFormats.end(), [&](const am_CustomConnectionFormat_t & ref) { - fmt << "[" << ref << "]"; - }); - fmt << ") convertionMatrix ("; - std::for_each(convertionMatrix.begin(), convertionMatrix.end(), [&](const bool & ref) { - fmt << "[" << ref << "]"; - }); - fmt << ")" << std::endl; - outString = fmt.str(); +void CAmDatabaseHandlerMap::AmGateway::getDescription(std::string &outString) const +{ + std::ostringstream fmt; + fmt << "Gateway(" << name.c_str() << ") id(" << gatewayID << ")\n" << + "sinkID(" << sinkID << + ") sourceID(" << sourceID << + ") domainSinkID(" << domainSinkID << + ") domainSourceID(" << domainSourceID << + ") controlDomainID(" << controlDomainID << + ") listSourceFormats ("; + std::for_each(listSourceFormats.begin(), listSourceFormats.end(), [&](const am_CustomConnectionFormat_t &ref) { + fmt << "[" << ref << "]"; + }); + fmt << ") listSinkFormats ("; + std::for_each(listSinkFormats.begin(), listSinkFormats.end(), [&](const am_CustomConnectionFormat_t &ref) { + fmt << "[" << ref << "]"; + }); + fmt << ") convertionMatrix ("; + std::for_each(convertionMatrix.begin(), convertionMatrix.end(), [&](const bool &ref) { + fmt << "[" << ref << "]"; + }); + fmt << ")" << std::endl; + outString = fmt.str(); } /* Converter */ -void CAmDatabaseHandlerMap::AmConverter::getDescription (std::string & outString) const -{ - std::ostringstream fmt; - fmt << "Converter(" << name.c_str() << ") id(" << converterID << ")\n" << - "sinkID(" << sinkID << - ") sourceID(" << sourceID << - ") domainSinkID(" << domainID << - ") listSourceFormats ("; - std::for_each(listSourceFormats.begin(), listSourceFormats.end(), [&](const am_CustomConnectionFormat_t & ref) { - fmt << "[" << ref << "]"; - }); - fmt << ") listSinkFormats ("; - std::for_each(listSinkFormats.begin(), listSinkFormats.end(), [&](const am_CustomConnectionFormat_t & ref) { - fmt << "[" << ref << "]"; - }); - fmt << ") convertionMatrix ("; - std::for_each(convertionMatrix.begin(), convertionMatrix.end(), [&](const bool & ref) { - fmt << "[" << ref << "]"; - }); - fmt << ")" << std::endl; - outString = fmt.str(); +void CAmDatabaseHandlerMap::AmConverter::getDescription(std::string &outString) const +{ + std::ostringstream fmt; + fmt << "Converter(" << name.c_str() << ") id(" << converterID << ")\n" << + "sinkID(" << sinkID << + ") sourceID(" << sourceID << + ") domainSinkID(" << domainID << + ") listSourceFormats ("; + std::for_each(listSourceFormats.begin(), listSourceFormats.end(), [&](const am_CustomConnectionFormat_t &ref) { + fmt << "[" << ref << "]"; + }); + fmt << ") listSinkFormats ("; + std::for_each(listSinkFormats.begin(), listSinkFormats.end(), [&](const am_CustomConnectionFormat_t &ref) { + fmt << "[" << ref << "]"; + }); + fmt << ") convertionMatrix ("; + std::for_each(convertionMatrix.begin(), convertionMatrix.end(), [&](const bool &ref) { + fmt << "[" << ref << "]"; + }); + fmt << ")" << std::endl; + outString = fmt.str(); } /* Crossfader */ -void CAmDatabaseHandlerMap::AmCrossfader::getDescription (std::string & outString) const -{ - std::ostringstream fmt; - fmt << "Crossfader(" << name.c_str() << ") id(" << crossfaderID << ")\n" << - "sinkID_A(" << sinkID_A << - ") sinkID_B(" << sinkID_B << - ") sourceID(" << sourceID << - ") hotSink(" << hotSink << - ")" << std::endl; - outString = fmt.str(); -} - -bool CAmDatabaseHandlerMap::AmMappedData::increaseID(int16_t & resultID, AmIdentifier & elementID, - int16_t const desiredStaticID = 0) -{ - if( desiredStaticID > 0 && desiredStaticID < elementID.mMin ) - { - resultID = desiredStaticID; - return true; - } - else if( elementID.mCurrentValue < elementID.mMax ) //The last used value is 'limit' - 1. e.g. SHRT_MAX - 1, SHRT_MAX is reserved. - { - resultID = elementID.mCurrentValue++; - return true; - } - else - { - resultID = -1; - return false; - } -} - -template bool CAmDatabaseHandlerMap::AmMappedData::getNextConnectionID(int16_t & resultID, AmIdentifier & connID, - const std::unordered_map & map) -{ - TMapKey nextID; - int16_t const lastID = connID.mCurrentValue; - if( connID.mCurrentValue < connID.mMax ) - nextID = connID.mCurrentValue++; - else - nextID = connID.mCurrentValue = connID.mMin; - - bool notFreeIDs = false; - while( existsObjectWithKeyInMap(nextID, map) ) - { - - if( connID.mCurrentValue < connID.mMax ) - nextID = connID.mCurrentValue++; - else - { - connID.mCurrentValue = connID.mMin; - nextID = connID.mCurrentValue; - } - - if( connID.mCurrentValue == lastID ) - { - notFreeIDs = true; - break; - } - } - if(notFreeIDs) - { - resultID = -1; - return false; - } - resultID = nextID; - return true; -} - -bool CAmDatabaseHandlerMap::AmMappedData::increaseMainConnectionID(int16_t & resultID) -{ - return getNextConnectionID(resultID, mCurrentMainConnectionID, mMainConnectionMap); -} - -bool CAmDatabaseHandlerMap::AmMappedData::increaseConnectionID(int16_t & resultID) -{ - return getNextConnectionID(resultID, mCurrentConnectionID, mConnectionMap); -} - - -CAmDatabaseHandlerMap::CAmDatabaseHandlerMap(): IAmDatabaseHandler(), - mFirstStaticSink(true), - mFirstStaticSource(true), - mFirstStaticGateway(true), - mFirstStaticConverter(true), - mFirstStaticSinkClass(true), - mFirstStaticSourceClass(true), - mFirstStaticCrossfader(true), - mListConnectionFormat(), - mMappedData(), - mDatabaseObservers() -{ - logVerbose(__METHOD_NAME__,"Init "); +void CAmDatabaseHandlerMap::AmCrossfader::getDescription(std::string &outString) const +{ + std::ostringstream fmt; + fmt << "Crossfader(" << name.c_str() << ") id(" << crossfaderID << ")\n" << + "sinkID_A(" << sinkID_A << + ") sinkID_B(" << sinkID_B << + ") sourceID(" << sourceID << + ") hotSink(" << hotSink << + ")" << std::endl; + outString = fmt.str(); +} + +bool CAmDatabaseHandlerMap::AmMappedData::increaseID(int16_t &resultID, AmIdentifier &elementID, + int16_t const desiredStaticID = 0) +{ + if ( desiredStaticID > 0 && desiredStaticID < elementID.mMin ) + { + resultID = desiredStaticID; + return true; + } + else if ( elementID.mCurrentValue < elementID.mMax ) // The last used value is 'limit' - 1. e.g. SHRT_MAX - 1, SHRT_MAX is reserved. + { + resultID = elementID.mCurrentValue++; + return true; + } + else + { + resultID = -1; + return false; + } +} + +template +bool CAmDatabaseHandlerMap::AmMappedData::getNextConnectionID(int16_t &resultID, AmIdentifier &connID, + const std::unordered_map &map) +{ + TMapKey nextID; + int16_t const lastID = connID.mCurrentValue; + if ( connID.mCurrentValue < connID.mMax ) + { + nextID = connID.mCurrentValue++; + } + else + { + nextID = connID.mCurrentValue = connID.mMin; + } + + bool notFreeIDs = false; + while ( existsObjectWithKeyInMap(nextID, map)) + { + + if ( connID.mCurrentValue < connID.mMax ) + { + nextID = connID.mCurrentValue++; + } + else + { + connID.mCurrentValue = connID.mMin; + nextID = connID.mCurrentValue; + } + + if ( connID.mCurrentValue == lastID ) + { + notFreeIDs = true; + break; + } + } + + if (notFreeIDs) + { + resultID = -1; + return false; + } + + resultID = nextID; + return true; +} + +bool CAmDatabaseHandlerMap::AmMappedData::increaseMainConnectionID(int16_t &resultID) +{ + return getNextConnectionID(resultID, mCurrentMainConnectionID, mMainConnectionMap); +} + +bool CAmDatabaseHandlerMap::AmMappedData::increaseConnectionID(int16_t &resultID) +{ + return getNextConnectionID(resultID, mCurrentConnectionID, mConnectionMap); +} + +CAmDatabaseHandlerMap::CAmDatabaseHandlerMap() + : IAmDatabaseHandler() + , mFirstStaticSink(true) + , mFirstStaticSource(true) + , mFirstStaticGateway(true) + , mFirstStaticConverter(true) + , mFirstStaticSinkClass(true) + , mFirstStaticSourceClass(true) + , mFirstStaticCrossfader(true) + , mListConnectionFormat() + , mMappedData() + , mDatabaseObservers() +{ + logVerbose(__METHOD_NAME__, "Init "); } CAmDatabaseHandlerMap::~CAmDatabaseHandlerMap() { - logVerbose(__METHOD_NAME__,"Destroy"); - for(AmDatabaseObserverCallbacks * ptr: mDatabaseObservers) - ptr->mpDatabaseHandler=nullptr; + logVerbose(__METHOD_NAME__, "Destroy"); + for (AmDatabaseObserverCallbacks *ptr: mDatabaseObservers) + { + ptr->mpDatabaseHandler = nullptr; + } } -am_Error_e CAmDatabaseHandlerMap::enterDomainDB(const am_Domain_s & domainData, am_domainID_t & domainID) +am_Error_e CAmDatabaseHandlerMap::enterDomainDB(const am_Domain_s &domainData, am_domainID_t &domainID) { - if(domainData.name.empty()) + if (domainData.name.empty()) { - logError(__METHOD_NAME__,"DomainName must not be emtpy!"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "DomainName must not be emtpy!"); + return (E_NOT_POSSIBLE); } - if(domainData.busname.empty()) + + if (domainData.busname.empty()) { - logError(__METHOD_NAME__,"Busname must not be emtpy!"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "Busname must not be emtpy!"); + return (E_NOT_POSSIBLE); } - if(!(domainData.state>=DS_UNKNOWN && domainData.state<=DS_MAX)) + + if (!(domainData.state >= DS_UNKNOWN && domainData.state <= DS_MAX)) { - logError(__METHOD_NAME__,"State must not be valid!"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "State must not be valid!"); + return (E_NOT_POSSIBLE); } - //first check for a reserved domain - am_Domain_s const *reservedDomain = objectMatchingPredicate(mMappedData.mDomainMap, [&](const AmDomain & obj){ - return domainData.name.compare(obj.name)==0; - }); + + // first check for a reserved domain + am_Domain_s const *reservedDomain = objectMatchingPredicate(mMappedData.mDomainMap, [&](const AmDomain &obj){ + return domainData.name.compare(obj.name) == 0; + }); int16_t nextID = 0; - if( NULL != reservedDomain ) + if ( NULL != reservedDomain ) { - nextID = reservedDomain->domainID; - domainID = nextID; - mMappedData.mDomainMap[nextID] = domainData; - mMappedData.mDomainMap[nextID].domainID = nextID; - mMappedData.mDomainMap[nextID].reserved = 0; - logVerbose("DatabaseHandler::enterDomainDB entered reserved domain with name=", domainData.name, "busname=", domainData.busname, "nodename=", domainData.nodename, "reserved ID:", domainID); + nextID = reservedDomain->domainID; + domainID = nextID; + mMappedData.mDomainMap[nextID] = domainData; + mMappedData.mDomainMap[nextID].domainID = nextID; + mMappedData.mDomainMap[nextID].reserved = 0; + logVerbose("DatabaseHandler::enterDomainDB entered reserved domain with name=", domainData.name, "busname=", domainData.busname, "nodename=", domainData.nodename, "reserved ID:", domainID); - NOTIFY_OBSERVERS1(dboNewDomain, mMappedData.mDomainMap[nextID]) + NOTIFY_OBSERVERS1(dboNewDomain, mMappedData.mDomainMap[nextID]) - return (E_OK); + return (E_OK); } else { - if(mMappedData.increaseID(nextID, mMappedData.mCurrentDomainID, domainData.domainID)) - { - domainID = nextID; - mMappedData.mDomainMap[nextID] = domainData; - mMappedData.mDomainMap[nextID].domainID = nextID; - logVerbose("DatabaseHandler::enterDomainDB entered new domain with name=", domainData.name, "busname=", domainData.busname, "nodename=", domainData.nodename, "assigned ID:", domainID); + if (mMappedData.increaseID(nextID, mMappedData.mCurrentDomainID, domainData.domainID)) + { + domainID = nextID; + mMappedData.mDomainMap[nextID] = domainData; + mMappedData.mDomainMap[nextID].domainID = nextID; + logVerbose("DatabaseHandler::enterDomainDB entered new domain with name=", domainData.name, "busname=", domainData.busname, "nodename=", domainData.nodename, "assigned ID:", domainID); - NOTIFY_OBSERVERS1(dboNewDomain, mMappedData.mDomainMap[nextID]) + NOTIFY_OBSERVERS1(dboNewDomain, mMappedData.mDomainMap[nextID]) - return (E_OK); - } - else - { - domainID = 0; - logVerbose(__METHOD_NAME__,"Max limit reached."); - return (E_UNKNOWN); - } + return (E_OK); + } + else + { + domainID = 0; + logVerbose(__METHOD_NAME__, "Max limit reached."); + return (E_UNKNOWN); + } } } -int16_t CAmDatabaseHandlerMap::calculateDelayForRoute(const std::vector& listConnectionID) +int16_t CAmDatabaseHandlerMap::calculateDelayForRoute(const std::vector &listConnectionID) { - int16_t delay = 0; - std::vector::const_iterator elementIterator = listConnectionID.begin(); - for (; elementIterator < listConnectionID.end(); ++elementIterator) - { - am_connectionID_t key = *elementIterator; - std::unordered_map::const_iterator it = mMappedData.mConnectionMap.find(key); - if (it!=mMappedData.mConnectionMap.end()) - { - int16_t temp_delay = it->second.delay; - if (temp_delay != -1 && delay != -1) - delay += temp_delay; - else - delay = -1; - } - } - return delay; + int16_t delay = 0; + std::vector::const_iterator elementIterator = listConnectionID.begin(); + for (; elementIterator < listConnectionID.end(); ++elementIterator) + { + am_connectionID_t key = *elementIterator; + std::unordered_map::const_iterator it = mMappedData.mConnectionMap.find(key); + if (it != mMappedData.mConnectionMap.end()) + { + int16_t temp_delay = it->second.delay; + if (temp_delay != -1 && delay != -1) + { + delay += temp_delay; + } + else + { + delay = -1; + } + } + } + + return delay; } -am_Error_e CAmDatabaseHandlerMap::enterMainConnectionDB(const am_MainConnection_s & mainConnectionData, am_mainConnectionID_t & connectionID) +am_Error_e CAmDatabaseHandlerMap::enterMainConnectionDB(const am_MainConnection_s &mainConnectionData, am_mainConnectionID_t &connectionID) { - if(mainConnectionData.mainConnectionID!=0) + if (mainConnectionData.mainConnectionID != 0) { - logError(__METHOD_NAME__,"mainConnectionID must be 0!"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "mainConnectionID must be 0!"); + return (E_NOT_POSSIBLE); } - if(!(mainConnectionData.connectionState>=CS_UNKNOWN && mainConnectionData.connectionState<=CS_MAX)) + + if (!(mainConnectionData.connectionState >= CS_UNKNOWN && mainConnectionData.connectionState <= CS_MAX)) { - logError(__METHOD_NAME__,"connectionState must be valid!"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "connectionState must be valid!"); + return (E_NOT_POSSIBLE); } - if(!existSink(mainConnectionData.sinkID)) + + if (!existSink(mainConnectionData.sinkID)) { - logError(__METHOD_NAME__,"sinkID must be valid!"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "sinkID must be valid!"); + return (E_NOT_POSSIBLE); } - if(!existSource(mainConnectionData.sourceID)) + + if (!existSource(mainConnectionData.sourceID)) { - logError(__METHOD_NAME__,"sourceID must be valid!"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "sourceID must be valid!"); + return (E_NOT_POSSIBLE); } - int16_t delay = 0; + int16_t delay = 0; int16_t nextID = 0; - if(mMappedData.increaseMainConnectionID(nextID)) - { - connectionID = nextID; - mMappedData.mMainConnectionMap[nextID] = mainConnectionData; - mMappedData.mMainConnectionMap[nextID].mainConnectionID = nextID; - } - else - { - connectionID = 0; - logVerbose(__METHOD_NAME__,"Max limit reached."); - return (E_UNKNOWN); - } - - //now check the connectionTable for all connections in the route. IF connectionID exist + if (mMappedData.increaseMainConnectionID(nextID)) + { + connectionID = nextID; + mMappedData.mMainConnectionMap[nextID] = mainConnectionData; + mMappedData.mMainConnectionMap[nextID].mainConnectionID = nextID; + } + else + { + connectionID = 0; + logVerbose(__METHOD_NAME__, "Max limit reached."); + return (E_UNKNOWN); + } + + // now check the connectionTable for all connections in the route. IF connectionID exist delay = calculateDelayForRoute(mainConnectionData.listConnectionID); logVerbose("DatabaseHandler::enterMainConnectionDB entered new mainConnection with sourceID", mainConnectionData.sourceID, "sinkID:", mainConnectionData.sinkID, "delay:", delay, "assigned ID:", connectionID); - if (mDatabaseObservers.size()) { - am_MainConnectionType_s mainConnection; - mMappedData.mMainConnectionMap[nextID].getMainConnectionType(mainConnection); + am_MainConnectionType_s mainConnection; + mMappedData.mMainConnectionMap[nextID].getMainConnectionType(mainConnection); NOTIFY_OBSERVERS1(dboNewMainConnection, mainConnection) NOTIFY_OBSERVERS2(dboMainConnectionStateChanged, connectionID, mMappedData.mMainConnectionMap[nextID].connectionState) } - //finally, we update the delay value for the maintable + // finally, we update the delay value for the maintable if (delay == 0) + { delay = -1; + } + (void)changeDelayMainConnection(delay, connectionID); return (E_OK); @@ -618,258 +653,278 @@ am_Error_e CAmDatabaseHandlerMap::enterMainConnectionDB(const am_MainConnection_ * Helper method, that inserts a new struct in the map and copies the given into it. * This method uses the increaseID function to secure the global id is properly increased. **/ -bool CAmDatabaseHandlerMap::insertSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID) +bool CAmDatabaseHandlerMap::insertSinkDB(const am_Sink_s &sinkData, am_sinkID_t &sinkID) { int16_t nextID = 0; - if( mMappedData.increaseID(nextID, mMappedData.mCurrentSinkID, sinkData.sinkID) ) - { - sinkID = nextID; - mMappedData.mSinkMap[nextID] = sinkData; - mMappedData.mSinkMap[nextID].sinkID = nextID; - filterDuplicateNotificationConfigurationTypes(mMappedData.mSinkMap[nextID].listNotificationConfigurations); - filterDuplicateNotificationConfigurationTypes(mMappedData.mSinkMap[nextID].listMainNotificationConfigurations); - return (true); - } - else - { - sinkID = 0; - logVerbose(__METHOD_NAME__,"Max limit reached!"); - return (false); - } + if ( mMappedData.increaseID(nextID, mMappedData.mCurrentSinkID, sinkData.sinkID)) + { + sinkID = nextID; + mMappedData.mSinkMap[nextID] = sinkData; + mMappedData.mSinkMap[nextID].sinkID = nextID; + filterDuplicateNotificationConfigurationTypes(mMappedData.mSinkMap[nextID].listNotificationConfigurations); + filterDuplicateNotificationConfigurationTypes(mMappedData.mSinkMap[nextID].listMainNotificationConfigurations); + return (true); + } + else + { + sinkID = 0; + logVerbose(__METHOD_NAME__, "Max limit reached!"); + return (false); + } } -am_Error_e CAmDatabaseHandlerMap::enterSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID) +am_Error_e CAmDatabaseHandlerMap::enterSinkDB(const am_Sink_s &sinkData, am_sinkID_t &sinkID) { - if(sinkData.sinkID>=DYNAMIC_ID_BOUNDARY) + if (sinkData.sinkID >= DYNAMIC_ID_BOUNDARY) { - logError(__METHOD_NAME__,"sinkID must be below:",DYNAMIC_ID_BOUNDARY); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "sinkID must be below:", DYNAMIC_ID_BOUNDARY); + return (E_NOT_POSSIBLE); } - if(!existDomain(sinkData.domainID)) + + if (!existDomain(sinkData.domainID)) { - logError(__METHOD_NAME__,"domainID must be valid"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "domainID must be valid"); + return (E_NOT_POSSIBLE); } - if(sinkData.name.empty()) + + if (sinkData.name.empty()) { - logError(__METHOD_NAME__,"sinkName must not be zero"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "sinkName must not be zero"); + return (E_NOT_POSSIBLE); } - if(!existSinkClass(sinkData.sinkClassID)) + + if (!existSinkClass(sinkData.sinkClassID)) { - logError(__METHOD_NAME__,"sinkClass must be valid"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "sinkClass must be valid"); + return (E_NOT_POSSIBLE); } - if(!(sinkData.muteState>=MS_UNKNOWN && sinkData.muteState<=MS_MAX)) + if (!(sinkData.muteState >= MS_UNKNOWN && sinkData.muteState <= MS_MAX)) { - logError(__METHOD_NAME__,"muteState must be valid"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "muteState must be valid"); + return (E_NOT_POSSIBLE); } - am_sinkID_t temp_SinkID = 0; + am_sinkID_t temp_SinkID = 0; am_sinkID_t temp_SinkIndex = 0; - //if sinkID is zero and the first Static Sink was already entered, the ID is created - am_Sink_s const *reservedDomain = objectMatchingPredicate(mMappedData.mSinkMap, [&](const AmSink & obj){ - return true==obj.reserved && obj.name.compare(sinkData.name)==0; - }); - if( NULL!=reservedDomain ) - { - am_sinkID_t oldSinkID = reservedDomain->sinkID; - mMappedData.mSinkMap[oldSinkID] = sinkData; - mMappedData.mSinkMap[oldSinkID].reserved = 0; - temp_SinkID = oldSinkID; - temp_SinkIndex = oldSinkID; + // if sinkID is zero and the first Static Sink was already entered, the ID is created + am_Sink_s const *reservedDomain = objectMatchingPredicate(mMappedData.mSinkMap, [&](const AmSink &obj){ + return true == obj.reserved && obj.name.compare(sinkData.name) == 0; + }); + if ( NULL != reservedDomain ) + { + am_sinkID_t oldSinkID = reservedDomain->sinkID; + mMappedData.mSinkMap[oldSinkID] = sinkData; + mMappedData.mSinkMap[oldSinkID].reserved = 0; + temp_SinkID = oldSinkID; + temp_SinkIndex = oldSinkID; } else { - bool result; - if ( sinkData.sinkID != 0 || mFirstStaticSink ) - { - //check if the ID already exists - if (existSinkNameOrID(sinkData.sinkID, sinkData.name)) - { - sinkID = sinkData.sinkID; - return (E_ALREADY_EXISTS); - } - } - result = insertSinkDB(sinkData, temp_SinkID); - if( false == result ) - return (E_UNKNOWN); - temp_SinkIndex = temp_SinkID; - } - //if the first static sink is entered, we need to set it onto the boundary + bool result; + if ( sinkData.sinkID != 0 || mFirstStaticSink ) + { + // check if the ID already exists + if (existSinkNameOrID(sinkData.sinkID, sinkData.name)) + { + sinkID = sinkData.sinkID; + return (E_ALREADY_EXISTS); + } + } + + result = insertSinkDB(sinkData, temp_SinkID); + if ( false == result ) + { + return (E_UNKNOWN); + } + + temp_SinkIndex = temp_SinkID; + } + + // if the first static sink is entered, we need to set it onto the boundary if (sinkData.sinkID == 0 && mFirstStaticSink) { mFirstStaticSink = false; } + mMappedData.mSinkMap[temp_SinkIndex].sinkID = temp_SinkID; - sinkID = temp_SinkID; + sinkID = temp_SinkID; - am_Sink_s & sink = mMappedData.mSinkMap[temp_SinkID]; + am_Sink_s &sink = mMappedData.mSinkMap[temp_SinkID]; logVerbose("DatabaseHandler::enterSinkDB entered new sink with name", sink.name, "domainID:", sink.domainID, "classID:", sink.sinkClassID, "volume:", sink.volume, "assigned ID:", sink.sinkID); - sink.sinkID=sinkID; - NOTIFY_OBSERVERS1(dboNewSink, sink) + sink.sinkID = sinkID; + NOTIFY_OBSERVERS1(dboNewSink, sink) return (E_OK); } -bool CAmDatabaseHandlerMap::insertCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID) +bool CAmDatabaseHandlerMap::insertCrossfaderDB(const am_Crossfader_s &crossfaderData, am_crossfaderID_t &crossfaderID) { int16_t nextID = 0; - if(mMappedData.increaseID(nextID, mMappedData.mCurrentCrossfaderID, crossfaderData.crossfaderID)) - { - crossfaderID = nextID; - mMappedData.mCrossfaderMap[nextID] = crossfaderData; - mMappedData.mCrossfaderMap[nextID].crossfaderID = nextID; - return (true); - } - else - { - crossfaderID = 0; - logVerbose(__METHOD_NAME__,"Max limit reached."); - return (false); - } + if (mMappedData.increaseID(nextID, mMappedData.mCurrentCrossfaderID, crossfaderData.crossfaderID)) + { + crossfaderID = nextID; + mMappedData.mCrossfaderMap[nextID] = crossfaderData; + mMappedData.mCrossfaderMap[nextID].crossfaderID = nextID; + return (true); + } + else + { + crossfaderID = 0; + logVerbose(__METHOD_NAME__, "Max limit reached."); + return (false); + } } -am_Error_e CAmDatabaseHandlerMap::enterCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID) +am_Error_e CAmDatabaseHandlerMap::enterCrossfaderDB(const am_Crossfader_s &crossfaderData, am_crossfaderID_t &crossfaderID) { - if(crossfaderData.crossfaderID>=DYNAMIC_ID_BOUNDARY) + if (crossfaderData.crossfaderID >= DYNAMIC_ID_BOUNDARY) { - logError(__METHOD_NAME__,"crossfaderID must be below:",DYNAMIC_ID_BOUNDARY); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "crossfaderID must be below:", DYNAMIC_ID_BOUNDARY); + return (E_NOT_POSSIBLE); } - if(!(crossfaderData.hotSink>=HS_UNKNOWN && crossfaderData.hotSink<=HS_MAX)) + if (!(crossfaderData.hotSink >= HS_UNKNOWN && crossfaderData.hotSink <= HS_MAX)) { - logError(__METHOD_NAME__,"hotSink must be valid"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "hotSink must be valid"); + return (E_NOT_POSSIBLE); } - if(crossfaderData.name.empty()) + + if (crossfaderData.name.empty()) { - logError(__METHOD_NAME__,"crossfaderName must not be zero"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "crossfaderName must not be zero"); + return (E_NOT_POSSIBLE); } - if(!existSink(crossfaderData.sinkID_A)) + if (!existSink(crossfaderData.sinkID_A)) { - logError(__METHOD_NAME__,"sinkID_A must exist"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "sinkID_A must exist"); + return (E_NOT_POSSIBLE); } - if(!existSink(crossfaderData.sinkID_B)) + + if (!existSink(crossfaderData.sinkID_B)) { - logError(__METHOD_NAME__,"sinkID_B must exist"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "sinkID_B must exist"); + return (E_NOT_POSSIBLE); } - if(!existSource(crossfaderData.sourceID)) + + if (!existSource(crossfaderData.sourceID)) { - logError(__METHOD_NAME__,"sourceID must exist"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "sourceID must exist"); + return (E_NOT_POSSIBLE); } - am_crossfaderID_t temp_CrossfaderID = 0; + am_crossfaderID_t temp_CrossfaderID = 0; am_crossfaderID_t temp_CrossfaderIndex = 0; bool result; - //if gatewayData is zero and the first Static Sink was already entered, the ID is created + // if gatewayData is zero and the first Static Sink was already entered, the ID is created if (crossfaderData.crossfaderID != 0 || mFirstStaticCrossfader) { - //check if the ID already exists + // check if the ID already exists if (existCrossFader(crossfaderData.crossfaderID)) { - crossfaderID = crossfaderData.crossfaderID; + crossfaderID = crossfaderData.crossfaderID; return (E_ALREADY_EXISTS); } } + result = insertCrossfaderDB(crossfaderData, temp_CrossfaderID); - if( false == result ) - return (E_UNKNOWN); - temp_CrossfaderIndex = temp_CrossfaderID; + if ( false == result ) + { + return (E_UNKNOWN); + } - //if the first static sink is entered, we need to set it onto the boundary - if ( 0==crossfaderData.crossfaderID && mFirstStaticCrossfader) + temp_CrossfaderIndex = temp_CrossfaderID; + + // if the first static sink is entered, we need to set it onto the boundary + if ( 0 == crossfaderData.crossfaderID && mFirstStaticCrossfader) { mFirstStaticCrossfader = false; } - mMappedData.mCrossfaderMap[temp_CrossfaderIndex].crossfaderID = temp_CrossfaderID; - crossfaderID = temp_CrossfaderID; - logVerbose("DatabaseHandler::enterCrossfaderDB entered new crossfader with name=", crossfaderData.name, "sinkA= ", crossfaderData.sinkID_A, "sinkB=", crossfaderData.sinkID_B, "source=", crossfaderData.sourceID, "assigned ID:", crossfaderID); + mMappedData.mCrossfaderMap[temp_CrossfaderIndex].crossfaderID = temp_CrossfaderID; + crossfaderID = temp_CrossfaderID; + logVerbose("DatabaseHandler::enterCrossfaderDB entered new crossfader with name=", crossfaderData.name, "sinkA= ", crossfaderData.sinkID_A, "sinkB=", crossfaderData.sinkID_B, "source=", crossfaderData.sourceID, "assigned ID:", crossfaderID); - NOTIFY_OBSERVERS1(dboNewCrossfader, mMappedData.mCrossfaderMap[temp_CrossfaderIndex]) + NOTIFY_OBSERVERS1(dboNewCrossfader, mMappedData.mCrossfaderMap[temp_CrossfaderIndex]) return (E_OK); } -bool CAmDatabaseHandlerMap::insertGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID) +bool CAmDatabaseHandlerMap::insertGatewayDB(const am_Gateway_s &gatewayData, am_gatewayID_t &gatewayID) { int16_t nextID = 0; - if(mMappedData.increaseID(nextID, mMappedData.mCurrentGatewayID, gatewayData.gatewayID)) - { - gatewayID = nextID; - mMappedData.mGatewayMap[nextID] = gatewayData; - mMappedData.mGatewayMap[nextID].gatewayID = nextID; - return (true); - } - else - { - gatewayID = 0; - logVerbose(__METHOD_NAME__,"Max limit reached."); - return (false); - } + if (mMappedData.increaseID(nextID, mMappedData.mCurrentGatewayID, gatewayData.gatewayID)) + { + gatewayID = nextID; + mMappedData.mGatewayMap[nextID] = gatewayData; + mMappedData.mGatewayMap[nextID].gatewayID = nextID; + return (true); + } + else + { + gatewayID = 0; + logVerbose(__METHOD_NAME__, "Max limit reached."); + return (false); + } } -am_Error_e CAmDatabaseHandlerMap::enterGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID) +am_Error_e CAmDatabaseHandlerMap::enterGatewayDB(const am_Gateway_s &gatewayData, am_gatewayID_t &gatewayID) { - if(gatewayData.gatewayID>=DYNAMIC_ID_BOUNDARY) + if (gatewayData.gatewayID >= DYNAMIC_ID_BOUNDARY) { - logError(__METHOD_NAME__,"gatewayID must be below:",DYNAMIC_ID_BOUNDARY); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "gatewayID must be below:", DYNAMIC_ID_BOUNDARY); + return (E_NOT_POSSIBLE); } - if(!existDomain(gatewayData.controlDomainID)) + if (!existDomain(gatewayData.controlDomainID)) { - logError(__METHOD_NAME__,"controlDomainID must be exist"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "controlDomainID must be exist"); + return (E_NOT_POSSIBLE); } - if(gatewayData.name.empty()) + if (gatewayData.name.empty()) { - logError(__METHOD_NAME__,"gatewayName must not be empty"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "gatewayName must not be empty"); + return (E_NOT_POSSIBLE); } - //might be that the sinks and sources are not there during registration time - //assert(existSink(gatewayData.sinkID)); - //assert(existSource(gatewayData.sourceID)); + // might be that the sinks and sources are not there during registration time + // assert(existSink(gatewayData.sinkID)); + // assert(existSource(gatewayData.sourceID)); - am_gatewayID_t temp_GatewayID = 0; + am_gatewayID_t temp_GatewayID = 0; am_gatewayID_t temp_GatewayIndex = 0; - //if gatewayData is zero and the first Static Sink was already entered, the ID is created + // if gatewayData is zero and the first Static Sink was already entered, the ID is created bool result; if (gatewayData.gatewayID != 0 || mFirstStaticGateway) { - //check if the ID already exists + // check if the ID already exists if (existGateway(gatewayData.gatewayID)) { - gatewayID = gatewayData.gatewayID; + gatewayID = gatewayData.gatewayID; return (E_ALREADY_EXISTS); } } + result = insertGatewayDB(gatewayData, temp_GatewayID); - if( false == result ) - return (E_UNKNOWN); + if ( false == result ) + { + return (E_UNKNOWN); + } - temp_GatewayIndex = temp_GatewayID; - //if the ID is not created, we add it to the query + temp_GatewayIndex = temp_GatewayID; + // if the ID is not created, we add it to the query if (gatewayData.gatewayID == 0 && mFirstStaticGateway) { mFirstStaticGateway = false; } + mMappedData.mGatewayMap[temp_GatewayIndex].gatewayID = temp_GatewayID; - gatewayID = temp_GatewayID; + gatewayID = temp_GatewayID; logVerbose("DatabaseHandler::enterGatewayDB entered new gateway with name", gatewayData.name, "sourceID:", gatewayData.sourceID, "sinkID:", gatewayData.sinkID, "assigned ID:", gatewayID); @@ -877,85 +932,89 @@ am_Error_e CAmDatabaseHandlerMap::enterGatewayDB(const am_Gateway_s & gatewayDat return (E_OK); } -bool CAmDatabaseHandlerMap::insertConverterDB(const am_Converter_s & converteData, am_converterID_t & converterID) +bool CAmDatabaseHandlerMap::insertConverterDB(const am_Converter_s &converteData, am_converterID_t &converterID) { int16_t nextID = 0; - if(mMappedData.increaseID(nextID, mMappedData.mCurrentConverterID, converteData.converterID)) - { - converterID = nextID; - mMappedData.mConverterMap[nextID] = converteData; - mMappedData.mConverterMap[nextID].converterID = nextID; - return (true); - } - else - { - converterID = 0; - logVerbose(__METHOD_NAME__,"Max limit reached."); - return (false); - } + if (mMappedData.increaseID(nextID, mMappedData.mCurrentConverterID, converteData.converterID)) + { + converterID = nextID; + mMappedData.mConverterMap[nextID] = converteData; + mMappedData.mConverterMap[nextID].converterID = nextID; + return (true); + } + else + { + converterID = 0; + logVerbose(__METHOD_NAME__, "Max limit reached."); + return (false); + } } -am_Error_e CAmDatabaseHandlerMap::enterConverterDB(const am_Converter_s & converterData, am_converterID_t & converterID) +am_Error_e CAmDatabaseHandlerMap::enterConverterDB(const am_Converter_s &converterData, am_converterID_t &converterID) { - if(converterData.converterID>=DYNAMIC_ID_BOUNDARY) + if (converterData.converterID >= DYNAMIC_ID_BOUNDARY) { - logError(__METHOD_NAME__,"converterID must be below:",DYNAMIC_ID_BOUNDARY); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "converterID must be below:", DYNAMIC_ID_BOUNDARY); + return (E_NOT_POSSIBLE); } - if(!existSink(converterData.sinkID)) + if (!existSink(converterData.sinkID)) { - logError(__METHOD_NAME__,"sinkID must exists"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "sinkID must exists"); + return (E_NOT_POSSIBLE); } - if(!existSource(converterData.sourceID)) + if (!existSource(converterData.sourceID)) { - logError(__METHOD_NAME__,"sourceID must exists"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "sourceID must exists"); + return (E_NOT_POSSIBLE); } - if(!existDomain(converterData.domainID)) + if (!existDomain(converterData.domainID)) { - logError(__METHOD_NAME__,"domainID must exists"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "domainID must exists"); + return (E_NOT_POSSIBLE); } - if(converterData.name.empty()) + if (converterData.name.empty()) { - logError(__METHOD_NAME__,"converterName must not be empty"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "converterName must not be empty"); + return (E_NOT_POSSIBLE); } - //might be that the sinks and sources are not there during registration time - //assert(existSink(gatewayData.sinkID)); - //assert(existSource(gatewayData.sourceID)); + // might be that the sinks and sources are not there during registration time + // assert(existSink(gatewayData.sinkID)); + // assert(existSource(gatewayData.sourceID)); - am_converterID_t tempID = 0; + am_converterID_t tempID = 0; am_converterID_t tempIndex = 0; - //if gatewayData is zero and the first Static Sink was already entered, the ID is created + // if gatewayData is zero and the first Static Sink was already entered, the ID is created bool result; if (converterData.converterID != 0 || mFirstStaticConverter) { - //check if the ID already exists + // check if the ID already exists if (existConverter(converterData.converterID)) { - converterID = converterData.converterID; + converterID = converterData.converterID; return (E_ALREADY_EXISTS); } } + result = insertConverterDB(converterData, tempID); - if( false == result ) - return (E_UNKNOWN); + if ( false == result ) + { + return (E_UNKNOWN); + } - tempIndex = tempID; - //if the ID is not created, we add it to the query + tempIndex = tempID; + // if the ID is not created, we add it to the query if (converterData.converterID == 0 && mFirstStaticConverter) { - mFirstStaticConverter = false; + mFirstStaticConverter = false; } + mMappedData.mConverterMap[tempIndex].converterID = tempID; - converterID = tempID; + converterID = tempID; logVerbose("DatabaseHandler::enterConverterDB entered new converter with name", converterData.name, "sourceID:", converterData.sourceID, "sinkID:", converterData.sinkID, "assigned ID:", converterID); NOTIFY_OBSERVERS1(dboNewConverter, mMappedData.mConverterMap[tempIndex]) @@ -963,113 +1022,124 @@ am_Error_e CAmDatabaseHandlerMap::enterConverterDB(const am_Converter_s & conver return (E_OK); } -void CAmDatabaseHandlerMap::dump( std::ostream & output ) const +void CAmDatabaseHandlerMap::dump(std::ostream &output) const { - output << std::endl << "****************** DUMP START ******************" << std::endl; - AmMappedData::printMap(mMappedData.mDomainMap, output); - AmMappedData::printMap(mMappedData.mSourceMap, output); - AmMappedData::printMap(mMappedData.mSinkMap, output); - AmMappedData::printMap(mMappedData.mSourceClassesMap, output); - AmMappedData::printMap(mMappedData.mSinkClassesMap, output); - AmMappedData::printMap(mMappedData.mConnectionMap, output); - AmMappedData::printMap(mMappedData.mMainConnectionMap, output); - AmMappedData::printMap(mMappedData.mCrossfaderMap, output); - AmMappedData::printMap(mMappedData.mGatewayMap, output); - AmVectorSystemProperties::const_iterator iter = mMappedData.mSystemProperties.begin(); - output << "System properties" << "\n"; - for(; iter!=mMappedData.mSystemProperties.end(); iter++) - output << "[type:" << iter->type << " value:" << iter->value << "]"; - output << std::endl << "****************** DUMP END ******************" << std::endl; + output << std::endl << "****************** DUMP START ******************" << std::endl; + AmMappedData::printMap(mMappedData.mDomainMap, output); + AmMappedData::printMap(mMappedData.mSourceMap, output); + AmMappedData::printMap(mMappedData.mSinkMap, output); + AmMappedData::printMap(mMappedData.mSourceClassesMap, output); + AmMappedData::printMap(mMappedData.mSinkClassesMap, output); + AmMappedData::printMap(mMappedData.mConnectionMap, output); + AmMappedData::printMap(mMappedData.mMainConnectionMap, output); + AmMappedData::printMap(mMappedData.mCrossfaderMap, output); + AmMappedData::printMap(mMappedData.mGatewayMap, output); + AmVectorSystemProperties::const_iterator iter = mMappedData.mSystemProperties.begin(); + output << "System properties" << "\n"; + for (; iter != mMappedData.mSystemProperties.end(); iter++) + { + output << "[type:" << iter->type << " value:" << iter->value << "]"; + } + + output << std::endl << "****************** DUMP END ******************" << std::endl; } -bool CAmDatabaseHandlerMap::insertSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID) +bool CAmDatabaseHandlerMap::insertSourceDB(const am_Source_s &sourceData, am_sourceID_t &sourceID) { int16_t nextID = 0; - if(mMappedData.increaseID(nextID, mMappedData.mCurrentSourceID, sourceData.sourceID)) - { - sourceID = nextID; - mMappedData.mSourceMap[nextID] = sourceData; - mMappedData.mSourceMap[nextID].sourceID = nextID; - filterDuplicateNotificationConfigurationTypes(mMappedData.mSourceMap[nextID].listNotificationConfigurations); - filterDuplicateNotificationConfigurationTypes(mMappedData.mSourceMap[nextID].listMainNotificationConfigurations); - return (true); - } - else - { - sourceID = 0; - logVerbose(__METHOD_NAME__,"Max limit reached."); - return (false); - } -} - -am_Error_e CAmDatabaseHandlerMap::enterSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID) -{ - if(sourceData.sourceID>=DYNAMIC_ID_BOUNDARY) - { - logError(__METHOD_NAME__,"sourceID must be below:",DYNAMIC_ID_BOUNDARY); - return (E_NOT_POSSIBLE); - } - if(!existDomain(sourceData.domainID)) - { - logError(__METHOD_NAME__,"domainID must be valid"); - return (E_NOT_POSSIBLE); - } - if(sourceData.name.empty()) - { - logError(__METHOD_NAME__,"sourceName must not be zero"); - return (E_NOT_POSSIBLE); - } - if(!existSourceClass(sourceData.sourceClassID)) - { - logError(__METHOD_NAME__,"sourceClassID must be valid"); - return (E_NOT_POSSIBLE); - } - - if(!(sourceData.sourceState>=SS_UNKNNOWN && sourceData.sourceState<=SS_MAX)) - { - logError(__METHOD_NAME__,"sourceState must be valid"); - return (E_NOT_POSSIBLE); - } - - bool isFirstStatic = sourceData.sourceID == 0 && mFirstStaticSource; - am_sourceID_t temp_SourceID = 0; - am_sourceID_t temp_SourceIndex = 0; - AmSource const *reservedSource = objectMatchingPredicate(mMappedData.mSourceMap, [&](const AmSource & obj){ - return true==obj.reserved && obj.name.compare(sourceData.name)==0; - }); - if( NULL != reservedSource ) - { - am_sourceID_t oldSourceID = reservedSource->sourceID; - mMappedData.mSourceMap[oldSourceID] = sourceData; - mMappedData.mSourceMap[oldSourceID].reserved = 0; - temp_SourceID = oldSourceID; - temp_SourceIndex = oldSourceID; - } - else - { - bool result; - if ( !isFirstStatic ) - { - //check if the ID already exists - if (existSourceNameOrID(sourceData.sourceID, sourceData.name)) - { - sourceID = sourceData.sourceID; - return (E_ALREADY_EXISTS); - } - } - result = insertSourceDB(sourceData, temp_SourceID); - if( false == result ) - return (E_UNKNOWN); - temp_SourceIndex = temp_SourceID; + if (mMappedData.increaseID(nextID, mMappedData.mCurrentSourceID, sourceData.sourceID)) + { + sourceID = nextID; + mMappedData.mSourceMap[nextID] = sourceData; + mMappedData.mSourceMap[nextID].sourceID = nextID; + filterDuplicateNotificationConfigurationTypes(mMappedData.mSourceMap[nextID].listNotificationConfigurations); + filterDuplicateNotificationConfigurationTypes(mMappedData.mSourceMap[nextID].listMainNotificationConfigurations); + return (true); + } + else + { + sourceID = 0; + logVerbose(__METHOD_NAME__, "Max limit reached."); + return (false); + } +} + +am_Error_e CAmDatabaseHandlerMap::enterSourceDB(const am_Source_s &sourceData, am_sourceID_t &sourceID) +{ + if (sourceData.sourceID >= DYNAMIC_ID_BOUNDARY) + { + logError(__METHOD_NAME__, "sourceID must be below:", DYNAMIC_ID_BOUNDARY); + return (E_NOT_POSSIBLE); + } + + if (!existDomain(sourceData.domainID)) + { + logError(__METHOD_NAME__, "domainID must be valid"); + return (E_NOT_POSSIBLE); + } + + if (sourceData.name.empty()) + { + logError(__METHOD_NAME__, "sourceName must not be zero"); + return (E_NOT_POSSIBLE); + } + + if (!existSourceClass(sourceData.sourceClassID)) + { + logError(__METHOD_NAME__, "sourceClassID must be valid"); + return (E_NOT_POSSIBLE); + } + + if (!(sourceData.sourceState >= SS_UNKNNOWN && sourceData.sourceState <= SS_MAX)) + { + logError(__METHOD_NAME__, "sourceState must be valid"); + return (E_NOT_POSSIBLE); + } + + bool isFirstStatic = sourceData.sourceID == 0 && mFirstStaticSource; + am_sourceID_t temp_SourceID = 0; + am_sourceID_t temp_SourceIndex = 0; + AmSource const *reservedSource = objectMatchingPredicate(mMappedData.mSourceMap, [&](const AmSource &obj){ + return true == obj.reserved && obj.name.compare(sourceData.name) == 0; + }); + if ( NULL != reservedSource ) + { + am_sourceID_t oldSourceID = reservedSource->sourceID; + mMappedData.mSourceMap[oldSourceID] = sourceData; + mMappedData.mSourceMap[oldSourceID].reserved = 0; + temp_SourceID = oldSourceID; + temp_SourceIndex = oldSourceID; + } + else + { + bool result; + if ( !isFirstStatic ) + { + // check if the ID already exists + if (existSourceNameOrID(sourceData.sourceID, sourceData.name)) + { + sourceID = sourceData.sourceID; + return (E_ALREADY_EXISTS); + } + } + + result = insertSourceDB(sourceData, temp_SourceID); + if ( false == result ) + { + return (E_UNKNOWN); + } + + temp_SourceIndex = temp_SourceID; } if ( isFirstStatic ) { - //if the first static sink is entered, we need to set it onto the boundary if needed + // if the first static sink is entered, we need to set it onto the boundary if needed mFirstStaticSource = false; } + mMappedData.mSourceMap[temp_SourceIndex].sourceID = temp_SourceID; - sourceID = temp_SourceID; + sourceID = temp_SourceID; logVerbose("DatabaseHandler::enterSourceDB entered new source with name", sourceData.name, "domainID:", sourceData.domainID, "classID:", sourceData.sourceClassID, "visible:", sourceData.visible, "assigned ID:", sourceID); @@ -1078,169 +1148,177 @@ am_Error_e CAmDatabaseHandlerMap::enterSourceDB(const am_Source_s & sourceData, return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::enterConnectionDB(const am_Connection_s& connection, am_connectionID_t& connectionID) +am_Error_e CAmDatabaseHandlerMap::enterConnectionDB(const am_Connection_s &connection, am_connectionID_t &connectionID) { - if(connection.connectionID!=0) + if (connection.connectionID != 0) { - logError(__METHOD_NAME__,"connectionID must be 0!"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "connectionID must be 0!"); + return (E_NOT_POSSIBLE); } - if(!existSink(connection.sinkID)) + if (!existSink(connection.sinkID)) { - logError(__METHOD_NAME__,"sinkID must exist!"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "sinkID must exist!"); + return (E_NOT_POSSIBLE); } - if(!existSource(connection.sourceID)) + if (!existSource(connection.sourceID)) { - logError(__METHOD_NAME__,"sourceID must exist!"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "sourceID must exist!"); + return (E_NOT_POSSIBLE); } - //connection format is not checked, because it's project specific + + // connection format is not checked, because it's project specific int16_t nextID = 0; - if(mMappedData.increaseConnectionID(nextID)) - { - connectionID = nextID; - mMappedData.mConnectionMap[nextID] = connection; - mMappedData.mConnectionMap[nextID].connectionID = nextID; - mMappedData.mConnectionMap[nextID].reserved = true; - } - else - { - connectionID = 0; - logVerbose(__METHOD_NAME__,"Max limit reached."); - return (E_UNKNOWN); - } + if (mMappedData.increaseConnectionID(nextID)) + { + connectionID = nextID; + mMappedData.mConnectionMap[nextID] = connection; + mMappedData.mConnectionMap[nextID].connectionID = nextID; + mMappedData.mConnectionMap[nextID].reserved = true; + } + else + { + connectionID = 0; + logVerbose(__METHOD_NAME__, "Max limit reached."); + return (E_UNKNOWN); + } logVerbose("DatabaseHandler::enterConnectionDB entered new connection sinkID=", connection.sinkID, "sourceID=", connection.sourceID, "connectionFormat=", connection.connectionFormat, "assigned ID=", connectionID); return (E_OK); } -bool CAmDatabaseHandlerMap::insertSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID) +bool CAmDatabaseHandlerMap::insertSinkClassDB(const am_SinkClass_s &sinkClass, am_sinkClass_t &sinkClassID) { int16_t nextID = 0; - if(mMappedData.increaseID(nextID, mMappedData.mCurrentSinkClassesID, sinkClass.sinkClassID)) - { - sinkClassID = nextID; - mMappedData.mSinkClassesMap[nextID] = sinkClass; - mMappedData.mSinkClassesMap[nextID].sinkClassID = nextID; - return (true); - } - else - { - sinkClassID = 0; - logVerbose(__METHOD_NAME__,"Max limit reached."); - return (false); - } + if (mMappedData.increaseID(nextID, mMappedData.mCurrentSinkClassesID, sinkClass.sinkClassID)) + { + sinkClassID = nextID; + mMappedData.mSinkClassesMap[nextID] = sinkClass; + mMappedData.mSinkClassesMap[nextID].sinkClassID = nextID; + return (true); + } + else + { + sinkClassID = 0; + logVerbose(__METHOD_NAME__, "Max limit reached."); + return (false); + } } -am_Error_e CAmDatabaseHandlerMap::enterSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID) +am_Error_e CAmDatabaseHandlerMap::enterSinkClassDB(const am_SinkClass_s &sinkClass, am_sinkClass_t &sinkClassID) { - if(sinkClass.sinkClassID>=DYNAMIC_ID_BOUNDARY) + if (sinkClass.sinkClassID >= DYNAMIC_ID_BOUNDARY) { - logError(__METHOD_NAME__,"sinkClassID must be <",DYNAMIC_ID_BOUNDARY); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "sinkClassID must be <", DYNAMIC_ID_BOUNDARY); + return (E_NOT_POSSIBLE); } - if(sinkClass.name.empty()) + if (sinkClass.name.empty()) { - logError(__METHOD_NAME__,"name must not be empty"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "name must not be empty"); + return (E_NOT_POSSIBLE); } - am_sinkClass_t temp_SinkClassID = 0; + am_sinkClass_t temp_SinkClassID = 0; am_sinkClass_t temp_SinkClassIndex = 0; - bool result; - if (sinkClass.sinkClassID != 0 || mFirstStaticSinkClass) - { - //check if the ID already exists - if (existSinkClass(sinkClass.sinkClassID)) - { - sinkClassID = sinkClass.sinkClassID; - return (E_ALREADY_EXISTS); - } - } - result = insertSinkClassDB(sinkClass, temp_SinkClassID); - if( false == result ) - return (E_UNKNOWN); - - temp_SinkClassIndex = temp_SinkClassID; - //if the ID is not created, we add it to the query - if (sinkClass.sinkClassID == 0 && mFirstStaticSinkClass) - { - mFirstStaticSinkClass = false; - } - mMappedData.mSinkClassesMap[temp_SinkClassIndex].sinkClassID = temp_SinkClassID; - sinkClassID = temp_SinkClassID; - - //todo:change last_insert implementations for multithreaded usage... + bool result; + if (sinkClass.sinkClassID != 0 || mFirstStaticSinkClass) + { + // check if the ID already exists + if (existSinkClass(sinkClass.sinkClassID)) + { + sinkClassID = sinkClass.sinkClassID; + return (E_ALREADY_EXISTS); + } + } + + result = insertSinkClassDB(sinkClass, temp_SinkClassID); + if ( false == result ) + { + return (E_UNKNOWN); + } + + temp_SinkClassIndex = temp_SinkClassID; + // if the ID is not created, we add it to the query + if (sinkClass.sinkClassID == 0 && mFirstStaticSinkClass) + { + mFirstStaticSinkClass = false; + } + + mMappedData.mSinkClassesMap[temp_SinkClassIndex].sinkClassID = temp_SinkClassID; + sinkClassID = temp_SinkClassID; + + // todo:change last_insert implementations for multithreaded usage... logVerbose("DatabaseHandler::enterSinkClassDB entered new sinkClass"); NOTIFY_OBSERVERS(dboNumberOfSinkClassesChanged) return (E_OK); } -bool CAmDatabaseHandlerMap::insertSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass) +bool CAmDatabaseHandlerMap::insertSourceClassDB(am_sourceClass_t &sourceClassID, const am_SourceClass_s &sourceClass) { int16_t nextID = 0; - if(mMappedData.increaseID(nextID, mMappedData.mCurrentSourceClassesID, sourceClass.sourceClassID)) - { - sourceClassID = nextID; - mMappedData.mSourceClassesMap[nextID] = sourceClass; - mMappedData.mSourceClassesMap[nextID].sourceClassID = nextID; - return (true); - } - else - { - sourceClassID = 0; - logVerbose(__METHOD_NAME__,"Max limit reached."); - return (false); - } + if (mMappedData.increaseID(nextID, mMappedData.mCurrentSourceClassesID, sourceClass.sourceClassID)) + { + sourceClassID = nextID; + mMappedData.mSourceClassesMap[nextID] = sourceClass; + mMappedData.mSourceClassesMap[nextID].sourceClassID = nextID; + return (true); + } + else + { + sourceClassID = 0; + logVerbose(__METHOD_NAME__, "Max limit reached."); + return (false); + } } -am_Error_e CAmDatabaseHandlerMap::enterSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass) +am_Error_e CAmDatabaseHandlerMap::enterSourceClassDB(am_sourceClass_t &sourceClassID, const am_SourceClass_s &sourceClass) { - if(sourceClass.sourceClassID>=DYNAMIC_ID_BOUNDARY) + if (sourceClass.sourceClassID >= DYNAMIC_ID_BOUNDARY) { - logError(__METHOD_NAME__,"sourceClassID must be <",DYNAMIC_ID_BOUNDARY); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "sourceClassID must be <", DYNAMIC_ID_BOUNDARY); + return (E_NOT_POSSIBLE); } - if(sourceClass.name.empty()) + if (sourceClass.name.empty()) { - logError(__METHOD_NAME__,"name must not be empty"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "name must not be empty"); + return (E_NOT_POSSIBLE); } - - am_sourceClass_t temp_SourceClassID = 0; + am_sourceClass_t temp_SourceClassID = 0; am_sourceClass_t temp_SourceClassIndex = 0; - bool result; - if (sourceClass.sourceClassID != 0 || mFirstStaticSourceClass) - { - //check if the ID already exists - if (existSourceClass(sourceClass.sourceClassID)) - { - sourceClassID = sourceClass.sourceClassID; - return (E_ALREADY_EXISTS); - } - } - result = insertSourceClassDB(temp_SourceClassID, sourceClass); - if( false == result ) - return (E_UNKNOWN); - - temp_SourceClassIndex = temp_SourceClassID; - //if the ID is not created, we add it to the query - if (sourceClass.sourceClassID == 0 && mFirstStaticSourceClass) - { - mFirstStaticSinkClass = false; - } - mMappedData.mSourceClassesMap[temp_SourceClassIndex].sourceClassID = temp_SourceClassID; - sourceClassID = temp_SourceClassID; - - //todo:change last_insert implementations for multithread usage... + bool result; + if (sourceClass.sourceClassID != 0 || mFirstStaticSourceClass) + { + // check if the ID already exists + if (existSourceClass(sourceClass.sourceClassID)) + { + sourceClassID = sourceClass.sourceClassID; + return (E_ALREADY_EXISTS); + } + } + + result = insertSourceClassDB(temp_SourceClassID, sourceClass); + if ( false == result ) + { + return (E_UNKNOWN); + } + + temp_SourceClassIndex = temp_SourceClassID; + // if the ID is not created, we add it to the query + if (sourceClass.sourceClassID == 0 && mFirstStaticSourceClass) + { + mFirstStaticSinkClass = false; + } + + mMappedData.mSourceClassesMap[temp_SourceClassIndex].sourceClassID = temp_SourceClassID; + sourceClassID = temp_SourceClassID; + + // todo:change last_insert implementations for multithread usage... logVerbose("DatabaseHandler::enterSourceClassDB entered new sourceClass"); @@ -1249,13 +1327,13 @@ am_Error_e CAmDatabaseHandlerMap::enterSourceClassDB(am_sourceClass_t & sourceCl return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::enterSystemProperties(const std::vector & listSystemProperties) +am_Error_e CAmDatabaseHandlerMap::enterSystemProperties(const std::vector &listSystemProperties) { - if(listSystemProperties.empty()) - { - logError(__METHOD_NAME__,"listSystemProperties must not be empty"); - return (E_NOT_POSSIBLE); - } + if (listSystemProperties.empty()) + { + logError(__METHOD_NAME__, "listSystemProperties must not be empty"); + return (E_NOT_POSSIBLE); + } mMappedData.mSystemProperties = listSystemProperties; @@ -1263,27 +1341,29 @@ am_Error_e CAmDatabaseHandlerMap::enterSystemProperties(const std::vector& listConnectionID) +am_Error_e CAmDatabaseHandlerMap::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector &listConnectionID) { - if(mainconnectionID==0) + if (mainconnectionID == 0) { - logError(__METHOD_NAME__,"mainconnectionID must not be 0"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "mainconnectionID must not be 0"); + return (E_NOT_POSSIBLE); } if (!existMainConnection(mainconnectionID)) { - logError(__METHOD_NAME__,"existMainConnection must exist"); + logError(__METHOD_NAME__, "existMainConnection must exist"); return (E_NON_EXISTENT); } int16_t delay = calculateDelayForRoute(listConnectionID); - //now we replace the data in the main connection object with the new one + // now we replace the data in the main connection object with the new one mMappedData.mMainConnectionMap[mainconnectionID].listConnectionID = listConnectionID; - if (changeDelayMainConnection(delay,mainconnectionID) == E_NO_CHANGE) + if (changeDelayMainConnection(delay, mainconnectionID) == E_NO_CHANGE) + { logError("DatabaseHandler::changeMainConnectionRouteDB error while changing mainConnectionDelay to ", delay); + } logVerbose("DatabaseHandler::changeMainConnectionRouteDB entered new route:", mainconnectionID); return (E_OK); @@ -1291,21 +1371,21 @@ am_Error_e CAmDatabaseHandlerMap::changeMainConnectionRouteDB(const am_mainConne am_Error_e CAmDatabaseHandlerMap::changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState) { - if(mainconnectionID==0) + if (mainconnectionID == 0) { - logError(__METHOD_NAME__,"mainconnectionID must not be 0"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "mainconnectionID must not be 0"); + return (E_NOT_POSSIBLE); } - if(!(connectionState>=CS_UNKNOWN && connectionState<=CS_MAX)) + if (!(connectionState >= CS_UNKNOWN && connectionState <= CS_MAX)) { - logError(__METHOD_NAME__,"connectionState must be valid"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "connectionState must be valid"); + return (E_NOT_POSSIBLE); } if (!existMainConnection(mainconnectionID)) { - logError(__METHOD_NAME__,"existMainConnection must exist"); + logError(__METHOD_NAME__, "existMainConnection must exist"); return (E_NON_EXISTENT); } @@ -1320,7 +1400,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkMainVolumeDB(const am_mainVolume_t m { if (!existSink(sinkID)) { - logError(__METHOD_NAME__,"sinkID must exist"); + logError(__METHOD_NAME__, "sinkID must exist"); return (E_NON_EXISTENT); } @@ -1333,17 +1413,17 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkMainVolumeDB(const am_mainVolume_t m return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::changeSinkAvailabilityDB(const am_Availability_s & availability, const am_sinkID_t sinkID) +am_Error_e CAmDatabaseHandlerMap::changeSinkAvailabilityDB(const am_Availability_s &availability, const am_sinkID_t sinkID) { - if (!(availability.availability>=A_UNKNOWN && availability.availability<=A_MAX)) + if (!(availability.availability >= A_UNKNOWN && availability.availability <= A_MAX)) { - logError(__METHOD_NAME__,"availability must be valid"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "availability must be valid"); + return (E_NOT_POSSIBLE); } if (!existSink(sinkID)) { - logError(__METHOD_NAME__,"sinkID must exist"); + logError(__METHOD_NAME__, "sinkID must exist"); return (E_NON_EXISTENT); } @@ -1353,23 +1433,24 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkAvailabilityDB(const am_Availability if (sinkVisible(sinkID)) { - NOTIFY_OBSERVERS2(dboSinkAvailabilityChanged,sinkID, availability) + NOTIFY_OBSERVERS2(dboSinkAvailabilityChanged, sinkID, availability) } + return (E_OK); } am_Error_e CAmDatabaseHandlerMap::changeDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID) { - if(!(domainState>=DS_UNKNOWN && domainState<=DS_MAX)) + if (!(domainState >= DS_UNKNOWN && domainState <= DS_MAX)) { - logError(__METHOD_NAME__,"domainState must be valid"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "domainState must be valid"); + return (E_NOT_POSSIBLE); } if (!existDomain(domainID)) { - logError(__METHOD_NAME__,"domainID must exist"); + logError(__METHOD_NAME__, "domainID must exist"); return (E_NON_EXISTENT); } @@ -1382,15 +1463,15 @@ am_Error_e CAmDatabaseHandlerMap::changeDomainStateDB(const am_DomainState_e dom am_Error_e CAmDatabaseHandlerMap::changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID) { - if(!(muteState>=MS_UNKNOWN && muteState<=MS_MAX)) + if (!(muteState >= MS_UNKNOWN && muteState <= MS_MAX)) { - logError(__METHOD_NAME__,"muteState must be valid"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "muteState must be valid"); + return (E_NOT_POSSIBLE); } if (!existSink(sinkID)) { - logError(__METHOD_NAME__,"sinkID must exist"); + logError(__METHOD_NAME__, "sinkID must exist"); return (E_NON_EXISTENT); } @@ -1403,52 +1484,60 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkMuteStateDB(const am_MuteState_e mut return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID) +am_Error_e CAmDatabaseHandlerMap::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s &soundProperty, const am_sinkID_t sinkID) { if (!existSink(sinkID)) { - logError(__METHOD_NAME__,"sinkID must exist"); + logError(__METHOD_NAME__, "sinkID must exist"); return (E_NON_EXISTENT); } - am_Sink_Database_s & sink = mMappedData.mSinkMap[sinkID]; + + am_Sink_Database_s &sink = mMappedData.mSinkMap[sinkID]; std::vector::iterator elementIterator = sink.listMainSoundProperties.begin(); - for (;elementIterator != sink.listMainSoundProperties.end(); ++elementIterator) - { - if (elementIterator->type == soundProperty.type) - { - DB_COND_UPDATE_RIE(elementIterator->value, soundProperty.value); - if(sink.cacheMainSoundProperties.size()) - sink.cacheMainSoundProperties[soundProperty.type] = soundProperty.value; - break; - } - } + for (; elementIterator != sink.listMainSoundProperties.end(); ++elementIterator) + { + if (elementIterator->type == soundProperty.type) + { + DB_COND_UPDATE_RIE(elementIterator->value, soundProperty.value); + if (sink.cacheMainSoundProperties.size()) + { + sink.cacheMainSoundProperties[soundProperty.type] = soundProperty.value; + } + + break; + } + } logVerbose("DatabaseHandler::changeMainSinkSoundPropertyDB changed MainSinkSoundProperty of sink:", sinkID, "type:", soundProperty.type, "to:", soundProperty.value); NOTIFY_OBSERVERS2(dboMainSinkSoundPropertyChanged, sinkID, soundProperty) return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID) +am_Error_e CAmDatabaseHandlerMap::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s &soundProperty, const am_sourceID_t sourceID) { if (!existSource(sourceID)) { - logError(__METHOD_NAME__,"sourceID must exist"); + logError(__METHOD_NAME__, "sourceID must exist"); return (E_NON_EXISTENT); } - am_Source_Database_s & source = mMappedData.mSourceMap.at(sourceID); + + am_Source_Database_s &source = mMappedData.mSourceMap.at(sourceID); std::vector::iterator elementIterator = source.listMainSoundProperties.begin(); - for (;elementIterator != source.listMainSoundProperties.end(); ++elementIterator) - { - if (elementIterator->type == soundProperty.type) - { - DB_COND_UPDATE_RIE(elementIterator->value, soundProperty.value); - if(source.cacheMainSoundProperties.size()) - source.cacheMainSoundProperties[soundProperty.type] = soundProperty.value; - break; - } - } + for (; elementIterator != source.listMainSoundProperties.end(); ++elementIterator) + { + if (elementIterator->type == soundProperty.type) + { + DB_COND_UPDATE_RIE(elementIterator->value, soundProperty.value); + if (source.cacheMainSoundProperties.size()) + { + source.cacheMainSoundProperties[soundProperty.type] = soundProperty.value; + } + + break; + } + } logVerbose("DatabaseHandler::changeMainSourceSoundPropertyDB changed MainSinkSoundProperty of source:", sourceID, "type:", soundProperty.type, "to:", soundProperty.value); @@ -1456,17 +1545,17 @@ am_Error_e CAmDatabaseHandlerMap::changeMainSourceSoundPropertyDB(const am_MainS return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::changeSourceAvailabilityDB(const am_Availability_s & availability, const am_sourceID_t sourceID) +am_Error_e CAmDatabaseHandlerMap::changeSourceAvailabilityDB(const am_Availability_s &availability, const am_sourceID_t sourceID) { - if(!(availability.availability>=A_UNKNOWN && availability.availability<=A_MAX)) + if (!(availability.availability >= A_UNKNOWN && availability.availability <= A_MAX)) { - logError(__METHOD_NAME__,"availability must be valid"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "availability must be valid"); + return (E_NOT_POSSIBLE); } if (!existSource(sourceID)) { - logError(__METHOD_NAME__,"sourceID must exist"); + logError(__METHOD_NAME__, "sourceID must exist"); return (E_NON_EXISTENT); } @@ -1476,19 +1565,22 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceAvailabilityDB(const am_Availabili if (sourceVisible(sourceID)) { - NOTIFY_OBSERVERS2(dboSourceAvailabilityChanged, sourceID, availability) + NOTIFY_OBSERVERS2(dboSourceAvailabilityChanged, sourceID, availability) } + return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::changeSystemPropertyDB(const am_SystemProperty_s & property) +am_Error_e CAmDatabaseHandlerMap::changeSystemPropertyDB(const am_SystemProperty_s &property) { std::vector::iterator elementIterator = mMappedData.mSystemProperties.begin(); - for (;elementIterator != mMappedData.mSystemProperties.end(); ++elementIterator) - { - if (elementIterator->type == property.type) - DB_COND_UPDATE_RIE(elementIterator->value, property.value); - } + for (; elementIterator != mMappedData.mSystemProperties.end(); ++elementIterator) + { + if (elementIterator->type == property.type) + { + DB_COND_UPDATE_RIE(elementIterator->value, property.value); + } + } logVerbose("DatabaseHandler::changeSystemPropertyDB changed system property"); @@ -1502,16 +1594,19 @@ am_Error_e CAmDatabaseHandlerMap::removeMainConnectionDB(const am_mainConnection if (!existMainConnection(mainConnectionID)) { - logError(__METHOD_NAME__,"mainConnectionID must exist"); + logError(__METHOD_NAME__, "mainConnectionID must exist"); return (E_NON_EXISTENT); } DB_COND_UPDATE_INIT; DB_COND_UPDATE(mMappedData.mMainConnectionMap[mainConnectionID].mainConnectionID, CS_DISCONNECTED); if (DB_COND_ISMODIFIED) + { NOTIFY_OBSERVERS2(dboMainConnectionStateChanged, mainConnectionID, CS_DISCONNECTED) - mMappedData.mMainConnectionMap.erase(mainConnectionID); + mMappedData.mMainConnectionMap.erase(mainConnectionID); + } + logVerbose("DatabaseHandler::removeMainConnectionDB removed:", mainConnectionID); NOTIFY_OBSERVERS1(dboRemovedMainConnection, mainConnectionID) @@ -1523,7 +1618,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSinkDB(const am_sinkID_t sinkID) if (!existSink(sinkID)) { - logError(__METHOD_NAME__,"sinkID must exist"); + logError(__METHOD_NAME__, "sinkID must exist"); return (E_NON_EXISTENT); } @@ -1531,7 +1626,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSinkDB(const am_sinkID_t sinkID) mMappedData.mSinkMap.erase(sinkID); // todo: Check the tables SinkMainSoundProperty and SinkMainNotificationConfiguration with 'visible' set to true - //if visible is true then delete SinkMainSoundProperty and SinkMainNotificationConfiguration ???? + // if visible is true then delete SinkMainSoundProperty and SinkMainNotificationConfiguration ???? logVerbose("DatabaseHandler::removeSinkDB removed:", sinkID); NOTIFY_OBSERVERS2(dboRemovedSink, sinkID, visible) @@ -1544,7 +1639,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSourceDB(const am_sourceID_t sourceID) if (!existSource(sourceID)) { - logError(__METHOD_NAME__,"sourceID must exist"); + logError(__METHOD_NAME__, "sourceID must exist"); return (E_NON_EXISTENT); } @@ -1553,7 +1648,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSourceDB(const am_sourceID_t sourceID) mMappedData.mSourceMap.erase(sourceID); // todo: Check the tables SourceMainSoundProperty and SourceMainNotificationConfiguration with 'visible' set to true - //if visible is true then delete SourceMainSoundProperty and SourceMainNotificationConfiguration ???? + // if visible is true then delete SourceMainSoundProperty and SourceMainNotificationConfiguration ???? logVerbose("DatabaseHandler::removeSourceDB removed:", sourceID); NOTIFY_OBSERVERS2(dboRemovedSource, sourceID, visible) @@ -1565,7 +1660,7 @@ am_Error_e CAmDatabaseHandlerMap::removeGatewayDB(const am_gatewayID_t gatewayID if (!existGateway(gatewayID)) { - logError(__METHOD_NAME__,"gatewayID must exist"); + logError(__METHOD_NAME__, "gatewayID must exist"); return (E_NON_EXISTENT); } @@ -1581,7 +1676,7 @@ am_Error_e CAmDatabaseHandlerMap::removeConverterDB(const am_converterID_t conve if (!existConverter(converterID)) { - logError(__METHOD_NAME__,"converterID must exist"); + logError(__METHOD_NAME__, "converterID must exist"); return (E_NON_EXISTENT); } @@ -1597,9 +1692,10 @@ am_Error_e CAmDatabaseHandlerMap::removeCrossfaderDB(const am_crossfaderID_t cro if (!existCrossFader(crossfaderID)) { - logError(__METHOD_NAME__,"crossfaderID must exist"); + logError(__METHOD_NAME__, "crossfaderID must exist"); return (E_NON_EXISTENT); } + mMappedData.mCrossfaderMap.erase(crossfaderID); logVerbose("DatabaseHandler::removeCrossfaderDB removed:", crossfaderID); @@ -1613,9 +1709,10 @@ am_Error_e CAmDatabaseHandlerMap::removeDomainDB(const am_domainID_t domainID) if (!existDomain(domainID)) { - logError(__METHOD_NAME__,"domainID must exist"); + logError(__METHOD_NAME__, "domainID must exist"); return (E_NON_EXISTENT); } + mMappedData.mDomainMap.erase(domainID); logVerbose("DatabaseHandler::removeDomainDB removed:", domainID); @@ -1629,7 +1726,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSinkClassDB(const am_sinkClass_t sinkCla if (!existSinkClass(sinkClassID)) { - logError(__METHOD_NAME__,"sinkClassID must exist"); + logError(__METHOD_NAME__, "sinkClassID must exist"); return (E_NON_EXISTENT); } @@ -1645,7 +1742,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSourceClassDB(const am_sourceClass_t sou if (!existSourceClass(sourceClassID)) { - logError(__METHOD_NAME__,"sourceClassID must exist"); + logError(__METHOD_NAME__, "sourceClassID must exist"); return (E_NON_EXISTENT); } @@ -1659,7 +1756,7 @@ am_Error_e CAmDatabaseHandlerMap::removeConnection(const am_connectionID_t conne { if (!existConnectionID(connectionID)) { - logError(__METHOD_NAME__,"connectionID must exist",connectionID); + logError(__METHOD_NAME__, "connectionID must exist", connectionID); return (E_NON_EXISTENT); } @@ -1669,87 +1766,95 @@ am_Error_e CAmDatabaseHandlerMap::removeConnection(const am_connectionID_t conne return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s & classInfo) const +am_Error_e CAmDatabaseHandlerMap::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s &classInfo) const { if (!existSource(sourceID)) { - logWarning(__METHOD_NAME__,"sourceID must exist"); + logWarning(__METHOD_NAME__, "sourceID must exist"); return (E_NON_EXISTENT); } + am_Source_Database_s source = mMappedData.mSourceMap.at(sourceID); - classInfo.sourceClassID = source.sourceClassID; + classInfo.sourceClassID = source.sourceClassID; if (!existSourceClass(classInfo.sourceClassID)) { return (E_NON_EXISTENT); } + am_SourceClass_s tmpClass = mMappedData.mSourceClassesMap.at(classInfo.sourceClassID); classInfo = tmpClass; return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s & sinkData) const +am_Error_e CAmDatabaseHandlerMap::getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s &sinkData) const { if (!existSink(sinkID)) { - logWarning(__METHOD_NAME__,"sinkID",sinkID,"does not exist"); + logWarning(__METHOD_NAME__, "sinkID", sinkID, "does not exist"); return (E_NON_EXISTENT); } am_Sink_Database_s mappedSink = mMappedData.mSinkMap.at(sinkID); - if( true == mappedSink.reserved ) - return (E_NON_EXISTENT); - sinkData = mappedSink; + if ( true == mappedSink.reserved ) + { + return (E_NON_EXISTENT); + } + + sinkData = mappedSink; return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s & sourceData) const +am_Error_e CAmDatabaseHandlerMap::getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s &sourceData) const { if (!existSource(sourceID)) { - logWarning(__METHOD_NAME__,"sourceID",sourceID,"does not exist"); + logWarning(__METHOD_NAME__, "sourceID", sourceID, "does not exist"); return (E_NON_EXISTENT); } am_Source_Database_s mappedSource = mMappedData.mSourceMap.at(sourceID); - if( true == mappedSource.reserved ) - return (E_NON_EXISTENT); + if ( true == mappedSource.reserved ) + { + return (E_NON_EXISTENT); + } sourceData = mappedSource; return (E_OK); } -am_Error_e am::CAmDatabaseHandlerMap::getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s & mainConnectionData) const +am_Error_e am::CAmDatabaseHandlerMap::getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s &mainConnectionData) const { if (!existMainConnection(mainConnectionID)) { - logError(__METHOD_NAME__,"mainConnectionID must exist"); + logError(__METHOD_NAME__, "mainConnectionID must exist"); return (E_NON_EXISTENT); } + am_MainConnection_s temp = mMappedData.mMainConnectionMap.at(mainConnectionID); mainConnectionData = temp; return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::changeSinkClassInfoDB(const am_SinkClass_s& sinkClass) +am_Error_e CAmDatabaseHandlerMap::changeSinkClassInfoDB(const am_SinkClass_s &sinkClass) { - if(sinkClass.listClassProperties.empty()) + if (sinkClass.listClassProperties.empty()) { - logError(__METHOD_NAME__,"listClassProperties must not be empty"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "listClassProperties must not be empty"); + return (E_NOT_POSSIBLE); } - //check if the ID already exists + // check if the ID already exists if (!existSinkClass(sinkClass.sinkClassID)) { - logError(__METHOD_NAME__,"sinkClassID must exist"); + logError(__METHOD_NAME__, "sinkClassID must exist"); return (E_NON_EXISTENT); } @@ -1759,18 +1864,18 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkClassInfoDB(const am_SinkClass_s& si return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::changeSourceClassInfoDB(const am_SourceClass_s& sourceClass) +am_Error_e CAmDatabaseHandlerMap::changeSourceClassInfoDB(const am_SourceClass_s &sourceClass) { - if(sourceClass.listClassProperties.empty()) + if (sourceClass.listClassProperties.empty()) { - logError(__METHOD_NAME__,"listClassProperties must not be empty"); - return (E_NOT_POSSIBLE); + logError(__METHOD_NAME__, "listClassProperties must not be empty"); + return (E_NOT_POSSIBLE); } - //check if the ID already exists + // check if the ID already exists if (!existSourceClass(sourceClass.sourceClassID)) { - logError(__METHOD_NAME__,"sourceClassID must exist"); + logError(__METHOD_NAME__, "sourceClassID must exist"); return (E_NON_EXISTENT); } @@ -1780,33 +1885,35 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceClassInfoDB(const am_SourceClass_s return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s & sinkClass) const +am_Error_e CAmDatabaseHandlerMap::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s &sinkClass) const { if (!existSink(sinkID)) { - logWarning(__METHOD_NAME__,"sinkID must exist"); + logWarning(__METHOD_NAME__, "sinkID must exist"); return (E_NON_EXISTENT); } + am_Sink_Database_s sink = mMappedData.mSinkMap.at(sinkID); - sinkClass.sinkClassID = sink.sinkClassID; + sinkClass.sinkClassID = sink.sinkClassID; if (!existSinkClass(sinkClass.sinkClassID)) { - logWarning(__METHOD_NAME__,"sinkClassID must exist"); + logWarning(__METHOD_NAME__, "sinkClassID must exist"); return (E_NON_EXISTENT); } + am_SinkClass_s tmpSinkClass = mMappedData.mSinkClassesMap.at(sinkClass.sinkClassID); sinkClass = tmpSinkClass; return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s & gatewayData) const +am_Error_e CAmDatabaseHandlerMap::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s &gatewayData) const { if (!existGateway(gatewayID)) { - logWarning(__METHOD_NAME__,"gatewayID must exist"); + logWarning(__METHOD_NAME__, "gatewayID must exist"); return (E_NON_EXISTENT); } @@ -1816,11 +1923,11 @@ am_Error_e CAmDatabaseHandlerMap::getGatewayInfoDB(const am_gatewayID_t gatewayI } -am_Error_e CAmDatabaseHandlerMap::getConverterInfoDB(const am_converterID_t converterID, am_Converter_s& converterData) const +am_Error_e CAmDatabaseHandlerMap::getConverterInfoDB(const am_converterID_t converterID, am_Converter_s &converterData) const { if (!existConverter(converterID)) { - logWarning(__METHOD_NAME__,"converterID must exist"); + logWarning(__METHOD_NAME__, "converterID must exist"); return (E_NON_EXISTENT); } @@ -1830,11 +1937,11 @@ am_Error_e CAmDatabaseHandlerMap::getConverterInfoDB(const am_converterID_t conv } -am_Error_e CAmDatabaseHandlerMap::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s & crossfaderData) const +am_Error_e CAmDatabaseHandlerMap::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s &crossfaderData) const { if (!existCrossFader(crossfaderID)) { - logWarning(__METHOD_NAME__,"crossfaderID must exist"); + logWarning(__METHOD_NAME__, "crossfaderID must exist"); return (E_NON_EXISTENT); } @@ -1843,411 +1950,442 @@ am_Error_e CAmDatabaseHandlerMap::getCrossfaderInfoDB(const am_crossfaderID_t cr return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListSinksOfDomain(const am_domainID_t domainID, std::vector & listSinkID) const +am_Error_e CAmDatabaseHandlerMap::getListSinksOfDomain(const am_domainID_t domainID, std::vector &listSinkID) const { listSinkID.clear(); if (!existDomain(domainID)) { - logWarning(__METHOD_NAME__,"domainID must exist"); + logWarning(__METHOD_NAME__, "domainID must exist"); return (E_NON_EXISTENT); } std::unordered_map::const_iterator elementIterator = mMappedData.mSinkMap.begin(); - for (;elementIterator != mMappedData.mSinkMap.end(); ++elementIterator) - { - if (0==elementIterator->second.reserved && domainID==elementIterator->second.domainID) - listSinkID.push_back(elementIterator->second.sinkID); - } + for (; elementIterator != mMappedData.mSinkMap.end(); ++elementIterator) + { + if (0 == elementIterator->second.reserved && domainID == elementIterator->second.domainID) + { + listSinkID.push_back(elementIterator->second.sinkID); + } + } + return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListSourcesOfDomain(const am_domainID_t domainID, std::vector & listSourceID) const +am_Error_e CAmDatabaseHandlerMap::getListSourcesOfDomain(const am_domainID_t domainID, std::vector &listSourceID) const { listSourceID.clear(); if (!existDomain(domainID)) { - logWarning(__METHOD_NAME__,"domainID must exist"); + logWarning(__METHOD_NAME__, "domainID must exist"); return (E_NON_EXISTENT); } - AmMapSource::const_iterator elementIterator = mMappedData.mSourceMap.begin(); - for (;elementIterator != mMappedData.mSourceMap.end(); ++elementIterator) - { - if (0==elementIterator->second.reserved && domainID==elementIterator->second.domainID) - listSourceID.push_back(elementIterator->second.sourceID); - } + + AmMapSource::const_iterator elementIterator = mMappedData.mSourceMap.begin(); + for (; elementIterator != mMappedData.mSourceMap.end(); ++elementIterator) + { + if (0 == elementIterator->second.reserved && domainID == elementIterator->second.domainID) + { + listSourceID.push_back(elementIterator->second.sourceID); + } + } return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector & listCrossfader) const +am_Error_e CAmDatabaseHandlerMap::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector &listCrossfader) const { listCrossfader.clear(); if (!existDomain(domainID)) { - logWarning(__METHOD_NAME__,"domainID must exist"); + logWarning(__METHOD_NAME__, "domainID must exist"); return (E_NON_EXISTENT); } AmMapSource::const_iterator sourceIterator = mMappedData.mSourceMap.begin(); - for (;sourceIterator != mMappedData.mSourceMap.end(); ++sourceIterator) - { - if (domainID==sourceIterator->second.domainID) - { - AmMapCrossfader::const_iterator elementIterator = mMappedData.mCrossfaderMap.begin(); - for (;elementIterator != mMappedData.mCrossfaderMap.end(); ++elementIterator) - { - if ( sourceIterator->second.sourceID==elementIterator->second.sourceID ) - listCrossfader.push_back(elementIterator->second.crossfaderID); - } - } - } + for (; sourceIterator != mMappedData.mSourceMap.end(); ++sourceIterator) + { + if (domainID == sourceIterator->second.domainID) + { + AmMapCrossfader::const_iterator elementIterator = mMappedData.mCrossfaderMap.begin(); + for (; elementIterator != mMappedData.mCrossfaderMap.end(); ++elementIterator) + { + if ( sourceIterator->second.sourceID == elementIterator->second.sourceID ) + { + listCrossfader.push_back(elementIterator->second.crossfaderID); + } + } + } + } return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector & listGatewaysID) const +am_Error_e CAmDatabaseHandlerMap::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector &listGatewaysID) const { listGatewaysID.clear(); if (!existDomain(domainID)) { - logWarning(__METHOD_NAME__,"domainID must exist"); + logWarning(__METHOD_NAME__, "domainID must exist"); return (E_NON_EXISTENT); } AmMapGateway::const_iterator elementIterator = mMappedData.mGatewayMap.begin(); - for (;elementIterator != mMappedData.mGatewayMap.end(); ++elementIterator) - { - if (domainID==elementIterator->second.controlDomainID) - listGatewaysID.push_back(elementIterator->second.gatewayID); - } + for (; elementIterator != mMappedData.mGatewayMap.end(); ++elementIterator) + { + if (domainID == elementIterator->second.controlDomainID) + { + listGatewaysID.push_back(elementIterator->second.gatewayID); + } + } + return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListConvertersOfDomain(const am_domainID_t domainID, std::vector& listConvertersID) const +am_Error_e CAmDatabaseHandlerMap::getListConvertersOfDomain(const am_domainID_t domainID, std::vector &listConvertersID) const { listConvertersID.clear(); if (!existDomain(domainID)) { - logWarning(__METHOD_NAME__,"domainID must exist"); + logWarning(__METHOD_NAME__, "domainID must exist"); return (E_NON_EXISTENT); } AmMapConverter::const_iterator elementIterator = mMappedData.mConverterMap.begin(); - for (;elementIterator != mMappedData.mConverterMap.end(); ++elementIterator) - { - if (domainID==elementIterator->second.domainID) - listConvertersID.push_back(elementIterator->second.converterID); - } + for (; elementIterator != mMappedData.mConverterMap.end(); ++elementIterator) + { + if (domainID == elementIterator->second.domainID) + { + listConvertersID.push_back(elementIterator->second.converterID); + } + } + return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListMainConnections(std::vector & listMainConnections) const +am_Error_e CAmDatabaseHandlerMap::getListMainConnections(std::vector &listMainConnections) const { listMainConnections.clear(); AmMapMainConnection::const_iterator elementIterator = mMappedData.mMainConnectionMap.begin(); - for (;elementIterator != mMappedData.mMainConnectionMap.end(); ++elementIterator) + for (; elementIterator != mMappedData.mMainConnectionMap.end(); ++elementIterator) { - listMainConnections.push_back(elementIterator->second); + listMainConnections.push_back(elementIterator->second); } return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListDomains(std::vector & listDomains) const +am_Error_e CAmDatabaseHandlerMap::getListDomains(std::vector &listDomains) const { listDomains.clear(); AmMapDomain::const_iterator elementIterator = mMappedData.mDomainMap.begin(); - for (;elementIterator != mMappedData.mDomainMap.end(); ++elementIterator) - { - if( 0==elementIterator->second.reserved ) - listDomains.push_back(elementIterator->second); - } + for (; elementIterator != mMappedData.mDomainMap.end(); ++elementIterator) + { + if ( 0 == elementIterator->second.reserved ) + { + listDomains.push_back(elementIterator->second); + } + } return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListConnections(std::vector & listConnections) const +am_Error_e CAmDatabaseHandlerMap::getListConnections(std::vector &listConnections) const { listConnections.clear(); AmMapConnection::const_iterator elementIterator = mMappedData.mConnectionMap.begin(); - for (;elementIterator != mMappedData.mConnectionMap.end(); ++elementIterator) - { - if( 0==elementIterator->second.reserved ) - listConnections.push_back(elementIterator->second); - } + for (; elementIterator != mMappedData.mConnectionMap.end(); ++elementIterator) + { + if ( 0 == elementIterator->second.reserved ) + { + listConnections.push_back(elementIterator->second); + } + } - return (E_OK); + return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListConnectionsReserved(std::vector & listConnections) const +am_Error_e CAmDatabaseHandlerMap::getListConnectionsReserved(std::vector &listConnections) const { listConnections.clear(); AmMapConnection::const_iterator elementIterator = mMappedData.mConnectionMap.begin(); - for (;elementIterator != mMappedData.mConnectionMap.end(); ++elementIterator) - { - if( elementIterator->second.reserved ) - listConnections.push_back(elementIterator->second); - } + for (; elementIterator != mMappedData.mConnectionMap.end(); ++elementIterator) + { + if ( elementIterator->second.reserved ) + { + listConnections.push_back(elementIterator->second); + } + } - return (E_OK); + return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListSinks(std::vector & listSinks) const +am_Error_e CAmDatabaseHandlerMap::getListSinks(std::vector &listSinks) const { listSinks.clear(); - std::for_each(mMappedData.mSinkMap.begin(), mMappedData.mSinkMap.end(), [&](const std::pair& ref) { - if( 0==ref.second.reserved ) - listSinks.push_back(ref.second); - }); + std::for_each(mMappedData.mSinkMap.begin(), mMappedData.mSinkMap.end(), [&](const std::pair &ref) { + if ( 0 == ref.second.reserved ) + { + listSinks.push_back(ref.second); + } + }); return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListSources(std::vector & listSources) const +am_Error_e CAmDatabaseHandlerMap::getListSources(std::vector &listSources) const { listSources.clear(); - std::for_each(mMappedData.mSourceMap.begin(), mMappedData.mSourceMap.end(), [&](const std::pair& ref) { - if( 0==ref.second.reserved ) - { - listSources.push_back(ref.second); - } - }); + std::for_each(mMappedData.mSourceMap.begin(), mMappedData.mSourceMap.end(), [&](const std::pair &ref) { + if ( 0 == ref.second.reserved ) + { + listSources.push_back(ref.second); + } + }); return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListSourceClasses(std::vector & listSourceClasses) const +am_Error_e CAmDatabaseHandlerMap::getListSourceClasses(std::vector &listSourceClasses) const { listSourceClasses.clear(); - std::for_each(mMappedData.mSourceClassesMap.begin(), mMappedData.mSourceClassesMap.end(), [&](const std::pair& ref) { - listSourceClasses.push_back(ref.second); - }); + std::for_each(mMappedData.mSourceClassesMap.begin(), mMappedData.mSourceClassesMap.end(), [&](const std::pair &ref) { + listSourceClasses.push_back(ref.second); + }); return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListCrossfaders(std::vector & listCrossfaders) const +am_Error_e CAmDatabaseHandlerMap::getListCrossfaders(std::vector &listCrossfaders) const { listCrossfaders.clear(); - std::for_each(mMappedData.mCrossfaderMap.begin(), mMappedData.mCrossfaderMap.end(), [&](const std::pair& ref) { - listCrossfaders.push_back(ref.second); - }); + std::for_each(mMappedData.mCrossfaderMap.begin(), mMappedData.mCrossfaderMap.end(), [&](const std::pair &ref) { + listCrossfaders.push_back(ref.second); + }); return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListGateways(std::vector & listGateways) const +am_Error_e CAmDatabaseHandlerMap::getListGateways(std::vector &listGateways) const { listGateways.clear(); - std::for_each(mMappedData.mGatewayMap.begin(), mMappedData.mGatewayMap.end(), [&](const std::pair& ref) { - listGateways.push_back(ref.second); - }); + std::for_each(mMappedData.mGatewayMap.begin(), mMappedData.mGatewayMap.end(), [&](const std::pair &ref) { + listGateways.push_back(ref.second); + }); return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListConverters(std::vector & listConverters) const +am_Error_e CAmDatabaseHandlerMap::getListConverters(std::vector &listConverters) const { - listConverters.clear(); + listConverters.clear(); - std::for_each(mMappedData.mConverterMap.begin(), mMappedData.mConverterMap.end(), [&](const std::pair& ref) { - listConverters.push_back(ref.second); - }); + std::for_each(mMappedData.mConverterMap.begin(), mMappedData.mConverterMap.end(), [&](const std::pair &ref) { + listConverters.push_back(ref.second); + }); return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListSinkClasses(std::vector & listSinkClasses) const +am_Error_e CAmDatabaseHandlerMap::getListSinkClasses(std::vector &listSinkClasses) const { listSinkClasses.clear(); - std::for_each(mMappedData.mSinkClassesMap.begin(), mMappedData.mSinkClassesMap.end(), [&](const std::pair& ref) { - listSinkClasses.push_back(ref.second); - }); + std::for_each(mMappedData.mSinkClassesMap.begin(), mMappedData.mSinkClassesMap.end(), [&](const std::pair &ref) { + listSinkClasses.push_back(ref.second); + }); return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListVisibleMainConnections(std::vector & listConnections) const +am_Error_e CAmDatabaseHandlerMap::getListVisibleMainConnections(std::vector &listConnections) const { listConnections.clear(); - std::for_each(mMappedData.mMainConnectionMap.begin(), mMappedData.mMainConnectionMap.end(), [&](const std::pair& ref) { - listConnections.emplace_back(); - ref.second.getMainConnectionType(listConnections.back()); - }); + std::for_each(mMappedData.mMainConnectionMap.begin(), mMappedData.mMainConnectionMap.end(), [&](const std::pair &ref) { + listConnections.emplace_back(); + ref.second.getMainConnectionType(listConnections.back()); + }); return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListMainSinks(std::vector & listMainSinks) const +am_Error_e CAmDatabaseHandlerMap::getListMainSinks(std::vector &listMainSinks) const { listMainSinks.clear(); - std::for_each(mMappedData.mSinkMap.begin(), mMappedData.mSinkMap.end(), [&](const std::pair& ref) { - if( 0==ref.second.reserved && 1==ref.second.visible ) - { - listMainSinks.emplace_back(); - ref.second.getSinkType(listMainSinks.back()); - } - }); + std::for_each(mMappedData.mSinkMap.begin(), mMappedData.mSinkMap.end(), [&](const std::pair &ref) { + if ( 0 == ref.second.reserved && 1 == ref.second.visible ) + { + listMainSinks.emplace_back(); + ref.second.getSinkType(listMainSinks.back()); + } + }); return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListMainSources(std::vector & listMainSources) const +am_Error_e CAmDatabaseHandlerMap::getListMainSources(std::vector &listMainSources) const { listMainSources.clear(); - std::for_each(mMappedData.mSourceMap.begin(), mMappedData.mSourceMap.end(), [&](const std::pair& ref) { - if( 0==ref.second.reserved && 1==ref.second.visible ) - { - listMainSources.emplace_back(); - ref.second.getSourceType(listMainSources.back()); - } - }); + std::for_each(mMappedData.mSourceMap.begin(), mMappedData.mSourceMap.end(), [&](const std::pair &ref) { + if ( 0 == ref.second.reserved && 1 == ref.second.visible ) + { + listMainSources.emplace_back(); + ref.second.getSourceType(listMainSources.back()); + } + }); return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector & listSoundProperties) const +am_Error_e CAmDatabaseHandlerMap::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector &listSoundProperties) const { if (!existSink(sinkID)) { - logWarning(__METHOD_NAME__,"sinkID must exist"); - return E_NON_EXISTENT; + logWarning(__METHOD_NAME__, "sinkID must exist"); + return E_NON_EXISTENT; } - const am_Sink_s & sink = mMappedData.mSinkMap.at(sinkID); + const am_Sink_s &sink = mMappedData.mSinkMap.at(sinkID); listSoundProperties = sink.listMainSoundProperties; return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector & listSourceProperties) const +am_Error_e CAmDatabaseHandlerMap::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector &listSourceProperties) const { if (!existSource(sourceID)) { - logWarning(__METHOD_NAME__,"sourceID must exist"); - return E_NON_EXISTENT; + logWarning(__METHOD_NAME__, "sourceID must exist"); + return E_NON_EXISTENT; } - const am_Source_s & source = mMappedData.mSourceMap.at(sourceID); + + const am_Source_s &source = mMappedData.mSourceMap.at(sourceID); listSourceProperties = source.listMainSoundProperties; return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListSinkSoundProperties(const am_sinkID_t sinkID, std::vector& listSoundproperties) const +am_Error_e CAmDatabaseHandlerMap::getListSinkSoundProperties(const am_sinkID_t sinkID, std::vector &listSoundproperties) const { if (!existSink(sinkID)) { - logWarning(__METHOD_NAME__,"sinkID must exist"); - return E_NON_EXISTENT; + logWarning(__METHOD_NAME__, "sinkID must exist"); + return E_NON_EXISTENT; } - const am_Sink_Database_s & sink = mMappedData.mSinkMap.at(sinkID); + const am_Sink_Database_s &sink = mMappedData.mSinkMap.at(sinkID); listSoundproperties = sink.listSoundProperties; return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListSourceSoundProperties(const am_sourceID_t sourceID, std::vector& listSoundproperties) const +am_Error_e CAmDatabaseHandlerMap::getListSourceSoundProperties(const am_sourceID_t sourceID, std::vector &listSoundproperties) const { - if (!existSource(sourceID)) + if (!existSource(sourceID)) { - logWarning(__METHOD_NAME__,"sourceID must exist"); - return E_NON_EXISTENT; + logWarning(__METHOD_NAME__, "sourceID must exist"); + return E_NON_EXISTENT; } - const am_Source_Database_s & source = mMappedData.mSourceMap.at(sourceID); - listSoundproperties = source.listSoundProperties; + const am_Source_Database_s &source = mMappedData.mSourceMap.at(sourceID); + listSoundproperties = source.listSoundProperties; - return (E_OK); + return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListSystemProperties(std::vector & listSystemProperties) const +am_Error_e CAmDatabaseHandlerMap::getListSystemProperties(std::vector &listSystemProperties) const { - listSystemProperties = mMappedData.mSystemProperties; + listSystemProperties = mMappedData.mSystemProperties; return (E_OK); } -am_Error_e am::CAmDatabaseHandlerMap::getListSinkConnectionFormats(const am_sinkID_t sinkID, std::vector & listConnectionFormats) const +am_Error_e am::CAmDatabaseHandlerMap::getListSinkConnectionFormats(const am_sinkID_t sinkID, std::vector &listConnectionFormats) const { - if (!existSink(sinkID)) - { - logWarning(__METHOD_NAME__,"sinkID must exist"); - return E_NON_EXISTENT; - } - const am_Sink_s & sink = mMappedData.mSinkMap.at(sinkID); - listConnectionFormats = sink.listConnectionFormats; + if (!existSink(sinkID)) + { + logWarning(__METHOD_NAME__, "sinkID must exist"); + return E_NON_EXISTENT; + } + + const am_Sink_s &sink = mMappedData.mSinkMap.at(sinkID); + listConnectionFormats = sink.listConnectionFormats; return (E_OK); } -am_Error_e am::CAmDatabaseHandlerMap::getListSourceConnectionFormats(const am_sourceID_t sourceID, std::vector & listConnectionFormats) const +am_Error_e am::CAmDatabaseHandlerMap::getListSourceConnectionFormats(const am_sourceID_t sourceID, std::vector &listConnectionFormats) const { - if (!existSource(sourceID)) - { - logWarning(__METHOD_NAME__,"sourceID must exist"); - return E_NON_EXISTENT; - } - const am_Source_s & source = mMappedData.mSourceMap.at(sourceID); + if (!existSource(sourceID)) + { + logWarning(__METHOD_NAME__, "sourceID must exist"); + return E_NON_EXISTENT; + } + + const am_Source_s &source = mMappedData.mSourceMap.at(sourceID); listConnectionFormats = source.listConnectionFormats; return (E_OK); } -am_Error_e am::CAmDatabaseHandlerMap::getListGatewayConnectionFormats(const am_gatewayID_t gatewayID, std::vector & listConnectionFormat) const +am_Error_e am::CAmDatabaseHandlerMap::getListGatewayConnectionFormats(const am_gatewayID_t gatewayID, std::vector &listConnectionFormat) const { - if (!existGateway(gatewayID)) - { - logWarning(__METHOD_NAME__,"gatewayID must exist"); - return E_NON_EXISTENT; - } + if (!existGateway(gatewayID)) + { + logWarning(__METHOD_NAME__, "gatewayID must exist"); + return E_NON_EXISTENT; + } + ListConnectionFormat::const_iterator iter = mListConnectionFormat.begin(); iter = mListConnectionFormat.find(gatewayID); if (iter == mListConnectionFormat.end()) { - logWarning("DatabaseHandler::getListGatewayConnectionFormats database error with convertionFormat"); + logWarning("DatabaseHandler::getListGatewayConnectionFormats database error with convertionFormat"); return E_NON_EXISTENT; } + listConnectionFormat = iter->second; return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t & delay) const +am_Error_e CAmDatabaseHandlerMap::getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t &delay) const { if (!existMainConnection(mainConnectionID)) { - logWarning(__METHOD_NAME__,"mainConnectionID must exist"); - return E_NON_EXISTENT; + logWarning(__METHOD_NAME__, "mainConnectionID must exist"); + return E_NON_EXISTENT; } + delay = -1; - const am_MainConnection_s & mainConnection = mMappedData.mMainConnectionMap.at(mainConnectionID); + const am_MainConnection_s &mainConnection = mMappedData.mMainConnectionMap.at(mainConnectionID); delay = mainConnection.delay; if (delay == -1) + { return (E_NOT_POSSIBLE); + } return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::changeDelayMainConnection(const am_timeSync_t & delay, const am_mainConnectionID_t & connectionID) +am_Error_e CAmDatabaseHandlerMap::changeDelayMainConnection(const am_timeSync_t &delay, const am_mainConnectionID_t &connectionID) { if (!existMainConnection(connectionID)) { - logError(__METHOD_NAME__,"connectionID must exist"); - return E_NON_EXISTENT; + logError(__METHOD_NAME__, "connectionID must exist"); + return E_NON_EXISTENT; } + DB_COND_UPDATE_RIE(mMappedData.mMainConnectionMap[connectionID].delay, delay); NOTIFY_OBSERVERS2(dboTimingInformationChanged, connectionID, delay) return (E_OK); @@ -2260,7 +2398,7 @@ am_Error_e CAmDatabaseHandlerMap::changeDelayMainConnection(const am_timeSync_t */ bool CAmDatabaseHandlerMap::existMainConnection(const am_mainConnectionID_t mainConnectionID) const { - return existsObjectWithKeyInMap(mainConnectionID, mMappedData.mMainConnectionMap); + return existsObjectWithKeyInMap(mainConnectionID, mMappedData.mMainConnectionMap); } /** @@ -2270,11 +2408,13 @@ bool CAmDatabaseHandlerMap::existMainConnection(const am_mainConnectionID_t main */ bool CAmDatabaseHandlerMap::existSource(const am_sourceID_t sourceID) const { - am_Source_Database_s const * source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap); - if( NULL!=source ) - return (0==source->reserved); + am_Source_Database_s const *source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap); + if ( NULL != source ) + { + return (0 == source->reserved); + } - return false; + return false; } /** @@ -2283,7 +2423,7 @@ bool CAmDatabaseHandlerMap::existSource(const am_sourceID_t sourceID) const * @param name the name * @return true if it exits */ -bool CAmDatabaseHandlerMap::existSourceNameOrID(const am_sourceID_t sourceID, const std::string & name) const +bool CAmDatabaseHandlerMap::existSourceNameOrID(const am_sourceID_t sourceID, const std::string &name) const { return sourceWithNameOrID(sourceID, name); } @@ -2293,7 +2433,7 @@ bool CAmDatabaseHandlerMap::existSourceNameOrID(const am_sourceID_t sourceID, co * @param name the name * @return true if it exits */ -bool CAmDatabaseHandlerMap::existSourceName(const std::string & name) const +bool CAmDatabaseHandlerMap::existSourceName(const std::string &name) const { return existSourceNameOrID(mMappedData.mCurrentSourceID.mMax, name); } @@ -2305,17 +2445,18 @@ bool CAmDatabaseHandlerMap::existSourceName(const std::string & name) const */ bool CAmDatabaseHandlerMap::existSink(const am_sinkID_t sinkID) const { - bool returnVal = false; - AmMapSink::const_iterator elementIterator = mMappedData.mSinkMap.begin(); - for (;elementIterator != mMappedData.mSinkMap.end(); ++elementIterator) - { - if( 0==elementIterator->second.reserved && - sinkID==elementIterator->second.sinkID) - { - returnVal = true; - break; - } - } + bool returnVal = false; + AmMapSink::const_iterator elementIterator = mMappedData.mSinkMap.begin(); + for (; elementIterator != mMappedData.mSinkMap.end(); ++elementIterator) + { + if ( 0 == elementIterator->second.reserved && + sinkID == elementIterator->second.sinkID) + { + returnVal = true; + break; + } + } + return (returnVal); } @@ -2325,13 +2466,13 @@ bool CAmDatabaseHandlerMap::existSink(const am_sinkID_t sinkID) const * @param name the name * @return source structure if exists. */ -const CAmDatabaseHandlerMap::am_Source_Database_s * CAmDatabaseHandlerMap::sourceWithNameOrID(const am_sourceID_t sourceID, const std::string & name) const +const CAmDatabaseHandlerMap::am_Source_Database_s *CAmDatabaseHandlerMap::sourceWithNameOrID(const am_sourceID_t sourceID, const std::string &name) const { - std::function comparator = [&](const CAmDatabaseHandlerMap::am_Source_Database_s & source)->bool{ - return ( 0==source.reserved && - (sourceID==source.sourceID || name.compare(source.name)==0)); - }; - return objectMatchingPredicate(mMappedData.mSourceMap, comparator); + std::function comparator = [&](const CAmDatabaseHandlerMap::am_Source_Database_s &source) -> bool { + return (0 == source.reserved && + (sourceID == source.sourceID || name.compare(source.name) == 0)); + }; + return objectMatchingPredicate(mMappedData.mSourceMap, comparator); } /** @@ -2340,13 +2481,13 @@ const CAmDatabaseHandlerMap::am_Source_Database_s * CAmDatabaseHandlerMap::sour * @param name the name * @return sink structure if exists. */ -const CAmDatabaseHandlerMap::am_Sink_Database_s * CAmDatabaseHandlerMap::sinkWithNameOrID(const am_sinkID_t sinkID, const std::string & name) const +const CAmDatabaseHandlerMap::am_Sink_Database_s *CAmDatabaseHandlerMap::sinkWithNameOrID(const am_sinkID_t sinkID, const std::string &name) const { - std::function comparator = [&](const CAmDatabaseHandlerMap::am_Sink_Database_s & sink)->bool{ - return ( 0==sink.reserved && - (sinkID==sink.sinkID || name.compare(sink.name)==0)); - }; - return objectMatchingPredicate(mMappedData.mSinkMap, comparator); + std::function comparator = [&](const CAmDatabaseHandlerMap::am_Sink_Database_s &sink) -> bool { + return (0 == sink.reserved && + (sinkID == sink.sinkID || name.compare(sink.name) == 0)); + }; + return objectMatchingPredicate(mMappedData.mSinkMap, comparator); } /** @@ -2355,9 +2496,9 @@ const CAmDatabaseHandlerMap::am_Sink_Database_s * CAmDatabaseHandlerMap::sinkWit * @param name the name * @return true if it exists. */ -bool CAmDatabaseHandlerMap::existSinkNameOrID(const am_sinkID_t sinkID, const std::string & name) const +bool CAmDatabaseHandlerMap::existSinkNameOrID(const am_sinkID_t sinkID, const std::string &name) const { - return sinkWithNameOrID( sinkID, name)!=NULL; + return sinkWithNameOrID(sinkID, name) != NULL; } /** @@ -2365,7 +2506,7 @@ bool CAmDatabaseHandlerMap::existSinkNameOrID(const am_sinkID_t sinkID, const st * @param name the name * @return true if it exists */ -bool CAmDatabaseHandlerMap::existSinkName(const std::string & name) const +bool CAmDatabaseHandlerMap::existSinkName(const std::string &name) const { return existSinkNameOrID(mMappedData.mCurrentSinkID.mMax, name); } @@ -2377,11 +2518,13 @@ bool CAmDatabaseHandlerMap::existSinkName(const std::string & name) const */ bool CAmDatabaseHandlerMap::existDomain(const am_domainID_t domainID) const { - am_Domain_Database_s const * source = objectForKeyIfExistsInMap(domainID, mMappedData.mDomainMap); - if( NULL!=source ) - return (0==source->reserved); + am_Domain_Database_s const *source = objectForKeyIfExistsInMap(domainID, mMappedData.mDomainMap); + if ( NULL != source ) + { + return (0 == source->reserved); + } - return false; + return false; } /** @@ -2391,51 +2534,54 @@ bool CAmDatabaseHandlerMap::existDomain(const am_domainID_t domainID) const */ bool CAmDatabaseHandlerMap::existGateway(const am_gatewayID_t gatewayID) const { - return existsObjectWithKeyInMap(gatewayID, mMappedData.mGatewayMap); + return existsObjectWithKeyInMap(gatewayID, mMappedData.mGatewayMap); } bool CAmDatabaseHandlerMap::existConverter(const am_converterID_t converterID) const { - return existsObjectWithKeyInMap(converterID, mMappedData.mConverterMap); + return existsObjectWithKeyInMap(converterID, mMappedData.mConverterMap); } -am_Error_e CAmDatabaseHandlerMap::getDomainOfSource(const am_sourceID_t sourceID, am_domainID_t & domainID) const +am_Error_e CAmDatabaseHandlerMap::getDomainOfSource(const am_sourceID_t sourceID, am_domainID_t &domainID) const { - domainID=0; + domainID = 0; - am_Source_Database_s const * source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap); - if( NULL!=source ) + am_Source_Database_s const *source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap); + if ( NULL != source ) { - domainID = source->domainID; - return E_OK; + domainID = source->domainID; + return E_OK; } + return E_NON_EXISTENT; } -am_Error_e am::CAmDatabaseHandlerMap::getDomainOfSink(const am_sinkID_t sinkID, am_domainID_t & domainID) const +am_Error_e am::CAmDatabaseHandlerMap::getDomainOfSink(const am_sinkID_t sinkID, am_domainID_t &domainID) const { - domainID=0; + domainID = 0; + + am_Sink_Database_s const *source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap); + if ( NULL != source ) + { + domainID = source->domainID; + return E_OK; + } - am_Sink_Database_s const * source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap); - if( NULL!=source ) - { - domainID = source->domainID; - return E_OK; - } - return E_NON_EXISTENT; + return E_NON_EXISTENT; } -am_Error_e am::CAmDatabaseHandlerMap::getDomainOfCrossfader(const am_converterID_t crossfader, am_domainID_t & domainID) const +am_Error_e am::CAmDatabaseHandlerMap::getDomainOfCrossfader(const am_converterID_t crossfader, am_domainID_t &domainID) const { - domainID=0; + domainID = 0; + + am_Crossfader_Database_s const *cross = objectForKeyIfExistsInMap(crossfader, mMappedData.mCrossfaderMap); + if ( NULL != cross ) + { + getDomainOfSource(cross->sinkID_A, domainID); + return E_OK; + } - am_Crossfader_Database_s const * cross = objectForKeyIfExistsInMap(crossfader, mMappedData.mCrossfaderMap); - if( NULL!=cross ) - { - getDomainOfSource(cross->sinkID_A,domainID); - return E_OK; - } - return E_NON_EXISTENT; + return E_NON_EXISTENT; } /** @@ -2445,7 +2591,7 @@ am_Error_e am::CAmDatabaseHandlerMap::getDomainOfCrossfader(const am_converterID */ bool CAmDatabaseHandlerMap::existSinkClass(const am_sinkClass_t sinkClassID) const { - return existsObjectWithKeyInMap(sinkClassID, mMappedData.mSinkClassesMap); + return existsObjectWithKeyInMap(sinkClassID, mMappedData.mSinkClassesMap); } /** @@ -2455,27 +2601,27 @@ bool CAmDatabaseHandlerMap::existSinkClass(const am_sinkClass_t sinkClassID) con */ bool CAmDatabaseHandlerMap::existSourceClass(const am_sourceClass_t sourceClassID) const { - return existsObjectWithKeyInMap(sourceClassID, mMappedData.mSourceClassesMap); + return existsObjectWithKeyInMap(sourceClassID, mMappedData.mSourceClassesMap); } am_Error_e CAmDatabaseHandlerMap::changeConnectionTimingInformation(const am_connectionID_t connectionID, const am_timeSync_t delay) { - if(!existConnectionID(connectionID)) - { - logError(__METHOD_NAME__,"connectionID must exist"); - return (E_NON_EXISTENT); - } + if (!existConnectionID(connectionID)) + { + logError(__METHOD_NAME__, "connectionID must exist"); + return (E_NON_EXISTENT); + } mMappedData.mConnectionMap[connectionID].delay = delay; - //now we need to find all mainConnections that use the changed connection and update their timing + // now we need to find all mainConnections that use the changed connection and update their timing - //first get all route tables for all mainconnections - am_Error_e error = E_OK; - AmMapMainConnection::const_iterator iter = mMappedData.mMainConnectionMap.begin(); - for(; iter != mMappedData.mMainConnectionMap.end(); ++iter) + // first get all route tables for all mainconnections + am_Error_e error = E_OK; + AmMapMainConnection::const_iterator iter = mMappedData.mMainConnectionMap.begin(); + for (; iter != mMappedData.mMainConnectionMap.end(); ++iter) { - const am_MainConnection_s & mainConnection = iter->second; + const am_MainConnection_s &mainConnection = iter->second; if (std::find(mainConnection.listConnectionID.begin(), mainConnection.listConnectionID.end(), connectionID) != mainConnection.listConnectionID.end()) { // Got it. @@ -2488,31 +2634,36 @@ am_Error_e CAmDatabaseHandlerMap::changeConnectionTimingInformation(const am_con am_Error_e CAmDatabaseHandlerMap::changeConnectionFinal(const am_connectionID_t connectionID) { - am_Connection_Database_s const * connection = objectForKeyIfExistsInMap(connectionID, mMappedData.mConnectionMap); - if( NULL!=connection ) + am_Connection_Database_s const *connection = objectForKeyIfExistsInMap(connectionID, mMappedData.mConnectionMap); + if ( NULL != connection ) { - mMappedData.mConnectionMap.at(connectionID).reserved = false; - return E_OK; + mMappedData.mConnectionMap.at(connectionID).reserved = false; + return E_OK; + } + + logError(__METHOD_NAME__, "connectionID must exist"); + return (E_NON_EXISTENT); +} + +am_timeSync_t CAmDatabaseHandlerMap::calculateMainConnectionDelay(const am_mainConnectionID_t mainConnectionID) const +{ + if (!existMainConnection(mainConnectionID)) + { + return -1; + } + + const am_MainConnection_s &mainConnection = mMappedData.mMainConnectionMap.at(mainConnectionID); + am_timeSync_t delay = 0; + std::vector::const_iterator iter = mainConnection.listConnectionID.begin(); + for (; iter < mainConnection.listConnectionID.end(); ++iter) + { + am_Connection_Database_s const *source = objectForKeyIfExistsInMap(*iter, mMappedData.mConnectionMap); + if ( NULL != source ) + { + delay += std::max(source->delay, static_cast(0)); + } } - logError(__METHOD_NAME__,"connectionID must exist"); - return (E_NON_EXISTENT); -} -am_timeSync_t CAmDatabaseHandlerMap::calculateMainConnectionDelay(const am_mainConnectionID_t mainConnectionID) const -{ - if (!existMainConnection(mainConnectionID)) - return -1; - const am_MainConnection_s & mainConnection = mMappedData.mMainConnectionMap.at(mainConnectionID); - am_timeSync_t delay = 0; - std::vector::const_iterator iter = mainConnection.listConnectionID.begin(); - for(;iterdelay, static_cast(0)); - } - } return (delay == 0 ? -1 : std::min(delay, static_cast(SHRT_MAX))); } @@ -2530,9 +2681,10 @@ bool CAmDatabaseHandlerMap::sourceVisible(const am_sourceID_t sourceID) const { if (!existSource(sourceID)) { - logError(__METHOD_NAME__,"sourceID must exist"); - return false; + logError(__METHOD_NAME__, "sourceID must exist"); + return false; } + am_Source_Database_s source = mMappedData.mSourceMap.at(sourceID); return source.visible; } @@ -2544,13 +2696,16 @@ bool CAmDatabaseHandlerMap::sourceVisible(const am_sourceID_t sourceID) const */ bool CAmDatabaseHandlerMap::sinkVisible(const am_sinkID_t sinkID) const { - am_Sink_Database_s const * source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap); - if( NULL!=source ) - { - if(0==source->reserved) - return source->visible; - } - return false; + am_Sink_Database_s const *source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap); + if ( NULL != source ) + { + if (0 == source->reserved) + { + return source->visible; + } + } + + return false; } /** @@ -2559,15 +2714,15 @@ bool CAmDatabaseHandlerMap::sinkVisible(const am_sinkID_t sinkID) const * @param connection the connection to be checked * @return true if connections exists */ -bool CAmDatabaseHandlerMap::existConnection(const am_Connection_s & connection) const +bool CAmDatabaseHandlerMap::existConnection(const am_Connection_s &connection) const { - am_Connection_Database_s const * connectionObject = objectMatchingPredicate(mMappedData.mConnectionMap, [&](const am_Connection_Database_s & obj){ - return false==obj.reserved && - connection.sinkID == obj.sinkID && - connection.sourceID == obj.sourceID && - connection.connectionFormat == obj.connectionFormat; - }); - return ( NULL!=connectionObject ); + am_Connection_Database_s const *connectionObject = objectMatchingPredicate(mMappedData.mConnectionMap, [&](const am_Connection_Database_s &obj){ + return false == obj.reserved && + connection.sinkID == obj.sinkID && + connection.sourceID == obj.sourceID && + connection.connectionFormat == obj.connectionFormat; + }); + return (NULL != connectionObject); } /** @@ -2577,12 +2732,13 @@ bool CAmDatabaseHandlerMap::existConnection(const am_Connection_s & connection) */ bool CAmDatabaseHandlerMap::existConnectionID(const am_connectionID_t connectionID) const { - am_Connection_Database_s const * connection = objectForKeyIfExistsInMap(connectionID, mMappedData.mConnectionMap); - if( NULL!=connection ) - { - return (true); - } - return false; + am_Connection_Database_s const *connection = objectForKeyIfExistsInMap(connectionID, mMappedData.mConnectionMap); + if ( NULL != connection ) + { + return (true); + } + + return false; } /** @@ -2592,297 +2748,324 @@ bool CAmDatabaseHandlerMap::existConnectionID(const am_connectionID_t connection */ bool CAmDatabaseHandlerMap::existCrossFader(const am_crossfaderID_t crossfaderID) const { - return existsObjectWithKeyInMap(crossfaderID, mMappedData.mCrossfaderMap); + return existsObjectWithKeyInMap(crossfaderID, mMappedData.mCrossfaderMap); } -am_Error_e CAmDatabaseHandlerMap::getSoureState(const am_sourceID_t sourceID, am_SourceState_e & sourceState) const +am_Error_e CAmDatabaseHandlerMap::getSoureState(const am_sourceID_t sourceID, am_SourceState_e &sourceState) const { - am_Source_Database_s const * source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap); - if( NULL!=source ) - { - sourceState = source->sourceState; - return (E_OK); - } - else - { - sourceState = SS_UNKNNOWN; - return (E_NON_EXISTENT); - } + am_Source_Database_s const *source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap); + if ( NULL != source ) + { + sourceState = source->sourceState; + return (E_OK); + } + else + { + sourceState = SS_UNKNNOWN; + return (E_NON_EXISTENT); + } } am_Error_e CAmDatabaseHandlerMap::changeSourceState(const am_sourceID_t sourceID, const am_SourceState_e sourceState) { - if(!(sourceState>=SS_UNKNNOWN && sourceState<=SS_MAX)) - { - logError(__METHOD_NAME__,"sourceState must be valid"); - return (E_NOT_POSSIBLE); - } + if (!(sourceState >= SS_UNKNNOWN && sourceState <= SS_MAX)) + { + logError(__METHOD_NAME__, "sourceState must be valid"); + return (E_NOT_POSSIBLE); + } - if(existSource(sourceID)) + if (existSource(sourceID)) { - mMappedData.mSourceMap.at(sourceID).sourceState = sourceState; - return (E_OK); - } - logError(__METHOD_NAME__,"sourceID must exist"); - return (E_NON_EXISTENT); + mMappedData.mSourceMap.at(sourceID).sourceState = sourceState; + return (E_OK); + } + + logError(__METHOD_NAME__, "sourceID must exist"); + return (E_NON_EXISTENT); } am_Error_e CAmDatabaseHandlerMap::changeSourceInterruptState(const am_sourceID_t sourceID, const am_InterruptState_e interruptState) { - assert(sourceID!=0); - assert(interruptState>=IS_UNKNOWN && interruptState<=IS_MAX); - if(existSource(sourceID)) + assert(sourceID != 0); + assert(interruptState >= IS_UNKNOWN && interruptState <= IS_MAX); + if (existSource(sourceID)) { mMappedData.mSourceMap.at(sourceID).interruptState = interruptState; return (E_OK); } + + return (E_NON_EXISTENT); +} + +am_Error_e CAmDatabaseHandlerMap::getSinkMainVolume(const am_sinkID_t sinkID, am_mainVolume_t &mainVolume) const +{ + + am_Sink_Database_s const *source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap); + if ( NULL != source ) + { + mainVolume = source->mainVolume; + return (E_OK); + } + + mainVolume = -1; + logWarning(__METHOD_NAME__, "sinkID must be valid"); + return (E_NON_EXISTENT); +} + +am_Error_e CAmDatabaseHandlerMap::getSinkVolume(const am_sinkID_t sinkID, am_volume_t &volume) const +{ + + am_Sink_Database_s const *source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap); + if ( NULL != source ) + { + volume = source->volume; + return (E_OK); + } + + volume = -1; + logWarning(__METHOD_NAME__, "sinkID must be valid"); + return (E_NON_EXISTENT); +} + +am_Error_e CAmDatabaseHandlerMap::getSourceVolume(const am_sourceID_t sourceID, am_volume_t &volume) const +{ + am_Source_Database_s const *source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap); + if ( NULL != source ) + { + volume = source->volume; + return (E_OK); + } + + volume = -1; + logWarning(__METHOD_NAME__, "sourceID must be valid"); + return (E_NON_EXISTENT); +} + +am_Error_e CAmDatabaseHandlerMap::getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomSoundPropertyType_t propertyType, int16_t &value) const +{ + + am_Sink_Database_s *pObject = (am_Sink_Database_s *)objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap); + if ( NULL != pObject ) + { + if (pObject->listSoundProperties.size() > 0 && 0 == pObject->cacheSoundProperties.size()) + { + std::vector::const_iterator iter = pObject->listSoundProperties.begin(); + for (; iter < pObject->listSoundProperties.end(); ++iter) + { + pObject->cacheSoundProperties[iter->type] = iter->value; + } + } + + auto it = pObject->cacheSoundProperties.find(propertyType); + if (it != pObject->cacheSoundProperties.end()) + { + value = it->second; + return (E_OK); + } + } + + value = -1; + logWarning(__METHOD_NAME__, "sinkID must be valid"); + return (E_NON_EXISTENT); +} + +am_Error_e CAmDatabaseHandlerMap::getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomSoundPropertyType_t propertyType, int16_t &value) const +{ + am_Source_Database_s *pObject = (am_Source_Database_s *)objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap); + if ( NULL != pObject ) + { + if (pObject->listSoundProperties.size() > 0 && 0 == pObject->cacheSoundProperties.size()) + { + std::vector::const_iterator iter = pObject->listSoundProperties.begin(); + for (; iter < pObject->listSoundProperties.end(); ++iter) + { + pObject->cacheSoundProperties[iter->type] = iter->value; + } + } + + auto it = pObject->cacheSoundProperties.find(propertyType); + if (it != pObject->cacheSoundProperties.end()) + { + value = it->second; + return (E_OK); + } + } + + value = -1; + logWarning(__METHOD_NAME__, "sourceID must be valid"); + return (E_NON_EXISTENT); +} + +am_Error_e CAmDatabaseHandlerMap::getMainSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomMainSoundPropertyType_t propertyType, int16_t &value) const +{ + am_Sink_Database_s *pObject = (am_Sink_Database_s *)objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap); + if ( NULL != pObject ) + { + if (pObject->listMainSoundProperties.size() > 0 && 0 == pObject->cacheMainSoundProperties.size()) + { + std::vector::const_iterator iter = pObject->listMainSoundProperties.begin(); + for (; iter < pObject->listMainSoundProperties.end(); ++iter) + { + pObject->cacheMainSoundProperties[iter->type] = iter->value; + } + } + + auto it = pObject->cacheMainSoundProperties.find(propertyType); + if (it != pObject->cacheMainSoundProperties.end()) + { + value = it->second; + return (E_OK); + } + } + + value = -1; + logWarning(__METHOD_NAME__, "sinkID must be valid"); + return (E_NON_EXISTENT); +} + +am_Error_e CAmDatabaseHandlerMap::getMainSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomMainSoundPropertyType_t propertyType, int16_t &value) const +{ + + am_Source_Database_s *pObject = (am_Source_Database_s *)objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap); + if ( NULL != pObject ) + { + if (pObject->listMainSoundProperties.size() > 0 && 0 == pObject->cacheMainSoundProperties.size()) + { + std::vector::const_iterator iter = pObject->listMainSoundProperties.begin(); + for (; iter < pObject->listMainSoundProperties.end(); ++iter) + { + pObject->cacheMainSoundProperties[iter->type] = iter->value; + } + } + + auto it = pObject->cacheMainSoundProperties.find(propertyType); + if (it != pObject->cacheMainSoundProperties.end()) + { + value = it->second; + return (E_OK); + } + } + + value = -1; + logWarning(__METHOD_NAME__, "sourceID must be valid"); + return (E_NON_EXISTENT); +} + +am_Error_e CAmDatabaseHandlerMap::getDomainState(const am_domainID_t domainID, am_DomainState_e &state) const +{ + + am_Domain_Database_s const *source = objectForKeyIfExistsInMap(domainID, mMappedData.mDomainMap); + if ( NULL != source ) + { + state = source->state; + return (E_OK); + } + + state = DS_UNKNOWN; + logWarning(__METHOD_NAME__, "domainID must be valid"); return (E_NON_EXISTENT); } +am_Error_e CAmDatabaseHandlerMap::peekDomain(const std::string &name, am_domainID_t &domainID) +{ + domainID = 0; + + am_Domain_Database_s const *reservedDomain = objectMatchingPredicate(mMappedData.mDomainMap, [&](const am_Domain_Database_s &obj){ + return name.compare(obj.name) == 0; + }); -am_Error_e CAmDatabaseHandlerMap::getSinkMainVolume(const am_sinkID_t sinkID, am_mainVolume_t& mainVolume) const { - - - am_Sink_Database_s const * source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap); - if( NULL!=source ) - { - mainVolume = source->mainVolume; - return (E_OK); - } - mainVolume = -1; - logWarning(__METHOD_NAME__,"sinkID must be valid"); - return (E_NON_EXISTENT); -} - -am_Error_e CAmDatabaseHandlerMap::getSinkVolume(const am_sinkID_t sinkID, am_volume_t & volume) const -{ - - am_Sink_Database_s const * source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap); - if( NULL!=source ) - { - volume = source->volume; - return (E_OK); - } - volume = -1; - logWarning(__METHOD_NAME__,"sinkID must be valid"); - return (E_NON_EXISTENT); -} - -am_Error_e CAmDatabaseHandlerMap::getSourceVolume(const am_sourceID_t sourceID, am_volume_t & volume) const -{ - am_Source_Database_s const * source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap); - if( NULL!=source ) - { - volume = source->volume; - return (E_OK); - } - volume = -1; - logWarning(__METHOD_NAME__,"sourceID must be valid"); - return (E_NON_EXISTENT); -} - -am_Error_e CAmDatabaseHandlerMap::getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomSoundPropertyType_t propertyType, int16_t & value) const -{ - - am_Sink_Database_s * pObject = (am_Sink_Database_s *)objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap); - if( NULL!=pObject ) - { - if(pObject->listSoundProperties.size()>0 && 0==pObject->cacheSoundProperties.size()) - { - std::vector::const_iterator iter = pObject->listSoundProperties.begin(); - for(; iterlistSoundProperties.end(); ++iter) - pObject->cacheSoundProperties[iter->type] = iter->value; - } - auto it = pObject->cacheSoundProperties.find(propertyType); - if(it!=pObject->cacheSoundProperties.end()) - { - value = it->second; - return (E_OK); - } - } - value = -1; - logWarning(__METHOD_NAME__,"sinkID must be valid"); - return (E_NON_EXISTENT); -} - -am_Error_e CAmDatabaseHandlerMap::getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomSoundPropertyType_t propertyType, int16_t & value) const -{ - am_Source_Database_s * pObject = (am_Source_Database_s *)objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap); - if( NULL!=pObject ) - { - if(pObject->listSoundProperties.size()>0 && 0==pObject->cacheSoundProperties.size()) - { - std::vector::const_iterator iter = pObject->listSoundProperties.begin(); - for(; iterlistSoundProperties.end(); ++iter) - pObject->cacheSoundProperties[iter->type] = iter->value; - } - auto it = pObject->cacheSoundProperties.find(propertyType); - if(it!=pObject->cacheSoundProperties.end()) - { - value = it->second; - return (E_OK); - } - } - value = -1; - logWarning(__METHOD_NAME__,"sourceID must be valid"); - return (E_NON_EXISTENT); -} - -am_Error_e CAmDatabaseHandlerMap::getMainSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomMainSoundPropertyType_t propertyType, int16_t& value) const -{ - am_Sink_Database_s * pObject = (am_Sink_Database_s *)objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap); - if( NULL!=pObject ) - { - if(pObject->listMainSoundProperties.size()>0 && 0==pObject->cacheMainSoundProperties.size()) - { - std::vector::const_iterator iter = pObject->listMainSoundProperties.begin(); - for(; iterlistMainSoundProperties.end(); ++iter) - pObject->cacheMainSoundProperties[iter->type] = iter->value; - } - auto it = pObject->cacheMainSoundProperties.find(propertyType); - if(it!=pObject->cacheMainSoundProperties.end()) - { - value = it->second; - return (E_OK); - } - } - value = -1; - logWarning(__METHOD_NAME__,"sinkID must be valid"); - return (E_NON_EXISTENT); -} - -am_Error_e CAmDatabaseHandlerMap::getMainSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomMainSoundPropertyType_t propertyType, int16_t& value) const -{ - - am_Source_Database_s * pObject = (am_Source_Database_s *)objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap); - if( NULL!=pObject ) - { - if(pObject->listMainSoundProperties.size()>0 && 0==pObject->cacheMainSoundProperties.size()) - { - std::vector::const_iterator iter = pObject->listMainSoundProperties.begin(); - for(; iterlistMainSoundProperties.end(); ++iter) - pObject->cacheMainSoundProperties[iter->type] = iter->value; - } - auto it = pObject->cacheMainSoundProperties.find(propertyType); - if(it!=pObject->cacheMainSoundProperties.end()) - { - value = it->second; - return (E_OK); - } - } - - value = -1; - logWarning(__METHOD_NAME__,"sourceID must be valid"); - return (E_NON_EXISTENT); -} - -am_Error_e CAmDatabaseHandlerMap::getDomainState(const am_domainID_t domainID, am_DomainState_e& state) const -{ - - am_Domain_Database_s const * source = objectForKeyIfExistsInMap(domainID, mMappedData.mDomainMap); - if( NULL!=source ) - { - state = source->state; - return (E_OK); - } - state = DS_UNKNOWN; - logWarning(__METHOD_NAME__,"domainID must be valid"); - return (E_NON_EXISTENT); -} - -am_Error_e CAmDatabaseHandlerMap::peekDomain(const std::string & name, am_domainID_t & domainID) -{ - domainID=0; - - am_Domain_Database_s const *reservedDomain = objectMatchingPredicate(mMappedData.mDomainMap, [&](const am_Domain_Database_s & obj){ - return name.compare(obj.name)==0; - }); - - if( NULL != reservedDomain ) - { - domainID = reservedDomain->domainID; - return E_OK; + if ( NULL != reservedDomain ) + { + domainID = reservedDomain->domainID; + return E_OK; } else { - int16_t nextID = 0; - if( mMappedData.increaseID( nextID, mMappedData.mCurrentDomainID) ) - { - domainID = nextID; - am_Domain_Database_s domain; - domain.domainID = nextID; - domain.name = name; - domain.reserved = 1; - mMappedData.mDomainMap[nextID] = domain; - return E_OK; - } - return E_UNKNOWN; + int16_t nextID = 0; + if ( mMappedData.increaseID(nextID, mMappedData.mCurrentDomainID)) + { + domainID = nextID; + am_Domain_Database_s domain; + domain.domainID = nextID; + domain.name = name; + domain.reserved = 1; + mMappedData.mDomainMap[nextID] = domain; + return E_OK; + } + + return E_UNKNOWN; } + return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::peekSink(const std::string & name, am_sinkID_t & sinkID) +am_Error_e CAmDatabaseHandlerMap::peekSink(const std::string &name, am_sinkID_t &sinkID) { - am_Sink_Database_s const *reservedSink = objectMatchingPredicate(mMappedData.mSinkMap, [&](const am_Sink_Database_s & obj){ - return name.compare(obj.name)==0; - }); - if( NULL!=reservedSink ) + am_Sink_Database_s const *reservedSink = objectMatchingPredicate(mMappedData.mSinkMap, [&](const am_Sink_Database_s &obj){ + return name.compare(obj.name) == 0; + }); + if ( NULL != reservedSink ) { - sinkID = reservedSink->sinkID; - return E_OK; + sinkID = reservedSink->sinkID; + return E_OK; } else { - int16_t nextID = 0; - if(mMappedData.increaseID(nextID, mMappedData.mCurrentSinkID)) - { - if(mFirstStaticSink) - { - nextID = DYNAMIC_ID_BOUNDARY; - mFirstStaticSink = false; - } - sinkID = nextID; - am_Sink_Database_s object; - object.sinkID = nextID; - object.name = name; - object.reserved = 1; - mMappedData.mSinkMap[nextID] = object; - return E_OK; - } - return E_UNKNOWN; + int16_t nextID = 0; + if (mMappedData.increaseID(nextID, mMappedData.mCurrentSinkID)) + { + if (mFirstStaticSink) + { + nextID = DYNAMIC_ID_BOUNDARY; + mFirstStaticSink = false; + } + + sinkID = nextID; + am_Sink_Database_s object; + object.sinkID = nextID; + object.name = name; + object.reserved = 1; + mMappedData.mSinkMap[nextID] = object; + return E_OK; + } + + return E_UNKNOWN; } } -am_Error_e CAmDatabaseHandlerMap::peekSource(const std::string & name, am_sourceID_t & sourceID) +am_Error_e CAmDatabaseHandlerMap::peekSource(const std::string &name, am_sourceID_t &sourceID) { - am_Source_Database_s const *reservedSrc = objectMatchingPredicate(mMappedData.mSourceMap, [&](const am_Source_Database_s & obj){ - return name.compare(obj.name)==0; - }); - if( NULL!=reservedSrc ) + am_Source_Database_s const *reservedSrc = objectMatchingPredicate(mMappedData.mSourceMap, [&](const am_Source_Database_s &obj){ + return name.compare(obj.name) == 0; + }); + if ( NULL != reservedSrc ) { - sourceID = reservedSrc->sourceID; - return E_OK; + sourceID = reservedSrc->sourceID; + return E_OK; } else { - int16_t nextID = 0; - if(mMappedData.increaseID(nextID, mMappedData.mCurrentSourceID)) - { - if(mFirstStaticSource) - { -// nextID = DYNAMIC_ID_BOUNDARY; - mFirstStaticSource = false; - } - sourceID = nextID; - am_Source_Database_s object; - object.sourceID = nextID; - object.name = name; - object.reserved = 1; - mMappedData.mSourceMap[nextID] = object; - return E_OK; - } - else - return E_UNKNOWN; + int16_t nextID = 0; + if (mMappedData.increaseID(nextID, mMappedData.mCurrentSourceID)) + { + if (mFirstStaticSource) + { +// nextID = DYNAMIC_ID_BOUNDARY; + mFirstStaticSource = false; + } + + sourceID = nextID; + am_Source_Database_s object; + object.sourceID = nextID; + object.name = name; + object.reserved = 1; + mMappedData.mSourceMap[nextID] = object; + return E_OK; + } + else + { + return E_UNKNOWN; + } } } @@ -2890,7 +3073,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkVolume(const am_sinkID_t sinkID, con { if (!existSink(sinkID)) { - logError(__METHOD_NAME__,"sinkID must be valid"); + logError(__METHOD_NAME__, "sinkID must be valid"); return (E_NON_EXISTENT); } @@ -2902,60 +3085,70 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceVolume(const am_sourceID_t sourceI { if (!existSource(sourceID)) { - logError(__METHOD_NAME__,"sourceID must be valid"); + logError(__METHOD_NAME__, "sourceID must be valid"); return (E_NON_EXISTENT); } + mMappedData.mSourceMap[sourceID].volume = volume; return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::changeSourceSoundPropertyDB(const am_SoundProperty_s & soundProperty, const am_sourceID_t sourceID) +am_Error_e CAmDatabaseHandlerMap::changeSourceSoundPropertyDB(const am_SoundProperty_s &soundProperty, const am_sourceID_t sourceID) { if (!existSource(sourceID)) { - logError(__METHOD_NAME__,"sourceID must be valid"); + logError(__METHOD_NAME__, "sourceID must be valid"); return (E_NON_EXISTENT); } - am_Source_Database_s & source = mMappedData.mSourceMap[sourceID]; - std::vector::iterator iter = source.listSoundProperties.begin(); - for(; itertype ) - { - iter->value = soundProperty.value; - if(source.cacheSoundProperties.size()) - source.cacheSoundProperties[soundProperty.type] = soundProperty.value; - return (E_OK); - } - } - logError(__METHOD_NAME__,"soundproperty type must be valid source:",sourceID,"type",soundProperty.type); - return (E_NON_EXISTENT); + am_Source_Database_s &source = mMappedData.mSourceMap[sourceID]; + std::vector::iterator iter = source.listSoundProperties.begin(); + for (; iter < source.listSoundProperties.end(); ++iter) + { + if ( soundProperty.type == iter->type ) + { + iter->value = soundProperty.value; + if (source.cacheSoundProperties.size()) + { + source.cacheSoundProperties[soundProperty.type] = soundProperty.value; + } + + return (E_OK); + } + } + + logError(__METHOD_NAME__, "soundproperty type must be valid source:", sourceID, "type", soundProperty.type); + return (E_NON_EXISTENT); } -am_Error_e CAmDatabaseHandlerMap::changeSinkSoundPropertyDB(const am_SoundProperty_s & soundProperty, const am_sinkID_t sinkID) +am_Error_e CAmDatabaseHandlerMap::changeSinkSoundPropertyDB(const am_SoundProperty_s &soundProperty, const am_sinkID_t sinkID) { if (!existSink(sinkID)) { - logError(__METHOD_NAME__,"sinkID must be valid"); + logError(__METHOD_NAME__, "sinkID must be valid"); return (E_NON_EXISTENT); } - am_Sink_Database_s & sink = mMappedData.mSinkMap[sinkID]; + + am_Sink_Database_s &sink = mMappedData.mSinkMap[sinkID]; std::vector::iterator iter = sink.listSoundProperties.begin(); - for(; itertype ) - { - iter->value = soundProperty.value; - if(sink.cacheSoundProperties.size()) - sink.cacheSoundProperties[soundProperty.type] = soundProperty.value; - return (E_OK); - } - } - logError(__METHOD_NAME__,"soundproperty type must be valid sinkID:",sinkID,"type",soundProperty.type); - return (E_NON_EXISTENT); + for (; iter < sink.listSoundProperties.end(); ++iter) + { + if ( soundProperty.type == iter->type ) + { + iter->value = soundProperty.value; + if (sink.cacheSoundProperties.size()) + { + sink.cacheSoundProperties[soundProperty.type] = soundProperty.value; + } + + return (E_OK); + } + } + + logError(__METHOD_NAME__, "soundproperty type must be valid sinkID:", sinkID, "type", soundProperty.type); + return (E_NON_EXISTENT); } am_Error_e CAmDatabaseHandlerMap::changeCrossFaderHotSink(const am_crossfaderID_t crossfaderID, const am_HotSink_e hotsink) @@ -2963,7 +3156,7 @@ am_Error_e CAmDatabaseHandlerMap::changeCrossFaderHotSink(const am_crossfaderID_ if (!existCrossFader(crossfaderID)) { - logError(__METHOD_NAME__,"crossfaderID must be valid"); + logError(__METHOD_NAME__, "crossfaderID must be valid"); return (E_NON_EXISTENT); } @@ -2971,67 +3164,74 @@ am_Error_e CAmDatabaseHandlerMap::changeCrossFaderHotSink(const am_crossfaderID_ return (E_OK); } -bool CAmDatabaseHandlerMap::isComponentConnected(const am_Gateway_s & gateway) const +bool CAmDatabaseHandlerMap::isComponentConnected(const am_Gateway_s &gateway) const { - bool ret = isConnected(gateway); - return ret; + bool ret = isConnected(gateway); + return ret; } -bool CAmDatabaseHandlerMap::isComponentConnected(const am_Converter_s & converter) const +bool CAmDatabaseHandlerMap::isComponentConnected(const am_Converter_s &converter) const { - bool ret = isConnected(converter); - return ret; + bool ret = isConnected(converter); + return ret; } -am_Error_e am::CAmDatabaseHandlerMap::peekSinkClassID(const std::string & name, am_sinkClass_t & sinkClassID) +am_Error_e am::CAmDatabaseHandlerMap::peekSinkClassID(const std::string &name, am_sinkClass_t &sinkClassID) { if (name.empty()) + { return (E_NON_EXISTENT); - am_SinkClass_Database_s const *reserved = objectMatchingPredicate(mMappedData.mSinkClassesMap, [&](const am_SinkClass_Database_s & obj){ - return name.compare(obj.name)==0; - }); - if( NULL!=reserved ) - { - sinkClassID = reserved->sinkClassID; - return E_OK; - } - return (E_NON_EXISTENT); + } + + am_SinkClass_Database_s const *reserved = objectMatchingPredicate(mMappedData.mSinkClassesMap, [&](const am_SinkClass_Database_s &obj){ + return name.compare(obj.name) == 0; + }); + if ( NULL != reserved ) + { + sinkClassID = reserved->sinkClassID; + return E_OK; + } + + return (E_NON_EXISTENT); } -am_Error_e am::CAmDatabaseHandlerMap::peekSourceClassID(const std::string & name, am_sourceClass_t & sourceClassID) +am_Error_e am::CAmDatabaseHandlerMap::peekSourceClassID(const std::string &name, am_sourceClass_t &sourceClassID) { if (name.empty()) + { return (E_NON_EXISTENT); - am_SourceClass_Database_s const *ptrSource = objectMatchingPredicate(mMappedData.mSourceClassesMap, [&](const am_SourceClass_Database_s & obj){ - return name.compare(obj.name)==0; - }); - if( NULL!=ptrSource ) - { - sourceClassID = ptrSource->sourceClassID; - return E_OK; - } - return (E_NON_EXISTENT); -} + } + + am_SourceClass_Database_s const *ptrSource = objectMatchingPredicate(mMappedData.mSourceClassesMap, [&](const am_SourceClass_Database_s &obj){ + return name.compare(obj.name) == 0; + }); + if ( NULL != ptrSource ) + { + sourceClassID = ptrSource->sourceClassID; + return E_OK; + } + return (E_NON_EXISTENT); +} -am_Error_e CAmDatabaseHandlerMap::changeSourceDB(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector& listSoundProperties, const std::vector& listConnectionFormats, const std::vector& listMainSoundProperties) +am_Error_e CAmDatabaseHandlerMap::changeSourceDB(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector &listSoundProperties, const std::vector &listConnectionFormats, const std::vector &listMainSoundProperties) { if (!existSource(sourceID)) { - logError(__METHOD_NAME__,"sourceID must be valid"); + logError(__METHOD_NAME__, "sourceID must be valid"); return (E_NON_EXISTENT); } DB_COND_UPDATE_INIT; - am_sourceClass_t sourceClassOut(sourceClassID); + am_sourceClass_t sourceClassOut(sourceClassID); std::vector listMainSoundPropertiesOut(listMainSoundProperties); - //check if sinkClass needs to be changed + // check if sinkClass needs to be changed std::unordered_map::iterator iter = mMappedData.mSourceMap.begin(); - for(; iter!=mMappedData.mSourceMap.end(); ++iter) + for (; iter != mMappedData.mSourceMap.end(); ++iter) { - if( iter->second.sourceID == sourceID ) + if ( iter->second.sourceID == sourceID ) { if (sourceClassID != 0) { @@ -3041,24 +3241,25 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceDB(const am_sourceID_t sourceID, c { sourceClassOut = iter->second.sourceClassID; } + break; } } - //check if soundProperties need to be updated + // check if soundProperties need to be updated if (!listSoundProperties.empty()) { mMappedData.mSourceMap.at(sourceID).listSoundProperties = listSoundProperties; mMappedData.mSourceMap.at(sourceID).cacheSoundProperties.clear(); } - //check if we have to update the list of connectionformats + // check if we have to update the list of connectionformats if (!listConnectionFormats.empty()) { mMappedData.mSourceMap.at(sourceID).listConnectionFormats = listConnectionFormats; } - //then we need to check if we need to update the listMainSoundProperties + // then we need to check if we need to update the listMainSoundProperties if (sourceVisible(sourceID)) { if (!listMainSoundProperties.empty()) @@ -3068,7 +3269,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceDB(const am_sourceID_t sourceID, c } else { - getListMainSourceSoundProperties(sourceID,listMainSoundPropertiesOut); + getListMainSourceSoundProperties(sourceID, listMainSoundPropertiesOut); } } @@ -3076,7 +3277,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceDB(const am_sourceID_t sourceID, c { logVerbose("DatabaseHandler::changeSource changed changeSource of source:", sourceID); - NOTIFY_OBSERVERS4(dboSourceUpdated, sourceID,sourceClassOut,listMainSoundPropertiesOut,sourceVisible(sourceID)) + NOTIFY_OBSERVERS4(dboSourceUpdated, sourceID, sourceClassOut, listMainSoundPropertiesOut, sourceVisible(sourceID)) } @@ -3084,21 +3285,21 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceDB(const am_sourceID_t sourceID, c } -am_Error_e CAmDatabaseHandlerMap::changeSinkDB(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector& listSoundProperties, const std::vector& listConnectionFormats, const std::vector& listMainSoundProperties) +am_Error_e CAmDatabaseHandlerMap::changeSinkDB(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector &listSoundProperties, const std::vector &listConnectionFormats, const std::vector &listMainSoundProperties) { DB_COND_UPDATE_INIT; - am_sinkClass_t sinkClassOut(sinkClassID); + am_sinkClass_t sinkClassOut(sinkClassID); std::vector listMainSoundPropertiesOut(listMainSoundProperties); if (!existSink(sinkID)) { - logError(__METHOD_NAME__,"sinkID must be valid"); + logError(__METHOD_NAME__, "sinkID must be valid"); return (E_NON_EXISTENT); } std::unordered_map::iterator iter = mMappedData.mSinkMap.begin(); - for(; iter!=mMappedData.mSinkMap.end(); ++iter) + for (; iter != mMappedData.mSinkMap.end(); ++iter) { if (iter->second.sinkID == sinkID) { @@ -3110,24 +3311,25 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkDB(const am_sinkID_t sinkID, const a { sinkClassOut = iter->second.sinkClassID; } + break; } } - //check if soundProperties need to be updated + // check if soundProperties need to be updated if (!listSoundProperties.empty()) { mMappedData.mSinkMap.at(sinkID).listSoundProperties = listSoundProperties; mMappedData.mSinkMap.at(sinkID).cacheSoundProperties.clear(); } - //check if we have to update the list of connectionformats + // check if we have to update the list of connectionformats if (!listConnectionFormats.empty()) { mMappedData.mSinkMap.at(sinkID).listConnectionFormats = listConnectionFormats; } - //then we need to check if we need to update the listMainSoundProperties + // then we need to check if we need to update the listMainSoundProperties if (sinkVisible(sinkID)) { if (!listMainSoundProperties.empty()) @@ -3135,9 +3337,9 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkDB(const am_sinkID_t sinkID, const a DB_COND_UPDATE(mMappedData.mSinkMap.at(sinkID).listMainSoundProperties, listMainSoundProperties); mMappedData.mSinkMap.at(sinkID).cacheMainSoundProperties.clear(); } - else //read out the properties + else // read out the properties { - getListMainSinkSoundProperties(sinkID,listMainSoundPropertiesOut); + getListMainSinkSoundProperties(sinkID, listMainSoundPropertiesOut); } } @@ -3145,33 +3347,34 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkDB(const am_sinkID_t sinkID, const a { logVerbose("DatabaseHandler::changeSink changed changeSink of sink:", sinkID); - NOTIFY_OBSERVERS4(dboSinkUpdated, sinkID,sinkClassOut,listMainSoundPropertiesOut,sinkVisible(sinkID)) + NOTIFY_OBSERVERS4(dboSinkUpdated, sinkID, sinkClassOut, listMainSoundPropertiesOut, sinkVisible(sinkID)) } return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListMainSinkNotificationConfigurations(const am_sinkID_t sinkID, std::vector& listMainNotificationConfigurations) +am_Error_e CAmDatabaseHandlerMap::getListMainSinkNotificationConfigurations(const am_sinkID_t sinkID, std::vector &listMainNotificationConfigurations) { if (!existSink(sinkID)) { - logWarning(__METHOD_NAME__,"sinkID must be valid"); + logWarning(__METHOD_NAME__, "sinkID must be valid"); return (E_DATABASE_ERROR); } + listMainNotificationConfigurations.clear(); listMainNotificationConfigurations = mMappedData.mSinkMap.at(sinkID).listMainNotificationConfigurations; - return (E_OK); + return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::getListMainSourceNotificationConfigurations(const am_sourceID_t sourceID, std::vector& listMainNotificationConfigurations) +am_Error_e CAmDatabaseHandlerMap::getListMainSourceNotificationConfigurations(const am_sourceID_t sourceID, std::vector &listMainNotificationConfigurations) { if (!existSource(sourceID)) { - logWarning(__METHOD_NAME__,"sourceID must be valid"); + logWarning(__METHOD_NAME__, "sourceID must be valid"); return (E_DATABASE_ERROR); } @@ -3180,22 +3383,25 @@ am_Error_e CAmDatabaseHandlerMap::getListMainSourceNotificationConfigurations(co return (E_OK); } -bool changeMainNotificationConfiguration(std::vector & listMainNotificationConfigurations, - const am_NotificationConfiguration_s & mainNotificationConfiguration) +bool changeMainNotificationConfiguration(std::vector &listMainNotificationConfigurations, + const am_NotificationConfiguration_s &mainNotificationConfiguration) { std::vector::iterator iter = listMainNotificationConfigurations.begin(); - for(; itertype ) + if ( mainNotificationConfiguration.type == iter->type ) { #ifdef WITH_DATABASE_CHANGE_CHECK - if( iter->status == mainNotificationConfiguration.status && iter->parameter == mainNotificationConfiguration.parameter ) + if ( iter->status == mainNotificationConfiguration.status && iter->parameter == mainNotificationConfiguration.parameter ) + { return false; + } #endif *iter = mainNotificationConfiguration; return true; } } + return false; } @@ -3204,13 +3410,16 @@ am_Error_e CAmDatabaseHandlerMap::changeMainSinkNotificationConfigurationDB(cons if (!existSink(sinkID)) { - logError(__METHOD_NAME__,"sinkID must be valid"); + logError(__METHOD_NAME__, "sinkID must be valid"); return (E_NON_EXISTENT); } - if(!changeMainNotificationConfiguration(mMappedData.mSinkMap.at(sinkID).listMainNotificationConfigurations, mainNotificationConfiguration)) - return (E_NO_CHANGE); - logVerbose("DatabaseHandler::changeMainSinkNotificationConfigurationDB changed MainNotificationConfiguration of source:", sinkID, "type:", mainNotificationConfiguration.type, "to status=", mainNotificationConfiguration.status, "and parameter=",mainNotificationConfiguration.parameter); + if (!changeMainNotificationConfiguration(mMappedData.mSinkMap.at(sinkID).listMainNotificationConfigurations, mainNotificationConfiguration)) + { + return (E_NO_CHANGE); + } + + logVerbose("DatabaseHandler::changeMainSinkNotificationConfigurationDB changed MainNotificationConfiguration of source:", sinkID, "type:", mainNotificationConfiguration.type, "to status=", mainNotificationConfiguration.status, "and parameter=", mainNotificationConfiguration.parameter); NOTIFY_OBSERVERS2(dboSinkMainNotificationConfigurationChanged, sinkID, mainNotificationConfiguration) @@ -3222,96 +3431,99 @@ am_Error_e CAmDatabaseHandlerMap::changeMainSourceNotificationConfigurationDB(co if (!existSource(sourceID)) { - logError(__METHOD_NAME__,"sourceID must be valid"); + logError(__METHOD_NAME__, "sourceID must be valid"); return (E_NON_EXISTENT); } - if(!changeMainNotificationConfiguration(mMappedData.mSourceMap.at(sourceID).listMainNotificationConfigurations, mainNotificationConfiguration)) - return (E_NO_CHANGE); + if (!changeMainNotificationConfiguration(mMappedData.mSourceMap.at(sourceID).listMainNotificationConfigurations, mainNotificationConfiguration)) + { + return (E_NO_CHANGE); + } - logVerbose("DatabaseHandler::changeMainSourceNotificationConfigurationDB changed MainNotificationConfiguration of source:", sourceID, "type:", mainNotificationConfiguration.type, "to status=", mainNotificationConfiguration.status, "and parameter=",mainNotificationConfiguration.parameter); + logVerbose("DatabaseHandler::changeMainSourceNotificationConfigurationDB changed MainNotificationConfiguration of source:", sourceID, "type:", mainNotificationConfiguration.type, "to status=", mainNotificationConfiguration.status, "and parameter=", mainNotificationConfiguration.parameter); NOTIFY_OBSERVERS2(dboSourceMainNotificationConfigurationChanged, sourceID, mainNotificationConfiguration) return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::changeGatewayDB(const am_gatewayID_t gatewayID, const std::vector& listSourceConnectionFormats, const std::vector& listSinkConnectionFormats, const std::vector& convertionMatrix) +am_Error_e CAmDatabaseHandlerMap::changeGatewayDB(const am_gatewayID_t gatewayID, const std::vector &listSourceConnectionFormats, const std::vector &listSinkConnectionFormats, const std::vector &convertionMatrix) { - if (!existGateway(gatewayID)) - { - logError(__METHOD_NAME__,"gatewayID must be valid"); - return (E_NON_EXISTENT); - } + if (!existGateway(gatewayID)) + { + logError(__METHOD_NAME__, "gatewayID must be valid"); + return (E_NON_EXISTENT); + } - if (!listSourceConnectionFormats.empty()) - { - mMappedData.mGatewayMap.at(gatewayID).listSourceFormats = listSourceConnectionFormats; - } + if (!listSourceConnectionFormats.empty()) + { + mMappedData.mGatewayMap.at(gatewayID).listSourceFormats = listSourceConnectionFormats; + } - if (!listSinkConnectionFormats.empty()) - { - mMappedData.mGatewayMap.at(gatewayID).listSinkFormats = listSinkConnectionFormats; - } + if (!listSinkConnectionFormats.empty()) + { + mMappedData.mGatewayMap.at(gatewayID).listSinkFormats = listSinkConnectionFormats; + } - if (!convertionMatrix.empty()) - { - mListConnectionFormat.clear(); - mListConnectionFormat.insert(std::make_pair(gatewayID, convertionMatrix)); - } + if (!convertionMatrix.empty()) + { + mListConnectionFormat.clear(); + mListConnectionFormat.insert(std::make_pair(gatewayID, convertionMatrix)); + } - logVerbose("DatabaseHandler::changeGatewayDB changed Gateway with ID", gatewayID); + logVerbose("DatabaseHandler::changeGatewayDB changed Gateway with ID", gatewayID); - //todo: check if observer needs to be adopted. - return (E_OK); + // todo: check if observer needs to be adopted. + return (E_OK); } -am_Error_e CAmDatabaseHandlerMap::changeConverterDB(const am_converterID_t converterID, const std::vector& listSourceConnectionFormats, const std::vector& listSinkConnectionFormats, const std::vector& convertionMatrix) +am_Error_e CAmDatabaseHandlerMap::changeConverterDB(const am_converterID_t converterID, const std::vector &listSourceConnectionFormats, const std::vector &listSinkConnectionFormats, const std::vector &convertionMatrix) { - if (!existConverter(converterID)) - { - logError(__METHOD_NAME__,"converterID must be valid"); - return (E_NON_EXISTENT); - } + if (!existConverter(converterID)) + { + logError(__METHOD_NAME__, "converterID must be valid"); + return (E_NON_EXISTENT); + } - if (!listSourceConnectionFormats.empty()) - { - mMappedData.mConverterMap.at(converterID).listSourceFormats = listSourceConnectionFormats; - } + if (!listSourceConnectionFormats.empty()) + { + mMappedData.mConverterMap.at(converterID).listSourceFormats = listSourceConnectionFormats; + } - if (!listSinkConnectionFormats.empty()) - { - mMappedData.mConverterMap.at(converterID).listSinkFormats = listSinkConnectionFormats; - } + if (!listSinkConnectionFormats.empty()) + { + mMappedData.mConverterMap.at(converterID).listSinkFormats = listSinkConnectionFormats; + } - if (!convertionMatrix.empty()) - { - mListConnectionFormat.clear(); - mListConnectionFormat.insert(std::make_pair(converterID, convertionMatrix)); - } + if (!convertionMatrix.empty()) + { + mListConnectionFormat.clear(); + mListConnectionFormat.insert(std::make_pair(converterID, convertionMatrix)); + } - logVerbose("DatabaseHandler::changeConverterDB changed Gateway with ID", converterID); + logVerbose("DatabaseHandler::changeConverterDB changed Gateway with ID", converterID); - //todo: check if observer needs to be adopted. - return (E_OK); + // todo: check if observer needs to be adopted. + return (E_OK); } -bool changeNotificationConfiguration(std::vector & listNotificationConfigurations, const am_NotificationConfiguration_s & notificationConfiguration) +bool changeNotificationConfiguration(std::vector &listNotificationConfigurations, const am_NotificationConfiguration_s ¬ificationConfiguration) { - bool changed = false; - std::vector::iterator iter = listNotificationConfigurations.begin(); - for(; itertype ) - { - iter->status = notificationConfiguration.status; - iter->parameter = notificationConfiguration.parameter; - changed |= true; - } - } - return changed; + bool changed = false; + std::vector::iterator iter = listNotificationConfigurations.begin(); + for (; iter < listNotificationConfigurations.end(); ++iter) + { + if ( notificationConfiguration.type == iter->type ) + { + iter->status = notificationConfiguration.status; + iter->parameter = notificationConfiguration.parameter; + changed |= true; + } + } + + return changed; } am_Error_e CAmDatabaseHandlerMap::changeSinkNotificationConfigurationDB(const am_sinkID_t sinkID, const am_NotificationConfiguration_s notificationConfiguration) @@ -3319,15 +3531,18 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkNotificationConfigurationDB(const am if (!existSink(sinkID)) { - logError(__METHOD_NAME__,"sinkID must be valid"); + logError(__METHOD_NAME__, "sinkID must be valid"); return (E_NON_EXISTENT); } - if(!changeNotificationConfiguration(mMappedData.mSinkMap.at(sinkID).listNotificationConfigurations, notificationConfiguration)) - return (E_NO_CHANGE); - logVerbose("DatabaseHandler::changeMainSinkNotificationConfigurationDB changed MainNotificationConfiguration of source:", sinkID, "type:", notificationConfiguration.type, "to status=", notificationConfiguration.status, "and parameter=",notificationConfiguration.parameter); + if (!changeNotificationConfiguration(mMappedData.mSinkMap.at(sinkID).listNotificationConfigurations, notificationConfiguration)) + { + return (E_NO_CHANGE); + } + + logVerbose("DatabaseHandler::changeMainSinkNotificationConfigurationDB changed MainNotificationConfiguration of source:", sinkID, "type:", notificationConfiguration.type, "to status=", notificationConfiguration.status, "and parameter=", notificationConfiguration.parameter); - //todo:: inform obsever here... + // todo:: inform obsever here... return (E_NON_EXISTENT); } @@ -3336,84 +3551,101 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceNotificationConfigurationDB(const if (!existSource(sourceID)) { - logError(__METHOD_NAME__,"sourceID must be valid"); + logError(__METHOD_NAME__, "sourceID must be valid"); return (E_NON_EXISTENT); } - if(!changeNotificationConfiguration(mMappedData.mSourceMap.at(sourceID).listNotificationConfigurations, notificationConfiguration)) - return (E_NO_CHANGE); + if (!changeNotificationConfiguration(mMappedData.mSourceMap.at(sourceID).listNotificationConfigurations, notificationConfiguration)) + { + return (E_NO_CHANGE); + } - logVerbose("DatabaseHandler::changeSourceNotificationConfigurationDB changed MainNotificationConfiguration of source:", sourceID, "type:", notificationConfiguration.type, "to status=", notificationConfiguration.status, "and parameter=",notificationConfiguration.parameter); + logVerbose("DatabaseHandler::changeSourceNotificationConfigurationDB changed MainNotificationConfiguration of source:", sourceID, "type:", notificationConfiguration.type, "to status=", notificationConfiguration.status, "and parameter=", notificationConfiguration.parameter); - //todo:: implement observer function + // todo:: implement observer function return (E_NON_EXISTENT); } -am_Error_e CAmDatabaseHandlerMap::enumerateSources(std::function cb) const +am_Error_e CAmDatabaseHandlerMap::enumerateSources(std::function cb) const { - for(auto it = mMappedData.mSourceMap.begin(); it!=mMappedData.mSourceMap.end(); it++) - { - const am_Source_Database_s *pObject = &it->second; - if( 0==pObject->reserved ) - cb(*pObject); - } - return E_OK; + for (auto it = mMappedData.mSourceMap.begin(); it != mMappedData.mSourceMap.end(); it++) + { + const am_Source_Database_s *pObject = &it->second; + if ( 0 == pObject->reserved ) + { + cb(*pObject); + } + } + + return E_OK; +} + +am_Error_e CAmDatabaseHandlerMap::enumerateSinks(std::function cb) const +{ + for (auto it = mMappedData.mSinkMap.begin(); it != mMappedData.mSinkMap.end(); it++) + { + const am_Sink_Database_s *pObject = &it->second; + if ( 0 == pObject->reserved ) + { + cb(*pObject); + } + } + + return E_OK; +} + +am_Error_e CAmDatabaseHandlerMap::enumerateGateways(std::function cb) const +{ + for (auto it = mMappedData.mGatewayMap.begin(); it != mMappedData.mGatewayMap.end(); it++) + { + const am_Gateway_s *pObject = &it->second; + cb(*pObject); + } + + return E_OK; } -am_Error_e CAmDatabaseHandlerMap::enumerateSinks(std::function cb) const +am_Error_e CAmDatabaseHandlerMap::enumerateConverters(std::function cb) const { - for(auto it = mMappedData.mSinkMap.begin(); it!=mMappedData.mSinkMap.end(); it++) - { - const am_Sink_Database_s *pObject = &it->second; - if( 0==pObject->reserved ) - cb(*pObject); - } - return E_OK; + for (auto it = mMappedData.mConverterMap.begin(); it != mMappedData.mConverterMap.end(); it++) + { + const am_Converter_s *pObject = &it->second; + cb(*pObject); + } + + return E_OK; } -am_Error_e CAmDatabaseHandlerMap::enumerateGateways(std::function cb) const +bool CAmDatabaseHandlerMap::registerObserver(IAmDatabaseObserver *iObserver) { - for(auto it = mMappedData.mGatewayMap.begin(); it!=mMappedData.mGatewayMap.end(); it++) - { - const am_Gateway_s *pObject = &it->second; - cb(*pObject); - } - return E_OK; + assert(iObserver != NULL); + if (std::find(mDatabaseObservers.begin(), mDatabaseObservers.end(), iObserver) == mDatabaseObservers.end()) + { + mDatabaseObservers.push_back(static_cast(iObserver)); + static_cast(iObserver)->mpDatabaseHandler = this; + return true; + } + + return false; } -am_Error_e CAmDatabaseHandlerMap::enumerateConverters(std::function cb) const +bool CAmDatabaseHandlerMap::unregisterObserver(IAmDatabaseObserver *iObserver) { - for(auto it = mMappedData.mConverterMap.begin(); it!=mMappedData.mConverterMap.end(); it++) - { - const am_Converter_s *pObject = &it->second; - cb(*pObject); - } - return E_OK; + assert(iObserver != NULL); + auto it = std::find(mDatabaseObservers.begin(), mDatabaseObservers.end(), iObserver); + if (it != mDatabaseObservers.end()) + { + mDatabaseObservers.erase(it); + static_cast(iObserver)->mpDatabaseHandler = nullptr; + return true; + } + + return false; } -bool CAmDatabaseHandlerMap::registerObserver(IAmDatabaseObserver * iObserver) { - assert(iObserver!=NULL); - if (std::find(mDatabaseObservers.begin(), mDatabaseObservers.end(), iObserver) == mDatabaseObservers.end()) - { - mDatabaseObservers.push_back(static_cast(iObserver)); - static_cast(iObserver)->mpDatabaseHandler = this; - return true; - } - return false; -} -bool CAmDatabaseHandlerMap::unregisterObserver(IAmDatabaseObserver * iObserver) { - assert(iObserver!=NULL); - auto it = std::find(mDatabaseObservers.begin(), mDatabaseObservers.end(), iObserver); - if (it != mDatabaseObservers.end()) { - mDatabaseObservers.erase(it); - static_cast(iObserver)->mpDatabaseHandler = nullptr; - return true; - } - return false; -} - -unsigned CAmDatabaseHandlerMap::countObservers() { - return mDatabaseObservers.size(); +unsigned CAmDatabaseHandlerMap::countObservers() +{ + return mDatabaseObservers.size(); } } diff --git a/AudioManagerCore/src/CAmLog.cpp b/AudioManagerCore/src/CAmLog.cpp index 5e58f27..6562eed 100644 --- a/AudioManagerCore/src/CAmLog.cpp +++ b/AudioManagerCore/src/CAmLog.cpp @@ -23,79 +23,84 @@ #include "CAmLog.h" - void CAmLog::CAmFileLogger::generateLogFilename(std::string &result) { - static uint32_t logFileID = 1; - time_t rawtime; - time (&rawtime); + static uint32_t logFileID = 1; + time_t rawtime; + time(&rawtime); - std::ostringstream stream; - stream << DEFAULT_LOG_FOLDER << DEFAULT_LOGFILE_PREFIX << logFileID << "_" << rawtime << DEFAULT_LOGFILE_EXT; - logFileID++; - result = stream.str(); + std::ostringstream stream; + stream << DEFAULT_LOG_FOLDER << DEFAULT_LOGFILE_PREFIX << logFileID << "_" << rawtime << DEFAULT_LOGFILE_EXT; + logFileID++; + result = stream.str(); } CAmLog::CAmFileLogger::~CAmFileLogger() { - if (mOutputStream) - { - std::ofstream* of = static_cast(mOutputStream); - of->close(); - DEL(mOutputStream); - } + if (mOutputStream) + { + std::ofstream *of = static_cast(mOutputStream); + of->close(); + DEL(mOutputStream); + } } -CAmLog::CAmLog(const eCAmLogType type ):mLogType(type) +CAmLog::CAmLog(const eCAmLogType type) + : mLogType(type) { - instantiateLogger(type); + instantiateLogger(type); } -CAmLog::CAmLog():mLogType(eCAmLogStdout) +CAmLog::CAmLog() + : mLogType(eCAmLogStdout) { - instantiateLogger((const eCAmLogType)eCAmLogStdout); + instantiateLogger((const eCAmLogType)eCAmLogStdout); } CAmLog::~CAmLog() { - releaseLogger(); + releaseLogger(); } void CAmLog::releaseLogger() { - if(mLogger) - DEL(mLogger); + if (mLogger) + { + DEL(mLogger); + } } -void CAmLog::instantiateLogger( const eCAmLogType type) +void CAmLog::instantiateLogger(const eCAmLogType type) { - if( eCAmLogStdout == type ) - mLogger = new CAmStdOutLogger(); - else if( eCAmLogFile == type ) - { - std::string filename(""); - CAmLog::CAmFileLogger::generateLogFilename(filename); - mLogger = new CAmFileLogger(filename); - } + if ( eCAmLogStdout == type ) + { + mLogger = new CAmStdOutLogger(); + } + else if ( eCAmLogFile == type ) + { + std::string filename(""); + CAmLog::CAmFileLogger::generateLogFilename(filename); + mLogger = new CAmFileLogger(filename); + } } CAmLog *CAmLog::getDefaultLog() { - static CAmLog theInstance; - return &theInstance; + static CAmLog theInstance; + return &theInstance; } -void CAmLog::setLogType( const eCAmLogType type) +void CAmLog::setLogType(const eCAmLogType type) { - if(mLogType!=type) - { - mLogType = type; - releaseLogger(); - instantiateLogger(type); - } + if (mLogType != type) + { + mLogType = type; + releaseLogger(); + instantiateLogger(type); + } } eCAmLogType CAmLog::getLogType() const { - return mLogType; + return mLogType; } diff --git a/AudioManagerCore/src/CAmRouter.cpp b/AudioManagerCore/src/CAmRouter.cpp index 3c9bee4..042916d 100644 --- a/AudioManagerCore/src/CAmRouter.cpp +++ b/AudioManagerCore/src/CAmRouter.cpp @@ -34,964 +34,1047 @@ namespace am { - template void getMergeConnectionFormats(const X * element, const am_CustomConnectionFormat_t connectionFormat, - const std::vector & listConnectionFormats, std::vector & outListMergeConnectionFormats) - { - std::vector listRestrictedConnectionFormats; - CAmRouter::getRestrictedOutputFormats(element->convertionMatrix, element->listSourceFormats, element->listSinkFormats, connectionFormat, - listRestrictedConnectionFormats); - std::sort(listRestrictedConnectionFormats.begin(), listRestrictedConnectionFormats.end()); //todo: this might be not needed if we use strictly sorted input - std::insert_iterator > inserter(outListMergeConnectionFormats, outListMergeConnectionFormats.begin()); - set_intersection(listConnectionFormats.begin(), listConnectionFormats.end(), listRestrictedConnectionFormats.begin(), - listRestrictedConnectionFormats.end(), inserter); - } - - CAmRouter::CAmRouter(IAmDatabaseHandler* iDatabaseHandler, CAmControlSender* iSender) : - CAmDatabaseHandlerMap::AmDatabaseObserverCallbacks(), - mpDatabaseHandler(iDatabaseHandler), - mpControlSender(iSender), - mUpdateGraphNodesAction(true), - mMaxAllowedCycles(MAX_ALLOWED_DOMAIN_CYCLES), - mMaxPathCount(MAX_ROUTING_PATHS), - mRoutingGraph(), - mNodeListSources(), - mNodeListSinks(), - mNodeListGateways(), - mNodeListConverters() - { - assert(mpDatabaseHandler); - assert(mpControlSender); - - dboNewSink = [&](const am_Sink_s& sink) - { +template +void getMergeConnectionFormats(const X *element, const am_CustomConnectionFormat_t connectionFormat, + const std::vector &listConnectionFormats, std::vector &outListMergeConnectionFormats) +{ + std::vector listRestrictedConnectionFormats; + CAmRouter::getRestrictedOutputFormats(element->convertionMatrix, element->listSourceFormats, element->listSinkFormats, connectionFormat, + listRestrictedConnectionFormats); + std::sort(listRestrictedConnectionFormats.begin(), listRestrictedConnectionFormats.end()); // todo: this might be not needed if we use strictly sorted input + std::insert_iterator > inserter(outListMergeConnectionFormats, outListMergeConnectionFormats.begin()); + set_intersection(listConnectionFormats.begin(), listConnectionFormats.end(), listRestrictedConnectionFormats.begin(), + listRestrictedConnectionFormats.end(), inserter); +} + +CAmRouter::CAmRouter(IAmDatabaseHandler *iDatabaseHandler, CAmControlSender *iSender) + : CAmDatabaseHandlerMap::AmDatabaseObserverCallbacks() + , mpDatabaseHandler(iDatabaseHandler) + , mpControlSender(iSender) + , mUpdateGraphNodesAction(true) + , mMaxAllowedCycles(MAX_ALLOWED_DOMAIN_CYCLES) + , mMaxPathCount(MAX_ROUTING_PATHS) + , mRoutingGraph() + , mNodeListSources() + , mNodeListSinks() + , mNodeListGateways() + , mNodeListConverters() +{ + assert(mpDatabaseHandler); + assert(mpControlSender); + + dboNewSink = [&](const am_Sink_s &sink){ mUpdateGraphNodesAction = true; }; - dboNewSource = [&](const am_Source_s& source) - { - mUpdateGraphNodesAction=true; + dboNewSource = [&](const am_Source_s &source){ + mUpdateGraphNodesAction = true; }; - dboNewGateway = [&](const am_Gateway_s& gateway) - { - mUpdateGraphNodesAction=true; + dboNewGateway = [&](const am_Gateway_s &gateway){ + mUpdateGraphNodesAction = true; }; - dboNewConverter = [&](const am_Converter_s& coverter) - { - mUpdateGraphNodesAction=true; + dboNewConverter = [&](const am_Converter_s &coverter){ + mUpdateGraphNodesAction = true; }; - dboRemovedSink = [&](const am_sinkID_t sinkID, const bool visible) - { - mUpdateGraphNodesAction=true; + dboRemovedSink = [&](const am_sinkID_t sinkID, const bool visible){ + mUpdateGraphNodesAction = true; }; - dboRemovedSource = [&](const am_sourceID_t sourceID, const bool visible) - { - mUpdateGraphNodesAction=true; + dboRemovedSource = [&](const am_sourceID_t sourceID, const bool visible){ + mUpdateGraphNodesAction = true; }; - dboRemoveGateway = [&](const am_gatewayID_t gatewayID) - { - mUpdateGraphNodesAction=true; + dboRemoveGateway = [&](const am_gatewayID_t gatewayID){ + mUpdateGraphNodesAction = true; }; - dboRemoveConverter = [&](const am_converterID_t converterID) - { - mUpdateGraphNodesAction=true; + dboRemoveConverter = [&](const am_converterID_t converterID){ + mUpdateGraphNodesAction = true; }; - } - - CAmRouter::~CAmRouter() - { - } +} - /** - * returns the best route between a source and a sink - * @param onlyfree if true only free gateways are used - * @param sourceID - * @param sinkID - * @param returnList this list contains a set of routes - * @return E_OK in case of success - */ - am_Error_e CAmRouter::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector & returnList) - { - if (mUpdateGraphNodesAction) - { - load(); - mUpdateGraphNodesAction = false; - } - return getRouteFromLoadedNodes(onlyfree, sourceID, sinkID, returnList); - } +CAmRouter::~CAmRouter() +{ +} - am_Error_e CAmRouter::getRoute(const bool onlyfree, const am_Source_s & aSource, const am_Sink_s & aSink, std::vector & listRoutes) +/** + * returns the best route between a source and a sink + * @param onlyfree if true only free gateways are used + * @param sourceID + * @param sinkID + * @param returnList this list contains a set of routes + * @return E_OK in case of success + */ +am_Error_e CAmRouter::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector &returnList) +{ + if (mUpdateGraphNodesAction) { - return getRoute(onlyfree, aSource.sourceID, aSink.sinkID, listRoutes); + load(); + mUpdateGraphNodesAction = false; } - am_Error_e CAmRouter::getRouteFromLoadedNodes(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, - std::vector & returnList) - { - returnList.clear(); - - CAmRoutingNode* pRootSource = sourceNodeWithID(sourceID); - CAmRoutingNode* pRootSink = sinkNodeWithID(sinkID); + return getRouteFromLoadedNodes(onlyfree, sourceID, sinkID, returnList); +} - if (!pRootSource || !pRootSink) - return E_NON_EXISTENT; +am_Error_e CAmRouter::getRoute(const bool onlyfree, const am_Source_s &aSource, const am_Sink_s &aSink, std::vector &listRoutes) +{ + return getRoute(onlyfree, aSource.sourceID, aSink.sinkID, listRoutes); +} - //try to find paths without cycles - am_Error_e error = getFirstNShortestPaths(onlyfree, 0, mMaxPathCount, *pRootSource, *pRootSink, returnList); +am_Error_e CAmRouter::getRouteFromLoadedNodes(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, + std::vector &returnList) +{ + returnList.clear(); - //if no paths have been found, we start a second search with cycles. - if (!returnList.size() && mMaxAllowedCycles > 0) - { - error = getFirstNShortestPaths(onlyfree, mMaxAllowedCycles, mMaxPathCount, *pRootSource, *pRootSink, returnList); - } + CAmRoutingNode *pRootSource = sourceNodeWithID(sourceID); + CAmRoutingNode *pRootSink = sinkNodeWithID(sinkID); - /* For shortest path use the following call: - * - * error = getShortestPath(*pRootSource, *pRootSink, listRoutes); - */ - return error; + if (!pRootSource || !pRootSink) + { + return E_NON_EXISTENT; } - am_Error_e CAmRouter::getRouteFromLoadedNodes(const bool onlyfree, const am_Source_s & aSource, const am_Sink_s & aSink, - std::vector & listRoutes) + // try to find paths without cycles + am_Error_e error = getFirstNShortestPaths(onlyfree, 0, mMaxPathCount, *pRootSource, *pRootSink, returnList); + + // if no paths have been found, we start a second search with cycles. + if (!returnList.size() && mMaxAllowedCycles > 0) { - return getRouteFromLoadedNodes(onlyfree, aSource.sourceID, aSink.sinkID, listRoutes); + error = getFirstNShortestPaths(onlyfree, mMaxAllowedCycles, mMaxPathCount, *pRootSource, *pRootSink, returnList); } - void CAmRouter::load() - { - clear(); + /* For shortest path use the following call: + * + * error = getShortestPath(*pRootSource, *pRootSink, listRoutes); + */ + return error; +} - am_RoutingNodeData_s nodeDataSrc; - nodeDataSrc.type = CAmNodeDataType::SOURCE; - mpDatabaseHandler->enumerateSources([&](const am_Source_s & obj) - { - nodeDataSrc.data.source = (am_Source_s*)&obj; +am_Error_e CAmRouter::getRouteFromLoadedNodes(const bool onlyfree, const am_Source_s &aSource, const am_Sink_s &aSink, + std::vector &listRoutes) +{ + return getRouteFromLoadedNodes(onlyfree, aSource.sourceID, aSink.sinkID, listRoutes); +} + +void CAmRouter::load() +{ + clear(); + + am_RoutingNodeData_s nodeDataSrc; + nodeDataSrc.type = CAmNodeDataType::SOURCE; + mpDatabaseHandler->enumerateSources([&](const am_Source_s &obj){ + nodeDataSrc.data.source = (am_Source_s *)&obj; auto node = &mRoutingGraph.addNode(nodeDataSrc); mNodeListSources[nodeDataSrc.data.source->domainID].push_back(node); }); - am_RoutingNodeData_s nodeDataSink; - nodeDataSink.type = CAmNodeDataType::SINK; - mpDatabaseHandler->enumerateSinks([&](const am_Sink_s & obj) - { - nodeDataSink.data.sink = (am_Sink_s*)&obj; + am_RoutingNodeData_s nodeDataSink; + nodeDataSink.type = CAmNodeDataType::SINK; + mpDatabaseHandler->enumerateSinks([&](const am_Sink_s &obj){ + nodeDataSink.data.sink = (am_Sink_s *)&obj; auto node = &mRoutingGraph.addNode(nodeDataSink); mNodeListSinks[nodeDataSink.data.sink->domainID].push_back(node); }); - am_RoutingNodeData_s nodeDataGateway; - nodeDataGateway.type = CAmNodeDataType::GATEWAY; - mpDatabaseHandler->enumerateGateways([&](const am_Gateway_s & obj) - { - nodeDataGateway.data.gateway = (am_Gateway_s*)&obj; + am_RoutingNodeData_s nodeDataGateway; + nodeDataGateway.type = CAmNodeDataType::GATEWAY; + mpDatabaseHandler->enumerateGateways([&](const am_Gateway_s &obj){ + nodeDataGateway.data.gateway = (am_Gateway_s *)&obj; auto node = &mRoutingGraph.addNode(nodeDataGateway); mNodeListGateways[nodeDataGateway.data.gateway->controlDomainID].push_back(node); }); - am_RoutingNodeData_s nodeDataConverter; - nodeDataConverter.type = CAmNodeDataType::CONVERTER; - mpDatabaseHandler->enumerateConverters([&](const am_Converter_s & obj) - { - nodeDataConverter.data.converter = (am_Converter_s*)&obj; + am_RoutingNodeData_s nodeDataConverter; + nodeDataConverter.type = CAmNodeDataType::CONVERTER; + mpDatabaseHandler->enumerateConverters([&](const am_Converter_s &obj){ + nodeDataConverter.data.converter = (am_Converter_s *)&obj; auto node = &mRoutingGraph.addNode(nodeDataConverter); mNodeListConverters[nodeDataConverter.data.converter->domainID].push_back(node); }); - constructConverterConnections(); - constructGatewayConnections(); - constructSourceSinkConnections(); + constructConverterConnections(); + constructGatewayConnections(); + constructSourceSinkConnections(); #ifdef TRACE_GRAPH - mRoutingGraph.trace([&](const CAmRoutingNode & node, const std::vector*> & list) - { - std::cout << "Node " << node.getIndex() << ":"; - ((CAmRoutingNode &)node).getData().trace(); - std::cout << "-->["; - int count = 0; - std::for_each(list.begin(), list.end(), [&](const CAmVertex* refVertex) - { - am::CAmNode* data = refVertex->getNode(); - if(count>0) - std::cout << ", "; - std::cout << "Node " << data->getIndex() << ":"; - data->getData().trace(); - count++; - }); - std::cout << "]" << std::endl; + mRoutingGraph.trace([&](const CAmRoutingNode &node, const std::vector *> &list){ + std::cout << "Node " << node.getIndex() << ":"; + ((CAmRoutingNode &)node).getData().trace(); + std::cout << "-->["; + int count = 0; + std::for_each(list.begin(), list.end(), [&](const CAmVertex *refVertex){ + am::CAmNode *data = refVertex->getNode(); + if (count > 0) + { + std::cout << ", "; + } + + std::cout << "Node " << data->getIndex() << ":"; + data->getData().trace(); + count++; }); -#endif + std::cout << "]" << std::endl; + }); +#endif // ifdef TRACE_GRAPH - } +} - void CAmRouter::clear() - { - mRoutingGraph.clear(); - mNodeListSources.clear(); - mNodeListSinks.clear(); - mNodeListGateways.clear(); - mNodeListConverters.clear(); - } +void CAmRouter::clear() +{ + mRoutingGraph.clear(); + mNodeListSources.clear(); + mNodeListSinks.clear(); + mNodeListGateways.clear(); + mNodeListConverters.clear(); +} - CAmRoutingNode* CAmRouter::sinkNodeWithID(const am_sinkID_t sinkID) +CAmRoutingNode *CAmRouter::sinkNodeWithID(const am_sinkID_t sinkID) +{ + CAmRoutingNode *result = NULL; + for (auto it = mNodeListSinks.begin(); it != mNodeListSinks.end(); it++) { - CAmRoutingNode* result = NULL; - for (auto it = mNodeListSinks.begin(); it != mNodeListSinks.end(); it++) + result = sinkNodeWithID(sinkID, it->first); + if (result) { - result = sinkNodeWithID(sinkID, it->first); - if (result) - return result; + return result; } - return result; } - CAmRoutingNode* CAmRouter::sinkNodeWithID(const am_sinkID_t sinkID, const am_domainID_t domainID) + return result; +} + +CAmRoutingNode *CAmRouter::sinkNodeWithID(const am_sinkID_t sinkID, const am_domainID_t domainID) +{ + CAmRoutingNode *result = NULL; + std::vector &value = mNodeListSinks[domainID]; + auto iter = std::find_if(value.begin(), value.end(), [sinkID](CAmRoutingNode *node){ + return node->getData().data.sink->sinkID == sinkID; + }); + if (iter != value.end()) { - CAmRoutingNode* result = NULL; - std::vector & value = mNodeListSinks[domainID]; - auto iter = std::find_if(value.begin(), value.end(), [sinkID](CAmRoutingNode* node) - { - return node->getData().data.sink->sinkID==sinkID; - }); - if (iter != value.end()) - result = *iter; - return result; + result = *iter; } - CAmRoutingNode* CAmRouter::sourceNodeWithID(const am_sourceID_t sourceID) + return result; +} + +CAmRoutingNode *CAmRouter::sourceNodeWithID(const am_sourceID_t sourceID) +{ + CAmRoutingNode *result = NULL; + for (auto it = mNodeListSources.begin(); it != mNodeListSources.end(); it++) { - CAmRoutingNode* result = NULL; - for (auto it = mNodeListSources.begin(); it != mNodeListSources.end(); it++) + result = sourceNodeWithID(sourceID, it->first); + if (result) { - result = sourceNodeWithID(sourceID, it->first); - if (result) - return result; + return result; } - return result; } - CAmRoutingNode* CAmRouter::sourceNodeWithID(const am_sourceID_t sourceID, const am_domainID_t domainID) + return result; +} + +CAmRoutingNode *CAmRouter::sourceNodeWithID(const am_sourceID_t sourceID, const am_domainID_t domainID) +{ + CAmRoutingNode *result = NULL; + std::vector &value = mNodeListSources[domainID]; + auto iter = std::find_if(value.begin(), value.end(), [sourceID](CAmRoutingNode *node){ + return node->getData().data.source->sourceID == sourceID; + }); + if (iter != value.end()) { - CAmRoutingNode* result = NULL; - std::vector & value = mNodeListSources[domainID]; - auto iter = std::find_if(value.begin(), value.end(), [sourceID](CAmRoutingNode* node) - { - return node->getData().data.source->sourceID==sourceID; - }); - if (iter != value.end()) - result = *iter; - return result; + result = *iter; } - CAmRoutingNode* CAmRouter::converterNodeWithSinkID(const am_sinkID_t sinkID, const am_domainID_t domainID) + return result; +} + +CAmRoutingNode *CAmRouter::converterNodeWithSinkID(const am_sinkID_t sinkID, const am_domainID_t domainID) +{ + CAmRoutingNode *result = NULL; + std::vector &value = mNodeListConverters[domainID]; + auto iter = std::find_if(value.begin(), value.end(), [sinkID](CAmRoutingNode *node){ + return node->getData().data.converter->sinkID == sinkID; + }); + if (iter != value.end()) { - CAmRoutingNode* result = NULL; - std::vector & value = mNodeListConverters[domainID]; - auto iter = std::find_if(value.begin(), value.end(), [sinkID](CAmRoutingNode* node) - { - return node->getData().data.converter->sinkID==sinkID; - }); - if (iter != value.end()) - result = *iter; - return result; + result = *iter; } - CAmRoutingNode* CAmRouter::gatewayNodeWithSinkID(const am_sinkID_t sinkID) + return result; +} + +CAmRoutingNode *CAmRouter::gatewayNodeWithSinkID(const am_sinkID_t sinkID) +{ + for (auto it = mNodeListGateways.begin(); it != mNodeListGateways.end(); it++) { - for (auto it = mNodeListGateways.begin(); it != mNodeListGateways.end(); it++) + std::vector &value = it->second; + auto iter = std::find_if(value.begin(), value.end(), [sinkID](CAmRoutingNode *node){ + return node->getData().data.gateway->sinkID == sinkID; + }); + if (iter != value.end()) { - std::vector & value = it->second; - auto iter = std::find_if(value.begin(), value.end(), [sinkID](CAmRoutingNode* node) - { - return node->getData().data.gateway->sinkID==sinkID; - }); - if (iter != value.end()) - return *iter; + return *iter; } - return NULL; } - void CAmRouter::constructSourceSinkConnections() + return NULL; +} + +void CAmRouter::constructSourceSinkConnections() +{ + std::vector intersection; + for (auto itSrc = mNodeListSources.begin(); itSrc != mNodeListSources.end(); itSrc++) { - std::vector intersection; - for (auto itSrc = mNodeListSources.begin(); itSrc != mNodeListSources.end(); itSrc++) + for (auto it = itSrc->second.begin(); it != itSrc->second.end(); it++) { - for (auto it = itSrc->second.begin(); it != itSrc->second.end(); it++) + CAmRoutingNode *srcNode = *it; + am_RoutingNodeData_s &srcNodeData = srcNode->getData(); + am_Source_s *source = srcNodeData.data.source; + for (auto itSink = mNodeListSinks[itSrc->first].begin(); itSink != mNodeListSinks[itSrc->first].end(); itSink++) { - CAmRoutingNode* srcNode = *it; - am_RoutingNodeData_s & srcNodeData = srcNode->getData(); - am_Source_s * source = srcNodeData.data.source; - for (auto itSink = mNodeListSinks[itSrc->first].begin(); itSink != mNodeListSinks[itSrc->first].end(); itSink++) + CAmRoutingNode *sinkNode = *itSink; + am_RoutingNodeData_s &sinkNodeData = sinkNode->getData(); + am_Sink_s *sink = sinkNodeData.data.sink; + + intersection.clear(); + // Check whether the hidden sink formats match the source formats... + listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, intersection); + if (intersection.size() > 0) // OK match source -> sink { - CAmRoutingNode* sinkNode = *itSink; - am_RoutingNodeData_s & sinkNodeData = sinkNode->getData(); - am_Sink_s * sink = sinkNodeData.data.sink; - - intersection.clear(); - //Check whether the hidden sink formats match the source formats... - listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, intersection); - if (intersection.size() > 0) //OK match source -> sink - { - mRoutingGraph.connectNodes(*srcNode, *sinkNode, CF_UNKNOWN, 1); - } + mRoutingGraph.connectNodes(*srcNode, *sinkNode, CF_UNKNOWN, 1); } } } } +} - void CAmRouter::constructGatewayConnections() +void CAmRouter::constructGatewayConnections() +{ + std::vector sourceFormats, sinkFormats; + for (auto iter = mNodeListGateways.begin(); iter != mNodeListGateways.end(); iter++) { - std::vector sourceFormats, sinkFormats; - for (auto iter = mNodeListGateways.begin(); iter != mNodeListGateways.end(); iter++) + for (auto it = iter->second.begin(); it != iter->second.end(); it++) { - for (auto it = iter->second.begin(); it != iter->second.end(); it++) + CAmRoutingNode *gatewayNode = *it; + am_RoutingNodeData_s &gatewayNodeData = gatewayNode->getData(); + am_Gateway_s *gateway = gatewayNodeData.data.gateway; + // Get only gateways with end point in current source domain + + // Get the sink connected to the gateway... + CAmRoutingNode *gatewaySinkNode = this->sinkNodeWithID(gateway->sinkID, gateway->domainSinkID); + if (gatewaySinkNode) { - CAmRoutingNode* gatewayNode = *it; - am_RoutingNodeData_s & gatewayNodeData = gatewayNode->getData(); - am_Gateway_s * gateway = gatewayNodeData.data.gateway; - //Get only gateways with end point in current source domain - - //Get the sink connected to the gateway... - CAmRoutingNode *gatewaySinkNode = this->sinkNodeWithID(gateway->sinkID, gateway->domainSinkID); - if (gatewaySinkNode) + am_RoutingNodeData_s &gatewaySinkData = gatewaySinkNode->getData(); + // Check whether the hidden sink formats match the source formats... + sourceFormats.clear(); + sinkFormats.clear(); + if (getAllowedFormatsFromConvMatrix(gateway->convertionMatrix, gateway->listSourceFormats, gateway->listSinkFormats, sourceFormats, + sinkFormats)) { - am_RoutingNodeData_s & gatewaySinkData = gatewaySinkNode->getData(); - //Check whether the hidden sink formats match the source formats... - sourceFormats.clear(); - sinkFormats.clear(); - if (getAllowedFormatsFromConvMatrix(gateway->convertionMatrix, gateway->listSourceFormats, gateway->listSinkFormats, sourceFormats, - sinkFormats)) + CAmRoutingNode *gatewaySourceNode = this->sourceNodeWithID(gateway->sourceID, gateway->domainSourceID); + if (gatewaySourceNode) { - CAmRoutingNode *gatewaySourceNode = this->sourceNodeWithID(gateway->sourceID, gateway->domainSourceID); - if (gatewaySourceNode) - { - //Connections hidden_sink->gateway->hidden_source - mRoutingGraph.connectNodes(*gatewaySinkNode, *gatewayNode, CF_UNKNOWN, 1); - mRoutingGraph.connectNodes(*gatewayNode, *gatewaySourceNode, CF_UNKNOWN, 1); - } + // Connections hidden_sink->gateway->hidden_source + mRoutingGraph.connectNodes(*gatewaySinkNode, *gatewayNode, CF_UNKNOWN, 1); + mRoutingGraph.connectNodes(*gatewayNode, *gatewaySourceNode, CF_UNKNOWN, 1); } } } } } +} - void CAmRouter::constructConverterConnections() - { - std::vector sourceFormats, sinkFormats; +void CAmRouter::constructConverterConnections() +{ + std::vector sourceFormats, sinkFormats; - for (auto iter = mNodeListConverters.begin(); iter != mNodeListConverters.end(); iter++) + for (auto iter = mNodeListConverters.begin(); iter != mNodeListConverters.end(); iter++) + { + for (auto it = iter->second.begin(); it != iter->second.end(); it++) { - for (auto it = iter->second.begin(); it != iter->second.end(); it++) + CAmRoutingNode *converterNode = *it; + am_RoutingNodeData_s &converterNodeData = converterNode->getData(); + am_Converter_s *converter = converterNodeData.data.converter; + // Get only converters with end point in current source domain + + // Get the sink connected to the converter... + CAmRoutingNode *converterSinkNode = this->sinkNodeWithID(converter->sinkID, converter->domainID); + if (converterSinkNode) { - CAmRoutingNode* converterNode = *it; - am_RoutingNodeData_s & converterNodeData = converterNode->getData(); - am_Converter_s * converter = converterNodeData.data.converter; - //Get only converters with end point in current source domain - - //Get the sink connected to the converter... - CAmRoutingNode *converterSinkNode = this->sinkNodeWithID(converter->sinkID, converter->domainID); - if (converterSinkNode) + am_RoutingNodeData_s &converterSinkData = converterSinkNode->getData(); + // Check whether the hidden sink formats match the source formats... + sourceFormats.clear(); + sinkFormats.clear(); + if (getAllowedFormatsFromConvMatrix(converter->convertionMatrix, converter->listSourceFormats, converter->listSinkFormats, sourceFormats, + sinkFormats)) { - am_RoutingNodeData_s & converterSinkData = converterSinkNode->getData(); - //Check whether the hidden sink formats match the source formats... - sourceFormats.clear(); - sinkFormats.clear(); - if (getAllowedFormatsFromConvMatrix(converter->convertionMatrix, converter->listSourceFormats, converter->listSinkFormats, sourceFormats, - sinkFormats)) + CAmRoutingNode *converterSourceNode = this->sourceNodeWithID(converter->sourceID, converter->domainID); + if (converterSourceNode) { - CAmRoutingNode *converterSourceNode = this->sourceNodeWithID(converter->sourceID, converter->domainID); - if (converterSourceNode) - { - //Connections hidden_sink->converter->hidden_source - mRoutingGraph.connectNodes(*converterSinkNode, *converterNode, CF_UNKNOWN, 1); - mRoutingGraph.connectNodes(*converterNode, *converterSourceNode, CF_UNKNOWN, 1); - } + // Connections hidden_sink->converter->hidden_source + mRoutingGraph.connectNodes(*converterSinkNode, *converterNode, CF_UNKNOWN, 1); + mRoutingGraph.connectNodes(*converterNode, *converterSourceNode, CF_UNKNOWN, 1); } } } } } +} - void CAmRouter::getVerticesForSource(const CAmRoutingNode & node, CAmRoutingListVertices & list) +void CAmRouter::getVerticesForSource(const CAmRoutingNode &node, CAmRoutingListVertices &list) +{ + am_RoutingNodeData_s &srcNodeData = ((CAmRoutingNode *)&node)->getData(); + std::vector intersection; + am_Source_s *source = srcNodeData.data.source; + std::vector &sinks = mNodeListSinks[source->domainID]; + for (auto itSink = sinks.begin(); itSink != sinks.end(); itSink++) { - am_RoutingNodeData_s & srcNodeData = ((CAmRoutingNode*) &node)->getData(); - std::vector intersection; - am_Source_s * source = srcNodeData.data.source; - std::vector & sinks = mNodeListSinks[source->domainID]; - for (auto itSink = sinks.begin(); itSink != sinks.end(); itSink++) + CAmRoutingNode *sinkNode = *itSink; + am_RoutingNodeData_s &sinkNodeData = sinkNode->getData(); + am_Sink_s *sink = sinkNodeData.data.sink; + + intersection.clear(); + // Check whether the hidden sink formats match the source formats... + listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, intersection); + if (intersection.size() > 0) // OK match source -> sink { - CAmRoutingNode* sinkNode = *itSink; - am_RoutingNodeData_s & sinkNodeData = sinkNode->getData(); - am_Sink_s * sink = sinkNodeData.data.sink; - - intersection.clear(); - //Check whether the hidden sink formats match the source formats... - listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, intersection); - if (intersection.size() > 0) //OK match source -> sink - { - list.emplace_back(sinkNode, CF_UNKNOWN, 1); - } + list.emplace_back(sinkNode, CF_UNKNOWN, 1); } } +} - void CAmRouter::getVerticesForSink(const CAmRoutingNode & node, CAmRoutingListVertices & list) +void CAmRouter::getVerticesForSink(const CAmRoutingNode &node, CAmRoutingListVertices &list) +{ + am_RoutingNodeData_s &sinkNodeData = ((CAmRoutingNode *)&node)->getData(); + std::vector intersection; + am_Sink_s *sink = sinkNodeData.data.sink; + + CAmRoutingNode *converterNode = converterNodeWithSinkID(sink->sinkID, sink->domainID); + if (converterNode) { - am_RoutingNodeData_s & sinkNodeData = ((CAmRoutingNode*) &node)->getData(); - std::vector intersection; - am_Sink_s * sink = sinkNodeData.data.sink; + std::vector sourceFormats, sinkFormats; + am_RoutingNodeData_s &converterData = converterNode->getData(); + am_Converter_s *converter = converterData.data.converter; - CAmRoutingNode *converterNode = converterNodeWithSinkID(sink->sinkID, sink->domainID); - if (converterNode) + if (getAllowedFormatsFromConvMatrix(converter->convertionMatrix, converter->listSourceFormats, converter->listSinkFormats, sourceFormats, + sinkFormats)) { - std::vector sourceFormats, sinkFormats; - am_RoutingNodeData_s & converterData = converterNode->getData(); - am_Converter_s * converter = converterData.data.converter; - - if (getAllowedFormatsFromConvMatrix(converter->convertionMatrix, converter->listSourceFormats, converter->listSinkFormats, sourceFormats, - sinkFormats)) - list.emplace_back(converterNode, CF_UNKNOWN, 1); + list.emplace_back(converterNode, CF_UNKNOWN, 1); } - else + } + else + { + std::vector sourceFormats, sinkFormats; + CAmRoutingNode *gatewayNode = gatewayNodeWithSinkID(sink->sinkID); + if (gatewayNode) { std::vector sourceFormats, sinkFormats; - CAmRoutingNode *gatewayNode = gatewayNodeWithSinkID(sink->sinkID); - if (gatewayNode) - { - std::vector sourceFormats, sinkFormats; - am_RoutingNodeData_s & gatewayData = gatewayNode->getData(); - am_Gateway_s * gateway = gatewayData.data.gateway; + am_RoutingNodeData_s &gatewayData = gatewayNode->getData(); + am_Gateway_s *gateway = gatewayData.data.gateway; - if (getAllowedFormatsFromConvMatrix(gateway->convertionMatrix, gateway->listSourceFormats, gateway->listSinkFormats, sourceFormats, - sinkFormats)) - list.emplace_back(gatewayNode, CF_UNKNOWN, 1); + if (getAllowedFormatsFromConvMatrix(gateway->convertionMatrix, gateway->listSourceFormats, gateway->listSinkFormats, sourceFormats, + sinkFormats)) + { + list.emplace_back(gatewayNode, CF_UNKNOWN, 1); } } - } +} - void CAmRouter::getVerticesForConverter(const CAmRoutingNode & node, CAmRoutingListVertices & list) +void CAmRouter::getVerticesForConverter(const CAmRoutingNode &node, CAmRoutingListVertices &list) +{ + std::vector sourceFormats, sinkFormats; + am_RoutingNodeData_s &converterNodeData = ((CAmRoutingNode *)&node)->getData(); + am_Converter_s *converter = converterNodeData.data.converter; + // Get only converters with end point in current source domain + if (getAllowedFormatsFromConvMatrix(converter->convertionMatrix, converter->listSourceFormats, converter->listSinkFormats, sourceFormats, sinkFormats)) { - std::vector sourceFormats, sinkFormats; - am_RoutingNodeData_s & converterNodeData = ((CAmRoutingNode*) &node)->getData(); - am_Converter_s * converter = converterNodeData.data.converter; - //Get only converters with end point in current source domain - if (getAllowedFormatsFromConvMatrix(converter->convertionMatrix, converter->listSourceFormats, converter->listSinkFormats, sourceFormats, sinkFormats)) + CAmRoutingNode *converterSourceNode = this->sourceNodeWithID(converter->sourceID, converter->domainID); + if (converterSourceNode) { - CAmRoutingNode *converterSourceNode = this->sourceNodeWithID(converter->sourceID, converter->domainID); - if (converterSourceNode) - { - list.emplace_back(converterSourceNode, CF_UNKNOWN, 1); - } + list.emplace_back(converterSourceNode, CF_UNKNOWN, 1); } } +} - void CAmRouter::getVerticesForGateway(const CAmRoutingNode & node, CAmRoutingListVertices & list) +void CAmRouter::getVerticesForGateway(const CAmRoutingNode &node, CAmRoutingListVertices &list) +{ + am_RoutingNodeData_s &gatewayNodeData = ((CAmRoutingNode *)&node)->getData(); + std::vector sourceFormats, sinkFormats; + am_Gateway_s *gateway = gatewayNodeData.data.gateway; + if (getAllowedFormatsFromConvMatrix(gateway->convertionMatrix, gateway->listSourceFormats, gateway->listSinkFormats, sourceFormats, sinkFormats)) { - am_RoutingNodeData_s & gatewayNodeData = ((CAmRoutingNode*) &node)->getData(); - std::vector sourceFormats, sinkFormats; - am_Gateway_s * gateway = gatewayNodeData.data.gateway; - if (getAllowedFormatsFromConvMatrix(gateway->convertionMatrix, gateway->listSourceFormats, gateway->listSinkFormats, sourceFormats, sinkFormats)) + CAmRoutingNode *gatewaySourceNode = this->sourceNodeWithID(gateway->sourceID, gateway->domainSourceID); + if (gatewaySourceNode) { - CAmRoutingNode *gatewaySourceNode = this->sourceNodeWithID(gateway->sourceID, gateway->domainSourceID); - if (gatewaySourceNode) - { - //Connections hidden_sink->gateway->hidden_source - list.emplace_back(gatewaySourceNode, CF_UNKNOWN, 1); - } + // Connections hidden_sink->gateway->hidden_source + list.emplace_back(gatewaySourceNode, CF_UNKNOWN, 1); } } +} - void CAmRouter::getVerticesForNode(const CAmRoutingNode & node, CAmRoutingListVertices & list) +void CAmRouter::getVerticesForNode(const CAmRoutingNode &node, CAmRoutingListVertices &list) +{ + am_RoutingNodeData_s &nodeData = ((CAmRoutingNode *)&node)->getData(); + if (nodeData.type == CAmNodeDataType::SOURCE) { - am_RoutingNodeData_s & nodeData = ((CAmRoutingNode*) &node)->getData(); - if (nodeData.type == CAmNodeDataType::SOURCE) + getVerticesForSource(node, list); + } + else if (nodeData.type == CAmNodeDataType::SINK) + { + getVerticesForSink(node, list); + } + else if (nodeData.type == CAmNodeDataType::CONVERTER) + { + getVerticesForConverter(node, list); + } + else if (nodeData.type == CAmNodeDataType::GATEWAY) + { + getVerticesForGateway(node, list); + } +} + +am_Error_e CAmRouter::determineConnectionFormatsForPath(am_Route_s &routeObjects, std::vector &nodes, std::vector &result) +{ + std::vector::iterator routingElementIterator = routeObjects.route.begin(); + std::vector::iterator nodeIterator = nodes.begin(); + if (routingElementIterator != routeObjects.route.end() && nodeIterator != nodes.end()) + { + return doConnectionFormatsForPath(routeObjects, nodes, routingElementIterator, nodeIterator, result); + } + + return E_OK; +} + +am_Error_e CAmRouter::doConnectionFormatsForPath(am_Route_s &routeObjects, std::vector &nodes, + std::vector::iterator routingElementIterator, std::vector::iterator nodeIterator, + std::vector &result) +{ + am_Error_e returnError = E_NOT_POSSIBLE; + std::vector listConnectionFormats; + std::vector listMergeConnectionFormats; + + std::vector::iterator currentNodeIterator = nodeIterator; + std::vector::iterator currentRoutingElementIterator = routingElementIterator; + + if (currentRoutingElementIterator != routeObjects.route.begin()) + { + std::vector listConnectionFormats; + std::vector::iterator tempIterator = (currentRoutingElementIterator - 1); + CAmRoutingNode *currentNode = *currentNodeIterator; + if ((returnError = getSourceSinkPossibleConnectionFormats(currentNodeIterator + 1, currentNodeIterator + 2, listConnectionFormats)) != E_OK) { - getVerticesForSource(node, list); + return returnError; } - else if (nodeData.type == CAmNodeDataType::SINK) + + if (currentNode->getData().type == CAmNodeDataType::GATEWAY) { - getVerticesForSink(node, list); + am_Gateway_s *gateway = currentNode->getData().data.gateway; + getMergeConnectionFormats(gateway, tempIterator->connectionFormat, listConnectionFormats, listMergeConnectionFormats); } - else if (nodeData.type == CAmNodeDataType::CONVERTER) + else if (currentNode->getData().type == CAmNodeDataType::CONVERTER) { - getVerticesForConverter(node, list); + am_Converter_s *converter = currentNode->getData().data.converter; + getMergeConnectionFormats(converter, tempIterator->connectionFormat, listConnectionFormats, listMergeConnectionFormats); } - else if (nodeData.type == CAmNodeDataType::GATEWAY) + else { - getVerticesForGateway(node, list); + return (E_UNKNOWN); } - } - am_Error_e CAmRouter::determineConnectionFormatsForPath(am_Route_s & routeObjects, std::vector & nodes, std::vector & result) - { - std::vector::iterator routingElementIterator = routeObjects.route.begin(); - std::vector::iterator nodeIterator = nodes.begin(); - if (routingElementIterator != routeObjects.route.end() && nodeIterator != nodes.end()) - return doConnectionFormatsForPath(routeObjects, nodes, routingElementIterator, nodeIterator, result); - return E_OK; + currentNodeIterator += 3; } - - am_Error_e CAmRouter::doConnectionFormatsForPath(am_Route_s & routeObjects, std::vector & nodes, - std::vector::iterator routingElementIterator, std::vector::iterator nodeIterator, - std::vector & result) + else { - am_Error_e returnError = E_NOT_POSSIBLE; - std::vector listConnectionFormats; - std::vector listMergeConnectionFormats; + CAmRoutingNode *currentNode = *currentNodeIterator; + if (currentNode->getData().type != CAmNodeDataType::SOURCE) + { + return (E_UNKNOWN); + } - std::vector::iterator currentNodeIterator = nodeIterator; - std::vector::iterator currentRoutingElementIterator = routingElementIterator; + currentNodeIterator++; - if (currentRoutingElementIterator != routeObjects.route.begin()) + if (currentNodeIterator == nodes.end()) { - std::vector listConnectionFormats; - std::vector::iterator tempIterator = (currentRoutingElementIterator - 1); - CAmRoutingNode * currentNode = *currentNodeIterator; - if ((returnError = getSourceSinkPossibleConnectionFormats(currentNodeIterator + 1, currentNodeIterator + 2, listConnectionFormats)) != E_OK) - return returnError; - - if (currentNode->getData().type == CAmNodeDataType::GATEWAY) - { - am_Gateway_s *gateway = currentNode->getData().data.gateway; - getMergeConnectionFormats(gateway, tempIterator->connectionFormat, listConnectionFormats, listMergeConnectionFormats); - } - else if (currentNode->getData().type == CAmNodeDataType::CONVERTER) - { - am_Converter_s *converter = currentNode->getData().data.converter; - getMergeConnectionFormats(converter, tempIterator->connectionFormat, listConnectionFormats, listMergeConnectionFormats); - } - else - return (E_UNKNOWN); - currentNodeIterator += 3; + return (E_UNKNOWN); } - else + + CAmRoutingNode *nodeSink = *currentNodeIterator; + if (nodeSink->getData().type != CAmNodeDataType::SINK) { - CAmRoutingNode * currentNode = *currentNodeIterator; - if (currentNode->getData().type != CAmNodeDataType::SOURCE) - return (E_UNKNOWN); - currentNodeIterator++; - - if (currentNodeIterator == nodes.end()) - return (E_UNKNOWN); - - CAmRoutingNode * nodeSink = *currentNodeIterator; - if (nodeSink->getData().type != CAmNodeDataType::SINK) - return (E_UNKNOWN); - - am_Source_s *source = currentNode->getData().data.source; - am_Sink_s *sink = nodeSink->getData().data.sink; - listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, listMergeConnectionFormats); - currentNodeIterator += 1; //now we are on the next converter/gateway + return (E_UNKNOWN); } - //let the controller decide: - std::vector listPriorityConnectionFormats; - if ((returnError = mpControlSender->getConnectionFormatChoice(currentRoutingElementIterator->sourceID, currentRoutingElementIterator->sinkID, - routeObjects, listMergeConnectionFormats, listPriorityConnectionFormats)) != E_OK) - return (returnError); - - if (listPriorityConnectionFormats.empty()) - return (E_NOT_POSSIBLE); - //we have the list sorted after priors - now we try one after the other with the next part of the route - std::vector::iterator connectionFormatIterator = listPriorityConnectionFormats.begin(); - //here we need to check if we are at the end and stop - std::vector::iterator nextIterator = currentRoutingElementIterator + 1; //next pair source and sink - if (nextIterator == routeObjects.route.end()) + + am_Source_s *source = currentNode->getData().data.source; + am_Sink_s *sink = nodeSink->getData().data.sink; + listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, listMergeConnectionFormats); + currentNodeIterator += 1; // now we are on the next converter/gateway + } + + // let the controller decide: + std::vector listPriorityConnectionFormats; + if ((returnError = mpControlSender->getConnectionFormatChoice(currentRoutingElementIterator->sourceID, currentRoutingElementIterator->sinkID, + routeObjects, listMergeConnectionFormats, listPriorityConnectionFormats)) != E_OK) + { + return (returnError); + } + + if (listPriorityConnectionFormats.empty()) + { + return (E_NOT_POSSIBLE); + } + + // we have the list sorted after priors - now we try one after the other with the next part of the route + std::vector::iterator connectionFormatIterator = listPriorityConnectionFormats.begin(); + // here we need to check if we are at the end and stop + std::vector::iterator nextIterator = currentRoutingElementIterator + 1; // next pair source and sink + if (nextIterator == routeObjects.route.end()) + { + for (; connectionFormatIterator != listPriorityConnectionFormats.end(); ++connectionFormatIterator) { - for (; connectionFormatIterator != listPriorityConnectionFormats.end(); ++connectionFormatIterator) - { - currentRoutingElementIterator->connectionFormat = *connectionFormatIterator; - result.push_back(routeObjects); - } + currentRoutingElementIterator->connectionFormat = *connectionFormatIterator; + result.push_back(routeObjects); } - else + } + else + { + for (; connectionFormatIterator != listPriorityConnectionFormats.end(); ++connectionFormatIterator) { - for (; connectionFormatIterator != listPriorityConnectionFormats.end(); ++connectionFormatIterator) - { - currentRoutingElementIterator->connectionFormat = *connectionFormatIterator; - doConnectionFormatsForPath(routeObjects, nodes, nextIterator, currentNodeIterator, result); - } + currentRoutingElementIterator->connectionFormat = *connectionFormatIterator; + doConnectionFormatsForPath(routeObjects, nodes, nextIterator, currentNodeIterator, result); } - return (E_OK); } - am_Error_e CAmRouter::cfPermutationsForPath(am_Route_s shortestRoute, std::vector resultNodesPath, std::vector& resultPath) + return (E_OK); +} + +am_Error_e CAmRouter::cfPermutationsForPath(am_Route_s shortestRoute, std::vector resultNodesPath, std::vector &resultPath) +{ + std::vector result; + am_Error_e err = determineConnectionFormatsForPath(shortestRoute, resultNodesPath, result); + if (err != E_UNKNOWN) { - std::vector result; - am_Error_e err = determineConnectionFormatsForPath(shortestRoute, resultNodesPath, result); - if (err != E_UNKNOWN) - { - resultPath.insert(resultPath.end(), result.begin(), result.end()); + resultPath.insert(resultPath.end(), result.begin(), result.end()); #ifdef TRACE_GRAPH - std::cout + std::cout << "Determined connection formats for path from source:" << shortestRoute.sourceID << " to sink:" << shortestRoute.sinkID << "\n"; - for (auto routeConnectionFormats : result) + for (auto routeConnectionFormats : result) + { + std::cout << "["; + for (auto it = routeConnectionFormats.route.begin(); it != routeConnectionFormats.route.end(); it++) { - std::cout << "["; - for (auto it = routeConnectionFormats.route.begin();it != routeConnectionFormats.route.end(); it++) + am_RoutingElement_s &routingElement = *it; + if (it - routeConnectionFormats.route.begin() > 0) { - am_RoutingElement_s& routingElement = *it; - if (it - routeConnectionFormats.route.begin() > 0) std::cout << " -> "; - - std::cout << routingElement.sourceID << ":" - << routingElement.sinkID << " CF:" - << routingElement.connectionFormat << " D:" - << routingElement.domainID; } - std::cout << "]\n"; + + std::cout << routingElement.sourceID << ":" + << routingElement.sinkID << " CF:" + << routingElement.connectionFormat << " D:" + << routingElement.domainID; } -#endif + + std::cout << "]\n"; } +#endif // ifdef TRACE_GRAPH + } + #ifdef TRACE_GRAPH - else - { - std::cout + else + { + std::cout << "Error by determining connection formats for path from source:" << shortestRoute.sourceID << " to sink:" << shortestRoute.sinkID << "\n"; - } -#endif - return err; } +#endif // ifdef TRACE_GRAPH + return err; +} - am_Error_e CAmRouter::getShortestPath(CAmRoutingNode & aSource, CAmRoutingNode & aSink, std::vector & resultPath) - { - am_Error_e err = E_OK; - am_Route_s shortestRoute; - std::vector resultNodesPath; - am_RoutingNodeData_s & sinkNodeData = aSink.getData(); - am_RoutingNodeData_s & sourceNodeData = aSource.getData(); - shortestRoute.sinkID = sinkNodeData.data.sink->sinkID; - shortestRoute.sourceID = sourceNodeData.data.source->sourceID; - - mRoutingGraph.getShortestPath(aSource, aSink, [&shortestRoute, &resultNodesPath](const am_GraphPathPosition_e position, CAmRoutingNode & object) - { - am_RoutingElement_s * element; - //reverse order - resultNodesPath.insert(resultNodesPath.begin(), (CAmRoutingNode*)&object); - am_RoutingNodeData_s & routingData = object.getData(); - if(routingData.type==CAmNodeDataType::SINK) - { - auto iter = shortestRoute.route.emplace(shortestRoute.route.begin()); - element = &(*iter); - element->domainID = routingData.data.sink->domainID; - element->sinkID = routingData.data.sink->sinkID; - element->connectionFormat = CF_UNKNOWN; - } - else if(routingData.type==CAmNodeDataType::SOURCE) - { - element->domainID = routingData.data.source->domainID; - element->sourceID = routingData.data.source->sourceID; - element->connectionFormat = CF_UNKNOWN; - } - }); +am_Error_e CAmRouter::getShortestPath(CAmRoutingNode &aSource, CAmRoutingNode &aSink, std::vector &resultPath) +{ + am_Error_e err = E_OK; + am_Route_s shortestRoute; + std::vector resultNodesPath; + am_RoutingNodeData_s &sinkNodeData = aSink.getData(); + am_RoutingNodeData_s &sourceNodeData = aSource.getData(); + shortestRoute.sinkID = sinkNodeData.data.sink->sinkID; + shortestRoute.sourceID = sourceNodeData.data.source->sourceID; + + mRoutingGraph.getShortestPath(aSource, aSink, [&shortestRoute, &resultNodesPath](const am_GraphPathPosition_e position, CAmRoutingNode &object){ + am_RoutingElement_s *element; + // reverse order + resultNodesPath.insert(resultNodesPath.begin(), (CAmRoutingNode *)&object); + am_RoutingNodeData_s &routingData = object.getData(); + if (routingData.type == CAmNodeDataType::SINK) + { + auto iter = shortestRoute.route.emplace(shortestRoute.route.begin()); + element = &(*iter); + element->domainID = routingData.data.sink->domainID; + element->sinkID = routingData.data.sink->sinkID; + element->connectionFormat = CF_UNKNOWN; + } + else if (routingData.type == CAmNodeDataType::SOURCE) + { + element->domainID = routingData.data.source->domainID; + element->sourceID = routingData.data.source->sourceID; + element->connectionFormat = CF_UNKNOWN; + } + }); - if (shortestRoute.route.size()) - { - err = cfPermutationsForPath(shortestRoute, resultNodesPath, resultPath); - } - return err; + if (shortestRoute.route.size()) + { + err = cfPermutationsForPath(shortestRoute, resultNodesPath, resultPath); } - int CAmRouter::insertPostion(const std::vector& path, const std::vector >& nodes) + return err; +} + +int CAmRouter::insertPostion(const std::vector &path, const std::vector > &nodes) +{ + int index = 0; + if (!nodes.empty()) { - int index = 0; - if (!nodes.empty()) + auto itNodes = nodes.begin(); + for (; itNodes != nodes.end(); itNodes++) { - auto itNodes = nodes.begin(); - for (; itNodes != nodes.end(); itNodes++) + if (itNodes->size() > path.size()) { - if (itNodes->size() > path.size()) - break; + break; } - if (itNodes == nodes.end()) - index = nodes.size(); - else - index = itNodes - nodes.begin(); } - return index; + + if (itNodes == nodes.end()) + { + index = nodes.size(); + } + else + { + index = itNodes - nodes.begin(); + } } - am_Error_e CAmRouter::getFirstNShortestPaths(const bool onlyFree, const unsigned cycles, const unsigned maxPathCount, CAmRoutingNode & aSource, - CAmRoutingNode & aSink, std::vector & resultPath) + return index; +} + +am_Error_e CAmRouter::getFirstNShortestPaths(const bool onlyFree, const unsigned cycles, const unsigned maxPathCount, CAmRoutingNode &aSource, + CAmRoutingNode &aSink, std::vector &resultPath) +{ + if (aSource.getData().type != CAmNodeDataType::SOURCE || aSink.getData().type != CAmNodeDataType::SINK) { - if (aSource.getData().type != CAmNodeDataType::SOURCE || aSink.getData().type != CAmNodeDataType::SINK) - return E_NOT_POSSIBLE; - const am_sinkID_t sinkID = aSink.getData().data.sink->sinkID; - const am_sourceID_t sourceID = aSource.getData().data.source->sourceID; - std::vector paths; - std::vector> nodes; - std::vector visitedDomains; - visitedDomains.push_back(((CAmRoutingNode*) &aSource)->getData().domainID()); + return E_NOT_POSSIBLE; + } - auto cbShouldVisitNode = [&visitedDomains, &cycles, &onlyFree, this](const CAmRoutingNode * node)->bool - { - if(CAmRouter::shouldGoInDomain(visitedDomains, node->getData().domainID(), cycles)) + const am_sinkID_t sinkID = aSink.getData().data.sink->sinkID; + const am_sourceID_t sourceID = aSource.getData().data.source->sourceID; + std::vector paths; + std::vector > nodes; + std::vector visitedDomains; + visitedDomains.push_back(((CAmRoutingNode *)&aSource)->getData().domainID()); + + auto cbShouldVisitNode = [&visitedDomains, &cycles, &onlyFree, this](const CAmRoutingNode *node) -> bool { + if (CAmRouter::shouldGoInDomain(visitedDomains, node->getData().domainID(), cycles)) { - const am_RoutingNodeData_s & nodeData = node->getData(); - if(am_RoutingNodeData_s::GATEWAY==nodeData.type) + const am_RoutingNodeData_s &nodeData = node->getData(); + if (am_RoutingNodeData_s::GATEWAY == nodeData.type) { - const am_Gateway_s * gateway = nodeData.data.gateway; + const am_Gateway_s *gateway = nodeData.data.gateway; return (!onlyFree || !isComponentConnected(*gateway)); } - else if(am_RoutingNodeData_s::CONVERTER==nodeData.type) + else if (am_RoutingNodeData_s::CONVERTER == nodeData.type) { - const am_Converter_s * converter = nodeData.data.converter; + const am_Converter_s *converter = nodeData.data.converter; return (!onlyFree || !isComponentConnected(*converter)); } + return true; } + return false; }; - auto cbWillVisitNode = [&visitedDomains](const CAmRoutingNode * node) - { visitedDomains.push_back(node->getData().domainID());}; - auto cbDidVisitNode = [&visitedDomains](const CAmRoutingNode * node) - { visitedDomains.erase(visitedDomains.end()-1);}; - auto cbDidFinish = [&resultPath, &nodes, &paths, &sinkID, &sourceID](const std::vector & path) - { + auto cbWillVisitNode = [&visitedDomains](const CAmRoutingNode *node){ + visitedDomains.push_back(node->getData().domainID()); + }; + auto cbDidVisitNode = [&visitedDomains](const CAmRoutingNode *node){ + visitedDomains.erase(visitedDomains.end() - 1); + }; + auto cbDidFinish = [&resultPath, &nodes, &paths, &sinkID, &sourceID](const std::vector &path){ int index = CAmRouter::insertPostion(path, nodes); - nodes.emplace(nodes.begin()+index); - paths.emplace(paths.begin()+index); + nodes.emplace(nodes.begin() + index); + paths.emplace(paths.begin() + index); nodes[index] = path; - am_Route_s & nextRoute = paths[index]; - nextRoute.sinkID = sinkID; + am_Route_s &nextRoute = paths[index]; + nextRoute.sinkID = sinkID; nextRoute.sourceID = sourceID; - am_RoutingElement_s * element; - for(auto it = path.begin(); it!=path.end(); it++) + am_RoutingElement_s *element; + for (auto it = path.begin(); it != path.end(); it++) { - am_RoutingNodeData_s & routingData = (*it)->getData(); - if(routingData.type==CAmNodeDataType::SOURCE) + am_RoutingNodeData_s &routingData = (*it)->getData(); + if (routingData.type == CAmNodeDataType::SOURCE) { auto iter = nextRoute.route.emplace(nextRoute.route.end()); - element = &(*iter); - element->domainID = routingData.data.source->domainID; - element->sourceID = routingData.data.source->sourceID; + element = &(*iter); + element->domainID = routingData.data.source->domainID; + element->sourceID = routingData.data.source->sourceID; element->connectionFormat = CF_UNKNOWN; } - else if(routingData.type==CAmNodeDataType::SINK) + else if (routingData.type == CAmNodeDataType::SINK) { - element->domainID = routingData.data.sink->domainID; - element->sinkID = routingData.data.sink->sinkID; + element->domainID = routingData.data.sink->domainID; + element->sinkID = routingData.data.sink->sinkID; element->connectionFormat = CF_UNKNOWN; } } }; - mRoutingGraph.getAllPaths(aSource, aSink, cbShouldVisitNode, cbWillVisitNode, cbDidVisitNode, cbDidFinish); - unsigned pathsFound = 0; - am_Error_e cfError = E_OK; - for (auto it = paths.begin(); pathsFound < maxPathCount && it != paths.end(); it++) + mRoutingGraph.getAllPaths(aSource, aSink, cbShouldVisitNode, cbWillVisitNode, cbDidVisitNode, cbDidFinish); + unsigned pathsFound = 0; + am_Error_e cfError = E_OK; + for (auto it = paths.begin(); pathsFound < maxPathCount && it != paths.end(); it++) + { + cfError = cfPermutationsForPath(*it, nodes[it - paths.begin()], resultPath); + if (E_OK == cfError) { - cfError = cfPermutationsForPath(*it, nodes[it - paths.begin()], resultPath); - if (E_OK == cfError) - { - pathsFound += (resultPath.size() > 0); - } + pathsFound += (resultPath.size() > 0); } - if (pathsFound) - return E_OK; - else - return E_NOT_POSSIBLE; } - bool CAmRouter::shouldGoInDomain(const std::vector & visitedDomains, const am_domainID_t nodeDomainID, const unsigned maxCyclesNumber) + if (pathsFound) + { + return E_OK; + } + else { - unsigned recourseCounter(0); - if (visitedDomains.size()) + return E_NOT_POSSIBLE; + } +} + +bool CAmRouter::shouldGoInDomain(const std::vector &visitedDomains, const am_domainID_t nodeDomainID, const unsigned maxCyclesNumber) +{ + unsigned recourseCounter(0); + if (visitedDomains.size()) + { + if (visitedDomains.back() == nodeDomainID) { - if (visitedDomains.back() == nodeDomainID) - return true; - unsigned count = 0; - am_domainID_t lastDomain = 0; - for (auto it = visitedDomains.begin(); it != visitedDomains.end() - 1; it++) + return true; + } + + unsigned count = 0; + am_domainID_t lastDomain = 0; + for (auto it = visitedDomains.begin(); it != visitedDomains.end() - 1; it++) + { + if (lastDomain != *it) { - if (lastDomain != *it) + if (nodeDomainID == *it) { - if (nodeDomainID == *it) + recourseCounter++; + if (recourseCounter > maxCyclesNumber) { - recourseCounter++; - if (recourseCounter > maxCyclesNumber) - return false; + return false; } - lastDomain = *it; } + + lastDomain = *it; } } - return true; } - bool CAmRouter::shouldGoInDomain(const std::vector & visitedDomains, const am_domainID_t nodeDomainID) + return true; +} + +bool CAmRouter::shouldGoInDomain(const std::vector &visitedDomains, const am_domainID_t nodeDomainID) +{ + return CAmRouter::shouldGoInDomain(visitedDomains, nodeDomainID, mMaxAllowedCycles); +} + +bool CAmRouter::getAllowedFormatsFromConvMatrix(const std::vector &convertionMatrix, + const std::vector &listSourceFormats, const std::vector &listSinkFormats, + std::vector &sourceFormats, std::vector &sinkFormats) +{ + const size_t sizeSourceFormats = listSourceFormats.size(); + const size_t sizeSinkFormats = listSinkFormats.size(); + const size_t sizeConvertionMatrix = convertionMatrix.size(); + + if (sizeSourceFormats == 0 || sizeSinkFormats == 0 || sizeConvertionMatrix == 0 || sizeConvertionMatrix != sizeSinkFormats * sizeSourceFormats) { - return CAmRouter::shouldGoInDomain(visitedDomains, nodeDomainID, mMaxAllowedCycles); + return false; } - bool CAmRouter::getAllowedFormatsFromConvMatrix(const std::vector & convertionMatrix, - const std::vector & listSourceFormats, const std::vector & listSinkFormats, - std::vector & sourceFormats, std::vector & sinkFormats) + std::vector::const_iterator iterator = convertionMatrix.begin(); + for (; iterator != convertionMatrix.end(); ++iterator) { - const size_t sizeSourceFormats = listSourceFormats.size(); - const size_t sizeSinkFormats = listSinkFormats.size(); - const size_t sizeConvertionMatrix = convertionMatrix.size(); - - if (sizeSourceFormats == 0 || sizeSinkFormats == 0 || sizeConvertionMatrix == 0 || sizeConvertionMatrix != sizeSinkFormats * sizeSourceFormats) + if (true == *iterator) { - return false; + const size_t index = iterator - convertionMatrix.begin(); + size_t idx = index % sizeSourceFormats; + sourceFormats.push_back(listSourceFormats.at(idx)); + idx = index / sizeSourceFormats; + sinkFormats.push_back(listSinkFormats.at(idx)); } - - std::vector::const_iterator iterator = convertionMatrix.begin(); - for (; iterator != convertionMatrix.end(); ++iterator) - { - if (true == *iterator) - { - const size_t index = iterator - convertionMatrix.begin(); - size_t idx = index % sizeSourceFormats; - sourceFormats.push_back(listSourceFormats.at(idx)); - idx = index / sizeSourceFormats; - sinkFormats.push_back(listSinkFormats.at(idx)); - } - } - return sourceFormats.size() > 0; } - void CAmRouter::listPossibleConnectionFormats(std::vector & inListSourceFormats, - std::vector & inListSinkFormats, std::vector & outListFormats) - { - std::sort(inListSourceFormats.begin(), inListSourceFormats.end()); - std::sort(inListSinkFormats.begin(), inListSinkFormats.end()); - std::insert_iterator > inserter(outListFormats, outListFormats.begin()); - set_intersection(inListSourceFormats.begin(), inListSourceFormats.end(), inListSinkFormats.begin(), inListSinkFormats.end(), inserter); - } + return sourceFormats.size() > 0; +} - bool CAmRouter::getRestrictedOutputFormats(const std::vector & convertionMatrix, const std::vector & listSourceFormats, - const std::vector & listSinkFormats, const am_CustomConnectionFormat_t connectionFormat, - std::vector & listFormats) - { - listFormats.clear(); - std::vector::const_iterator rowSinkIterator = listSinkFormats.begin(); - std::vector::const_iterator matrixIterator = convertionMatrix.begin(); +void CAmRouter::listPossibleConnectionFormats(std::vector &inListSourceFormats, + std::vector &inListSinkFormats, std::vector &outListFormats) +{ + std::sort(inListSourceFormats.begin(), inListSourceFormats.end()); + std::sort(inListSinkFormats.begin(), inListSinkFormats.end()); + std::insert_iterator > inserter(outListFormats, outListFormats.begin()); + set_intersection(inListSourceFormats.begin(), inListSourceFormats.end(), inListSinkFormats.begin(), inListSinkFormats.end(), inserter); +} + +bool CAmRouter::getRestrictedOutputFormats(const std::vector &convertionMatrix, const std::vector &listSourceFormats, + const std::vector &listSinkFormats, const am_CustomConnectionFormat_t connectionFormat, + std::vector &listFormats) +{ + listFormats.clear(); + std::vector::const_iterator rowSinkIterator = listSinkFormats.begin(); + std::vector::const_iterator matrixIterator = convertionMatrix.begin(); - //find the row number of the sink - rowSinkIterator = find(listSinkFormats.begin(), listSinkFormats.end(), connectionFormat); - int rowNumberSink = rowSinkIterator - listSinkFormats.begin(); + // find the row number of the sink + rowSinkIterator = find(listSinkFormats.begin(), listSinkFormats.end(), connectionFormat); + int rowNumberSink = rowSinkIterator - listSinkFormats.begin(); - //go through the convertionMatrix and find out if the conversion is possible, if yes, add connectionFormat ... - std::advance(matrixIterator, rowNumberSink); + // go through the convertionMatrix and find out if the conversion is possible, if yes, add connectionFormat ... + std::advance(matrixIterator, rowNumberSink); - //iterate line-wise through the matrix and add more formats - do + // iterate line-wise through the matrix and add more formats + do + { + if (*matrixIterator) { - if (*matrixIterator) - { - listFormats.push_back(listSourceFormats.at((matrixIterator - convertionMatrix.begin()) / listSinkFormats.size())); - } - std::advance(matrixIterator, listSinkFormats.size()); - } while (convertionMatrix.end() - matrixIterator > 0); + listFormats.push_back(listSourceFormats.at((matrixIterator - convertionMatrix.begin()) / listSinkFormats.size())); + } + + std::advance(matrixIterator, listSinkFormats.size()); + } while (convertionMatrix.end() - matrixIterator > 0); + + return listFormats.size(); +} - return listFormats.size(); +am_Error_e CAmRouter::getSourceSinkPossibleConnectionFormats(std::vector::iterator iteratorSource, + std::vector::iterator iteratorSink, std::vector &outConnectionFormats) +{ + CAmRoutingNode *nodeSink = *iteratorSink; + if (nodeSink->getData().type != CAmNodeDataType::SINK) + { + return (E_UNKNOWN); } - am_Error_e CAmRouter::getSourceSinkPossibleConnectionFormats(std::vector::iterator iteratorSource, - std::vector::iterator iteratorSink, std::vector & outConnectionFormats) + CAmRoutingNode *nodeSource = *iteratorSource; + if (nodeSource->getData().type != CAmNodeDataType::SOURCE) { - CAmRoutingNode * nodeSink = *iteratorSink; - if (nodeSink->getData().type != CAmNodeDataType::SINK) - return (E_UNKNOWN); + return (E_UNKNOWN); + } - CAmRoutingNode * nodeSource = *iteratorSource; - if (nodeSource->getData().type != CAmNodeDataType::SOURCE) - return (E_UNKNOWN); + am_Source_s *source = nodeSource->getData().data.source; + am_Sink_s *sink = nodeSink->getData().data.sink; + listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, outConnectionFormats); + return (E_OK); +} - am_Source_s *source = nodeSource->getData().data.source; - am_Sink_s *sink = nodeSink->getData().data.sink; - listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, outConnectionFormats); - return (E_OK); - } +am_Error_e CAmRouter::getAllPaths(CAmRoutingNode &aSource, CAmRoutingNode &aSink, std::vector &resultPath, + std::vector > &resultNodesPath, const bool includeCycles, const bool onlyFree) +{ - am_Error_e CAmRouter::getAllPaths(CAmRoutingNode & aSource, CAmRoutingNode & aSink, std::vector & resultPath, - std::vector> & resultNodesPath, const bool includeCycles, const bool onlyFree) + if (aSource.getData().type != CAmNodeDataType::SOURCE || aSink.getData().type != CAmNodeDataType::SINK) { + return E_NOT_POSSIBLE; + } - if (aSource.getData().type != CAmNodeDataType::SOURCE || aSink.getData().type != CAmNodeDataType::SINK) - return E_NOT_POSSIBLE; + unsigned cycles; + if (includeCycles) + { + cycles = UINT_MAX; + } + else + { + cycles = 0; + } - unsigned cycles; - if (includeCycles) - cycles = UINT_MAX; - else - cycles = 0; - - uint8_t errorsCount = 0, successCount = 0; - const am_sinkID_t sinkID = aSink.getData().data.sink->sinkID; - const am_sourceID_t sourceID = aSource.getData().data.source->sourceID; - std::vector paths; - std::vector visitedDomains; - visitedDomains.push_back(((CAmRoutingNode*) &aSource)->getData().domainID()); - mRoutingGraph.getAllPaths(aSource, aSink, [&visitedDomains, &cycles, &onlyFree, this](const CAmRoutingNode * node)->bool - { - if(CAmRouter::shouldGoInDomain(visitedDomains, node->getData().domainID(), cycles)) + uint8_t errorsCount = 0, successCount = 0; + const am_sinkID_t sinkID = aSink.getData().data.sink->sinkID; + const am_sourceID_t sourceID = aSource.getData().data.source->sourceID; + std::vector paths; + std::vector visitedDomains; + visitedDomains.push_back(((CAmRoutingNode *)&aSource)->getData().domainID()); + mRoutingGraph.getAllPaths(aSource, aSink, [&visitedDomains, &cycles, &onlyFree, this](const CAmRoutingNode *node) -> bool { + if (CAmRouter::shouldGoInDomain(visitedDomains, node->getData().domainID(), cycles)) { - const am_RoutingNodeData_s & nodeData = node->getData(); - if(am_RoutingNodeData_s::GATEWAY==nodeData.type) + const am_RoutingNodeData_s &nodeData = node->getData(); + if (am_RoutingNodeData_s::GATEWAY == nodeData.type) { - const am_Gateway_s * gateway = nodeData.data.gateway; + const am_Gateway_s *gateway = nodeData.data.gateway; return (!onlyFree || !isComponentConnected(*gateway)); } - else if(am_RoutingNodeData_s::CONVERTER==nodeData.type) + else if (am_RoutingNodeData_s::CONVERTER == nodeData.type) { - const am_Converter_s * converter = nodeData.data.converter; + const am_Converter_s *converter = nodeData.data.converter; return (!onlyFree || !isComponentConnected(*converter)); } + return true; } + return false; - }, [&visitedDomains](const CAmRoutingNode * node) - { + }, [&visitedDomains](const CAmRoutingNode *node){ visitedDomains.push_back(node->getData().domainID()); - }, [&visitedDomains](const CAmRoutingNode * node) - { visitedDomains.erase(visitedDomains.end()-1);}, - [&resultPath, &resultNodesPath, &paths, &errorsCount, &successCount, &sinkID, &sourceID](const std::vector & path) + }, [&visitedDomains](const CAmRoutingNode *node){ + visitedDomains.erase(visitedDomains.end() - 1); + }, + [&resultPath, &resultNodesPath, &paths, &errorsCount, &successCount, &sinkID, &sourceID](const std::vector &path){ + int index = CAmRouter::insertPostion(path, resultNodesPath); + resultNodesPath.emplace(resultNodesPath.begin() + index); + paths.emplace(paths.begin() + index); + resultNodesPath[index] = path; + am_Route_s &nextRoute = paths[index]; + nextRoute.sinkID = sinkID; + nextRoute.sourceID = sourceID; + am_RoutingElement_s *element; + for (auto it = path.begin(); it != path.end(); it++) + { + am_RoutingNodeData_s &routingData = (*it)->getData(); + if (routingData.type == CAmNodeDataType::SOURCE) { - int index = CAmRouter::insertPostion(path, resultNodesPath); - resultNodesPath.emplace(resultNodesPath.begin()+index); - paths.emplace(paths.begin()+index); - resultNodesPath[index] = path; - am_Route_s & nextRoute = paths[index]; - nextRoute.sinkID = sinkID; - nextRoute.sourceID = sourceID; - am_RoutingElement_s * element; - for(auto it = path.begin(); it!=path.end(); it++) - { - am_RoutingNodeData_s & routingData = (*it)->getData(); - if(routingData.type==CAmNodeDataType::SOURCE) - { - auto iter = nextRoute.route.emplace(nextRoute.route.end()); - element = &(*iter); - element->domainID = routingData.data.source->domainID; - element->sourceID = routingData.data.source->sourceID; - element->connectionFormat = CF_UNKNOWN; - } - else if(routingData.type==CAmNodeDataType::SINK) - { - element->domainID = routingData.data.sink->domainID; - element->sinkID = routingData.data.sink->sinkID; - element->connectionFormat = CF_UNKNOWN; - } - } - }); + auto iter = nextRoute.route.emplace(nextRoute.route.end()); + element = &(*iter); + element->domainID = routingData.data.source->domainID; + element->sourceID = routingData.data.source->sourceID; + element->connectionFormat = CF_UNKNOWN; + } + else if (routingData.type == CAmNodeDataType::SINK) + { + element->domainID = routingData.data.sink->domainID; + element->sinkID = routingData.data.sink->sinkID; + element->connectionFormat = CF_UNKNOWN; + } + } + }); - for (auto it = paths.begin(); successCount < mMaxPathCount && it != paths.end(); it++) + for (auto it = paths.begin(); successCount < mMaxPathCount && it != paths.end(); it++) + { + if (cfPermutationsForPath(*it, resultNodesPath[it - paths.begin()], resultPath) == E_UNKNOWN) { - if (cfPermutationsForPath(*it, resultNodesPath[it - paths.begin()], resultPath) == E_UNKNOWN) - errorsCount++; - else - successCount++; + errorsCount++; } + else + { + successCount++; + } + } - if (successCount) - return E_OK; - if (errorsCount) - return E_NOT_POSSIBLE; + if (successCount) + { return E_OK; } + if (errorsCount) + { + return E_NOT_POSSIBLE; + } + + return E_OK; +} + } diff --git a/AudioManagerCore/src/CAmRoutingReceiver.cpp b/AudioManagerCore/src/CAmRoutingReceiver.cpp index b3815cd..f372df9 100644 --- a/AudioManagerCore/src/CAmRoutingReceiver.cpp +++ b/AudioManagerCore/src/CAmRoutingReceiver.cpp @@ -30,50 +30,50 @@ #include "CAmDltWrapper.h" #include "CAmSocketHandler.h" -#define __METHOD_NAME__ std::string (std::string("CAmRoutingReceiver::") + __func__) +#define __METHOD_NAME__ std::string(std::string("CAmRoutingReceiver::") + __func__) namespace am { -CAmRoutingReceiver::CAmRoutingReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler) : - mpDatabaseHandler(iDatabaseHandler), - mpRoutingSender(iRoutingSender), - mpControlSender(iControlSender), - mpSocketHandler(iSocketHandler), - mpDBusWrapper(NULL), - mListStartupHandles(), - mListRundownHandles(), - handleCount(0), - mWaitStartup(false), - mWaitRundown(false), - mLastStartupError(E_OK), - mLastRundownError(E_OK) -{ - assert(mpDatabaseHandler!=NULL); - assert(mpRoutingSender!=NULL); - assert(mpControlSender!=NULL); - assert(mpSocketHandler!=NULL); -} - -CAmRoutingReceiver::CAmRoutingReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper) : - mpDatabaseHandler(iDatabaseHandler), - mpRoutingSender(iRoutingSender), - mpControlSender(iControlSender), - mpSocketHandler(iSocketHandler), - mpDBusWrapper(iDBusWrapper), - mListStartupHandles(), - mListRundownHandles(), - handleCount(0), - mWaitStartup(false), - mWaitRundown(false), - mLastStartupError(E_OK), - mLastRundownError(E_OK) -{ - assert(mpDatabaseHandler!=NULL); - assert(mpRoutingSender!=NULL); - assert(mpControlSender!=NULL); - assert(mpSocketHandler!=NULL); - assert(mpDBusWrapper!=NULL); +CAmRoutingReceiver::CAmRoutingReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler) + : mpDatabaseHandler(iDatabaseHandler) + , mpRoutingSender(iRoutingSender) + , mpControlSender(iControlSender) + , mpSocketHandler(iSocketHandler) + , mpDBusWrapper(NULL) + , mListStartupHandles() + , mListRundownHandles() + , handleCount(0) + , mWaitStartup(false) + , mWaitRundown(false) + , mLastStartupError(E_OK) + , mLastRundownError(E_OK) +{ + assert(mpDatabaseHandler != NULL); + assert(mpRoutingSender != NULL); + assert(mpControlSender != NULL); + assert(mpSocketHandler != NULL); +} + +CAmRoutingReceiver::CAmRoutingReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper) + : mpDatabaseHandler(iDatabaseHandler) + , mpRoutingSender(iRoutingSender) + , mpControlSender(iControlSender) + , mpSocketHandler(iSocketHandler) + , mpDBusWrapper(iDBusWrapper) + , mListStartupHandles() + , mListRundownHandles() + , handleCount(0) + , mWaitStartup(false) + , mWaitRundown(false) + , mLastStartupError(E_OK) + , mLastRundownError(E_OK) +{ + assert(mpDatabaseHandler != NULL); + assert(mpRoutingSender != NULL); + assert(mpControlSender != NULL); + assert(mpSocketHandler != NULL); + assert(mpDBusWrapper != NULL); } CAmRoutingReceiver::~CAmRoutingReceiver() @@ -88,138 +88,142 @@ void CAmRoutingReceiver::handleCallback(const am_Handle_s handle, const am_Error } else { - mpRoutingSender->removeHandle(handle); - } + mpRoutingSender->removeHandle(handle); + } } void CAmRoutingReceiver::ackConnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_Error_e error) { - logInfo(__METHOD_NAME__,"handle=",handle,"connectionID=",connectionID,"error=",error); + logInfo(__METHOD_NAME__, "handle=", handle, "connectionID=", connectionID, "error=", error); if (error == am_Error_e::E_OK) { mpRoutingSender->writeToDatabaseAndRemove(handle); } else { - //only remove connection of handle was found - if(mpRoutingSender->removeHandle(handle)==0) - { - mpDatabaseHandler->removeConnection(connectionID); - mpRoutingSender->removeConnectionLookup(connectionID); - } + // only remove connection of handle was found + if (mpRoutingSender->removeHandle(handle) == 0) + { + mpDatabaseHandler->removeConnection(connectionID); + mpRoutingSender->removeConnectionLookup(connectionID); + } } + mpControlSender->cbAckConnect(handle, error); } void CAmRoutingReceiver::ackDisconnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_Error_e error) { - logInfo(__METHOD_NAME__,"handle=",handle,"connectionID=",connectionID,"error=",error); - //only remove connection of handle was found - if(mpRoutingSender->removeHandle(handle) == 0) - { - mpRoutingSender->removeConnectionLookup(connectionID); - } + logInfo(__METHOD_NAME__, "handle=", handle, "connectionID=", connectionID, "error=", error); + // only remove connection of handle was found + if (mpRoutingSender->removeHandle(handle) == 0) + { + mpRoutingSender->removeConnectionLookup(connectionID); + } + mpControlSender->cbAckDisconnect(handle, error); } void CAmRoutingReceiver::ackSetSinkVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error) { - logInfo(__METHOD_NAME__,"handle=",handle,"volume=",volume,"error=",error); - if(error == E_OK) + logInfo(__METHOD_NAME__, "handle=", handle, "volume=", volume, "error=", error); + if (error == E_OK) { - mpRoutingSender->checkVolume(handle,volume); - } - - if (error== am_Error_e::E_OK || error== am_Error_e::E_ABORTED) + mpRoutingSender->checkVolume(handle, volume); + } + + if (error == am_Error_e::E_OK || error == am_Error_e::E_ABORTED) { - mpRoutingSender->writeToDatabaseAndRemove(handle); + mpRoutingSender->writeToDatabaseAndRemove(handle); } else { - mpRoutingSender->removeHandle(handle); - } + mpRoutingSender->removeHandle(handle); + } + mpControlSender->cbAckSetSinkVolumeChange(handle, volume, error); } void CAmRoutingReceiver::ackSetSourceVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error) { - logInfo(__METHOD_NAME__,"handle=",handle,"volume=",volume,"error=",error); - if(error == E_OK) + logInfo(__METHOD_NAME__, "handle=", handle, "volume=", volume, "error=", error); + if (error == E_OK) { - mpRoutingSender->checkVolume(handle,volume); + mpRoutingSender->checkVolume(handle, volume); } - if (error== am_Error_e::E_OK || error== am_Error_e::E_ABORTED) + if (error == am_Error_e::E_OK || error == am_Error_e::E_ABORTED) { - mpRoutingSender->writeToDatabaseAndRemove(handle); + mpRoutingSender->writeToDatabaseAndRemove(handle); } else { - mpRoutingSender->removeHandle(handle); - } + mpRoutingSender->removeHandle(handle); + } + mpControlSender->cbAckSetSourceVolumeChange(handle, volume, error); } void CAmRoutingReceiver::ackSetSourceState(const am_Handle_s handle, const am_Error_e error) { - logInfo(__METHOD_NAME__,"handle=",handle,"error=",error); - handleCallback(handle,error); + logInfo(__METHOD_NAME__, "handle=", handle, "error=", error); + handleCallback(handle, error); mpControlSender->cbAckSetSourceState(handle, error); } void CAmRoutingReceiver::ackSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error) { - logInfo(__METHOD_NAME__,"handle=",handle,"error=",error); - handleCallback(handle,error); + logInfo(__METHOD_NAME__, "handle=", handle, "error=", error); + handleCallback(handle, error); mpControlSender->cbAckSetSinkSoundProperty(handle, error); } void am::CAmRoutingReceiver::ackSetSinkSoundProperties(const am_Handle_s handle, const am_Error_e error) { - logInfo(__METHOD_NAME__,"handle=",handle,"error=",error); - handleCallback(handle,error); + logInfo(__METHOD_NAME__, "handle=", handle, "error=", error); + handleCallback(handle, error); mpControlSender->cbAckSetSinkSoundProperties(handle, error); } void CAmRoutingReceiver::ackSetSourceSoundProperty(const am_Handle_s handle, const am_Error_e error) { - logInfo(__METHOD_NAME__,"handle=",handle,"error=",error); - handleCallback(handle,error); + logInfo(__METHOD_NAME__, "handle=", handle, "error=", error); + handleCallback(handle, error); mpControlSender->cbAckSetSourceSoundProperty(handle, error); } void am::CAmRoutingReceiver::ackSetSourceSoundProperties(const am_Handle_s handle, const am_Error_e error) { - logInfo(__METHOD_NAME__,"handle=",handle,"error=",error); - handleCallback(handle,error); + logInfo(__METHOD_NAME__, "handle=", handle, "error=", error); + handleCallback(handle, error); mpControlSender->cbAckSetSourceSoundProperties(handle, error); } void CAmRoutingReceiver::ackCrossFading(const am_Handle_s handle, const am_HotSink_e hotSink, const am_Error_e error) { - logInfo(__METHOD_NAME__,"handle=",handle,"hotsink=",hotSink,"error=",error); - handleCallback(handle,error); + logInfo(__METHOD_NAME__, "handle=", handle, "hotsink=", hotSink, "error=", error); + handleCallback(handle, error); mpControlSender->cbAckCrossFade(handle, hotSink, error); } void CAmRoutingReceiver::ackSourceVolumeTick(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume) { - logInfo(__METHOD_NAME__,"handle=",handle,"sourceID=",sourceID,"volume=",volume); + logInfo(__METHOD_NAME__, "handle=", handle, "sourceID=", sourceID, "volume=", volume); mpControlSender->hookSystemSourceVolumeTick(handle, sourceID, volume); } void CAmRoutingReceiver::ackSinkVolumeTick(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume) { - logInfo(__METHOD_NAME__,"handle=",handle,"sinkID=",sinkID,"volume=",volume); + logInfo(__METHOD_NAME__, "handle=", handle, "sinkID=", sinkID, "volume=", volume); mpControlSender->hookSystemSinkVolumeTick(handle, sinkID, volume); } -am_Error_e CAmRoutingReceiver::peekDomain(const std::string & name, am_domainID_t & domainID) -{ +am_Error_e CAmRoutingReceiver::peekDomain(const std::string &name, am_domainID_t &domainID) +{ return (mpDatabaseHandler->peekDomain(name, domainID)); } -am_Error_e CAmRoutingReceiver::registerDomain(const am_Domain_s & domainData, am_domainID_t & domainID) +am_Error_e CAmRoutingReceiver::registerDomain(const am_Domain_s &domainData, am_domainID_t &domainID) { return (mpControlSender->hookSystemRegisterDomain(domainData, domainID)); } @@ -229,14 +233,14 @@ am_Error_e CAmRoutingReceiver::deregisterDomain(const am_domainID_t domainID) return (mpControlSender->hookSystemDeregisterDomain(domainID)); } -am_Error_e CAmRoutingReceiver::registerGateway(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID) +am_Error_e CAmRoutingReceiver::registerGateway(const am_Gateway_s &gatewayData, am_gatewayID_t &gatewayID) { return (mpControlSender->hookSystemRegisterGateway(gatewayData, gatewayID)); } -am_Error_e CAmRoutingReceiver::registerConverter(const am_Converter_s& converterData, am_converterID_t& converterID) +am_Error_e CAmRoutingReceiver::registerConverter(const am_Converter_s &converterData, am_converterID_t &converterID) { - return (mpControlSender->hookSystemRegisterConverter(converterData, converterID)); + return (mpControlSender->hookSystemRegisterConverter(converterData, converterID)); } am_Error_e CAmRoutingReceiver::deregisterGateway(const am_gatewayID_t gatewayID) @@ -244,17 +248,17 @@ am_Error_e CAmRoutingReceiver::deregisterGateway(const am_gatewayID_t gatewayID) return (mpControlSender->hookSystemDeregisterGateway(gatewayID)); } -am_Error_e CAmRoutingReceiver::deregisterConverter(const am_converterID_t converterID) +am_Error_e CAmRoutingReceiver::deregisterConverter(const am_converterID_t converterID) { - return (mpControlSender->hookSystemDeregisterConverter(converterID)); + return (mpControlSender->hookSystemDeregisterConverter(converterID)); } -am_Error_e CAmRoutingReceiver::peekSink(const std::string& name, am_sinkID_t & sinkID) +am_Error_e CAmRoutingReceiver::peekSink(const std::string &name, am_sinkID_t &sinkID) { return (mpDatabaseHandler->peekSink(name, sinkID)); } -am_Error_e CAmRoutingReceiver::registerSink(const am_Sink_s & sinkData, am_sinkID_t & sinkID) +am_Error_e CAmRoutingReceiver::registerSink(const am_Sink_s &sinkData, am_sinkID_t &sinkID) { return (mpControlSender->hookSystemRegisterSink(sinkData, sinkID)); } @@ -264,12 +268,12 @@ am_Error_e CAmRoutingReceiver::deregisterSink(const am_sinkID_t sinkID) return (mpControlSender->hookSystemDeregisterSink(sinkID)); } -am_Error_e CAmRoutingReceiver::peekSource(const std::string & name, am_sourceID_t & sourceID) +am_Error_e CAmRoutingReceiver::peekSource(const std::string &name, am_sourceID_t &sourceID) { return (mpDatabaseHandler->peekSource(name, sourceID)); } -am_Error_e CAmRoutingReceiver::registerSource(const am_Source_s & sourceData, am_sourceID_t & sourceID) +am_Error_e CAmRoutingReceiver::registerSource(const am_Source_s &sourceData, am_sourceID_t &sourceID) { return (mpControlSender->hookSystemRegisterSource(sourceData, sourceID)); } @@ -279,7 +283,7 @@ am_Error_e CAmRoutingReceiver::deregisterSource(const am_sourceID_t sourceID) return (mpControlSender->hookSystemDeregisterSource(sourceID)); } -am_Error_e CAmRoutingReceiver::registerCrossfader(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID) +am_Error_e CAmRoutingReceiver::registerCrossfader(const am_Crossfader_s &crossfaderData, am_crossfaderID_t &crossfaderID) { return (mpControlSender->hookSystemRegisterCrossfader(crossfaderData, crossfaderID)); } @@ -304,12 +308,12 @@ void CAmRoutingReceiver::hookDomainRegistrationComplete(const am_domainID_t doma mpControlSender->hookSystemDomainRegistrationComplete(domainID); } -void CAmRoutingReceiver::hookSinkAvailablityStatusChange(const am_sinkID_t sinkID, const am_Availability_s & availability) +void CAmRoutingReceiver::hookSinkAvailablityStatusChange(const am_sinkID_t sinkID, const am_Availability_s &availability) { mpControlSender->hookSystemSinkAvailablityStateChange(sinkID, availability); } -void CAmRoutingReceiver::hookSourceAvailablityStatusChange(const am_sourceID_t sourceID, const am_Availability_s & availability) +void CAmRoutingReceiver::hookSourceAvailablityStatusChange(const am_sourceID_t sourceID, const am_Availability_s &availability) { mpControlSender->hookSystemSourceAvailablityStateChange(sourceID, availability); } @@ -322,157 +326,167 @@ void CAmRoutingReceiver::hookDomainStateChange(const am_domainID_t domainID, con void CAmRoutingReceiver::hookTimingInformationChanged(const am_connectionID_t connectionID, const am_timeSync_t delay) { mpDatabaseHandler->changeConnectionTimingInformation(connectionID, delay); - mpControlSender->hookSystemSingleTimingInformationChanged(connectionID,delay); + mpControlSender->hookSystemSingleTimingInformationChanged(connectionID, delay); } -void CAmRoutingReceiver::sendChangedData(const std::vector & earlyData) +void CAmRoutingReceiver::sendChangedData(const std::vector &earlyData) { mpControlSender->hookSystemReceiveEarlyData(earlyData); } -am_Error_e CAmRoutingReceiver::peekSinkClassID(const std::string& name, am_sinkClass_t& sinkClassID) +am_Error_e CAmRoutingReceiver::peekSinkClassID(const std::string &name, am_sinkClass_t &sinkClassID) { return (mpDatabaseHandler->peekSinkClassID(name, sinkClassID)); } -am_Error_e CAmRoutingReceiver::peekSourceClassID(const std::string& name, am_sourceClass_t& sourceClassID) +am_Error_e CAmRoutingReceiver::peekSourceClassID(const std::string &name, am_sourceClass_t &sourceClassID) { return (mpDatabaseHandler->peekSourceClassID(name, sourceClassID)); } #ifdef WITH_DBUS_WRAPPER -am_Error_e CAmRoutingReceiver::getDBusConnectionWrapper(CAmDbusWrapper *& dbusConnectionWrapper) const +am_Error_e CAmRoutingReceiver::getDBusConnectionWrapper(CAmDbusWrapper * &dbusConnectionWrapper) const { dbusConnectionWrapper = mpDBusWrapper; return (E_OK); #else -am_Error_e CAmRoutingReceiver::getDBusConnectionWrapper(CAmDbusWrapper *& ) const +am_Error_e CAmRoutingReceiver::getDBusConnectionWrapper(CAmDbusWrapper * &) const { return (E_UNKNOWN); -#endif +#endif // ifdef WITH_DBUS_WRAPPER } -am_Error_e CAmRoutingReceiver::getSocketHandler(CAmSocketHandler *& socketHandler) const +am_Error_e CAmRoutingReceiver::getSocketHandler(CAmSocketHandler * &socketHandler) const { socketHandler = mpSocketHandler; return (E_OK); } -void CAmRoutingReceiver::getInterfaceVersion(std::string & version) const +void CAmRoutingReceiver::getInterfaceVersion(std::string &version) const { version = RoutingVersion; } -void CAmRoutingReceiver::confirmRoutingReady(const uint16_t handle, const am_Error_e error) +void CAmRoutingReceiver::confirmRoutingReady(const uint16_t handle, const am_Error_e error) { - if (error!=E_OK) - mLastStartupError=error; + if (error != E_OK) + { + mLastStartupError = error; + } + mListStartupHandles.erase(std::remove(mListStartupHandles.begin(), mListStartupHandles.end(), handle), mListStartupHandles.end()); if (mWaitStartup && mListStartupHandles.empty()) + { mpControlSender->confirmRoutingReady(mLastStartupError); + } } void CAmRoutingReceiver::confirmRoutingRundown(const uint16_t handle, const am_Error_e error) { - if (error!=E_OK) - mLastRundownError=error; + if (error != E_OK) + { + mLastRundownError = error; + } + mListRundownHandles.erase(std::remove(mListRundownHandles.begin(), mListRundownHandles.end(), handle), mListRundownHandles.end()); if (mWaitRundown && mListRundownHandles.empty()) + { mpControlSender->confirmRoutingRundown(mLastRundownError); + } } uint16_t am::CAmRoutingReceiver::getStartupHandle() { - uint16_t handle = ++handleCount; //todo: handle overflow + uint16_t handle = ++handleCount; // todo: handle overflow mListStartupHandles.push_back(handle); return (handle); } uint16_t am::CAmRoutingReceiver::getRundownHandle() { - uint16_t handle = ++handleCount; //todo: handle overflow + uint16_t handle = ++handleCount; // todo: handle overflow mListRundownHandles.push_back(handle); return (handle); } void am::CAmRoutingReceiver::waitOnStartup(bool startup) { - mWaitStartup = startup; - mLastStartupError=E_OK; + mWaitStartup = startup; + mLastStartupError = E_OK; } void CAmRoutingReceiver::ackSinkNotificationConfiguration(const am_Handle_s handle, const am_Error_e error) { - logInfo(__METHOD_NAME__,"handle=",handle,"error=",error); - handleCallback(handle,error); - mpControlSender->cbAckSetSinkNotificationConfiguration(handle,error); + logInfo(__METHOD_NAME__, "handle=", handle, "error=", error); + handleCallback(handle, error); + mpControlSender->cbAckSetSinkNotificationConfiguration(handle, error); } void CAmRoutingReceiver::ackSourceNotificationConfiguration(const am_Handle_s handle, const am_Error_e error) { - logInfo(__METHOD_NAME__,"handle=",handle,"error=",error); - handleCallback(handle,error); - mpControlSender->cbAckSetSourceNotificationConfiguration(handle,error); + logInfo(__METHOD_NAME__, "handle=", handle, "error=", error); + handleCallback(handle, error); + mpControlSender->cbAckSetSourceNotificationConfiguration(handle, error); } -am_Error_e CAmRoutingReceiver::updateGateway(const am_gatewayID_t gatewayID, const std::vector& listSourceFormats, const std::vector& listSinkFormats, const std::vector& convertionMatrix) +am_Error_e CAmRoutingReceiver::updateGateway(const am_gatewayID_t gatewayID, const std::vector &listSourceFormats, const std::vector &listSinkFormats, const std::vector &convertionMatrix) { - return (mpControlSender->hookSystemUpdateGateway(gatewayID,listSourceFormats,listSinkFormats,convertionMatrix)); + return (mpControlSender->hookSystemUpdateGateway(gatewayID, listSourceFormats, listSinkFormats, convertionMatrix)); } -am_Error_e CAmRoutingReceiver::updateConverter(const am_converterID_t converterID, const std::vector& listSourceFormats, const std::vector& listSinkFormats, const std::vector& convertionMatrix) +am_Error_e CAmRoutingReceiver::updateConverter(const am_converterID_t converterID, const std::vector &listSourceFormats, const std::vector &listSinkFormats, const std::vector &convertionMatrix) { - return (mpControlSender->hookSystemUpdateConverter(converterID,listSourceFormats,listSinkFormats,convertionMatrix)); + return (mpControlSender->hookSystemUpdateConverter(converterID, listSourceFormats, listSinkFormats, convertionMatrix)); } -am_Error_e CAmRoutingReceiver::updateSink(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector& listSoundProperties, const std::vector& listConnectionFormats, const std::vector& listMainSoundProperties) +am_Error_e CAmRoutingReceiver::updateSink(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector &listSoundProperties, const std::vector &listConnectionFormats, const std::vector &listMainSoundProperties) { - return (mpControlSender->hookSystemUpdateSink(sinkID,sinkClassID,listSoundProperties,listConnectionFormats,listMainSoundProperties)); + return (mpControlSender->hookSystemUpdateSink(sinkID, sinkClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties)); } -am_Error_e CAmRoutingReceiver::updateSource(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector& listSoundProperties, const std::vector& listConnectionFormats, const std::vector& listMainSoundProperties) +am_Error_e CAmRoutingReceiver::updateSource(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector &listSoundProperties, const std::vector &listConnectionFormats, const std::vector &listMainSoundProperties) { - return (mpControlSender->hookSystemUpdateSource(sourceID,sourceClassID,listSoundProperties,listConnectionFormats,listMainSoundProperties)); + return (mpControlSender->hookSystemUpdateSource(sourceID, sourceClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties)); } -void CAmRoutingReceiver::ackSetVolumes(const am_Handle_s handle, const std::vector& listvolumes, const am_Error_e error) +void CAmRoutingReceiver::ackSetVolumes(const am_Handle_s handle, const std::vector &listvolumes, const am_Error_e error) { - logInfo(__METHOD_NAME__,"handle=",handle,"error=",error); - handleCallback(handle,error); - mpControlSender->cbAckSetVolume(handle,listvolumes,error); + logInfo(__METHOD_NAME__, "handle=", handle, "error=", error); + handleCallback(handle, error); + mpControlSender->cbAckSetVolume(handle, listvolumes, error); } -void CAmRoutingReceiver::hookSinkNotificationDataChange(const am_sinkID_t sinkID, const am_NotificationPayload_s& payload) +void CAmRoutingReceiver::hookSinkNotificationDataChange(const am_sinkID_t sinkID, const am_NotificationPayload_s &payload) { - logInfo(__METHOD_NAME__,"sinkID=",sinkID,"type=",payload.type,"notificationValue=",payload.value); - mpControlSender->hookSinkNotificationDataChanged(sinkID,payload); + logInfo(__METHOD_NAME__, "sinkID=", sinkID, "type=", payload.type, "notificationValue=", payload.value); + mpControlSender->hookSinkNotificationDataChanged(sinkID, payload); } -void CAmRoutingReceiver::hookSourceNotificationDataChange(const am_sourceID_t sourceID, const am_NotificationPayload_s& payload) +void CAmRoutingReceiver::hookSourceNotificationDataChange(const am_sourceID_t sourceID, const am_NotificationPayload_s &payload) { - logInfo(__METHOD_NAME__,"sinkID=",sourceID,"type=",payload.type,"notificationValue=",payload.value); - mpControlSender->hookSourceNotificationDataChanged(sourceID,payload); + logInfo(__METHOD_NAME__, "sinkID=", sourceID, "type=", payload.type, "notificationValue=", payload.value); + mpControlSender->hookSourceNotificationDataChanged(sourceID, payload); } -am_Error_e CAmRoutingReceiver::getDomainOfSink(const am_sinkID_t sinkID, am_domainID_t& domainID) const +am_Error_e CAmRoutingReceiver::getDomainOfSink(const am_sinkID_t sinkID, am_domainID_t &domainID) const { - return (mpDatabaseHandler->getDomainOfSink(sinkID,domainID)); + return (mpDatabaseHandler->getDomainOfSink(sinkID, domainID)); } -am_Error_e CAmRoutingReceiver::getDomainOfSource(const am_sourceID_t sourceID, am_domainID_t& domainID) const +am_Error_e CAmRoutingReceiver::getDomainOfSource(const am_sourceID_t sourceID, am_domainID_t &domainID) const { - return (mpDatabaseHandler->getDomainOfSource(sourceID,domainID)); + return (mpDatabaseHandler->getDomainOfSource(sourceID, domainID)); } -am_Error_e CAmRoutingReceiver::getDomainOfCrossfader(const am_crossfaderID_t crossfader, am_domainID_t& domainID) const +am_Error_e CAmRoutingReceiver::getDomainOfCrossfader(const am_crossfaderID_t crossfader, am_domainID_t &domainID) const { - return (mpDatabaseHandler->getDomainOfCrossfader(crossfader,domainID)); + return (mpDatabaseHandler->getDomainOfCrossfader(crossfader, domainID)); } void CAmRoutingReceiver::waitOnRundown(bool rundown) { - mWaitRundown = rundown; - mLastRundownError=E_OK; + mWaitRundown = rundown; + mLastRundownError = E_OK; } } diff --git a/AudioManagerCore/src/CAmRoutingSender.cpp b/AudioManagerCore/src/CAmRoutingSender.cpp index 9c6e658..cb66fe9 100644 --- a/AudioManagerCore/src/CAmRoutingSender.cpp +++ b/AudioManagerCore/src/CAmRoutingSender.cpp @@ -40,78 +40,79 @@ namespace am { -#define REQUIRED_INTERFACE_VERSION_MAJOR 1 //!< major interface version. All versions smaller than this will be rejected +#define REQUIRED_INTERFACE_VERSION_MAJOR 1 //!< major interface version. All versions smaller than this will be rejected #define REQUIRED_INTERFACE_VERSION_MINOR 0 //!< minor interface version. All versions smaller than this will be rejected -#define __METHOD_NAME__ std::string (std::string("CAmRoutingSender::") + __func__) +#define __METHOD_NAME__ std::string(std::string("CAmRoutingSender::") + __func__) CAmRoutingSender::CAmRoutingSender( - const std::vector& listOfPluginDirectories, - IAmDatabaseHandler* databaseHandler) : - mHandleCount(0), - mlistActiveHandles(), - mListInterfaces(), - mMapConnectionInterface(), - mMapCrossfaderInterface(), - mMapDomainInterface(), - mMapSinkInterface(), - mMapSourceInterface(), - mpRoutingReceiver(), - mpDatabaseHandler(databaseHandler) { + const std::vector &listOfPluginDirectories, + IAmDatabaseHandler *databaseHandler) + : mHandleCount(0) + , mlistActiveHandles() + , mListInterfaces() + , mMapConnectionInterface() + , mMapCrossfaderInterface() + , mMapDomainInterface() + , mMapSinkInterface() + , mMapSourceInterface() + , mpRoutingReceiver() + , mpDatabaseHandler(databaseHandler) +{ loadPlugins(listOfPluginDirectories); - dboNewSink = [&](const am_Sink_s& sink) { - addSinkLookup(sink); - }; - dboNewSource = [&](const am_Source_s& source) { - addSourceLookup(source); - }; - dboNewDomain = [&](const am_Domain_s& domain) { - addDomainLookup(domain); - }; - //todo: newGateway implement something - //todo: newConverter implement something - dboNewCrossfader = [&](const am_Crossfader_s& crossfader) { - addCrossfaderLookup(crossfader); - }; + dboNewSink = [&](const am_Sink_s &sink) { + addSinkLookup(sink); + }; + dboNewSource = [&](const am_Source_s &source) { + addSourceLookup(source); + }; + dboNewDomain = [&](const am_Domain_s &domain) { + addDomainLookup(domain); + }; + // todo: newGateway implement something + // todo: newConverter implement something + dboNewCrossfader = [&](const am_Crossfader_s &crossfader) { + addCrossfaderLookup(crossfader); + }; dboRemovedSink = [&](const am_sinkID_t sinkID, const bool visible) { - removeSinkLookup(sinkID); - }; + removeSinkLookup(sinkID); + }; dboRemovedSource = [&](const am_sourceID_t sourceID, const bool visible) { - removeSourceLookup(sourceID); - }; + removeSourceLookup(sourceID); + }; dboRemoveDomain = [&](const am_domainID_t domainID) { - removeDomainLookup(domainID); - }; - //todo: removeGateway implement something - //todo: removeConverter implement something + removeDomainLookup(domainID); + }; + // todo: removeGateway implement something + // todo: removeConverter implement something dboRemoveCrossfader = [&](const am_crossfaderID_t crossfaderID) { - removeCrossfaderLookup(crossfaderID); - }; + removeCrossfaderLookup(crossfaderID); + }; } -void CAmRoutingSender::loadPlugins(const std::vector& listOfPluginDirectories) +void CAmRoutingSender::loadPlugins(const std::vector &listOfPluginDirectories) { if (listOfPluginDirectories.empty()) { - logError(__METHOD_NAME__,"List of routingplugins is empty"); + logError(__METHOD_NAME__, "List of routingplugins is empty"); } - std::vector sharedLibraryNameList; - std::vector::const_iterator dirIter = listOfPluginDirectories.begin(); + std::vector sharedLibraryNameList; + std::vector::const_iterator dirIter = listOfPluginDirectories.begin(); std::vector::const_iterator dirIterEnd = listOfPluginDirectories.end(); // search communicator plugins in configured directories for (; dirIter < dirIterEnd; ++dirIter) { - const char* directoryName = dirIter->c_str(); - logInfo(__METHOD_NAME__,"Searching for HookPlugins in", directoryName); + const char *directoryName = dirIter->c_str(); + logInfo(__METHOD_NAME__, "Searching for HookPlugins in", directoryName); DIR *directory = opendir(directoryName); if (!directory) { - logError(__METHOD_NAME__,"Error opening directory: ", directoryName); + logError(__METHOD_NAME__, "Error opening directory: ", directoryName); continue; } @@ -120,10 +121,10 @@ void CAmRoutingSender::loadPlugins(const std::vector& listOfPluginD while ((itemInDirectory = readdir(directory))) { unsigned char entryType = itemInDirectory->d_type; - std::string entryName = itemInDirectory->d_name; - std::string fullName = *dirIter + "/" + entryName; + std::string entryName = itemInDirectory->d_name; + std::string fullName = *dirIter + "/" + entryName; - bool regularFile = (entryType == DT_REG || entryType == DT_LNK); + bool regularFile = (entryType == DT_REG || entryType == DT_LNK); bool sharedLibExtension = ("so" == entryName.substr(entryName.find_last_of(".") + 1)); // Handle cases where readdir() could not determine the file type @@ -133,7 +134,7 @@ void CAmRoutingSender::loadPlugins(const std::vector& listOfPluginD if (stat(fullName.c_str(), &buf)) { - logInfo(__METHOD_NAME__,"Failed to stat file: ", entryName, errno); + logInfo(__METHOD_NAME__, "Failed to stat file: ", entryName, errno); continue; } @@ -142,7 +143,7 @@ void CAmRoutingSender::loadPlugins(const std::vector& listOfPluginD if (regularFile && sharedLibExtension) { - logInfo(__METHOD_NAME__,"adding file: ", entryName); + logInfo(__METHOD_NAME__, "adding file: ", entryName); std::string name(directoryName); sharedLibraryNameList.push_back(name + "/" + entryName); } @@ -156,28 +157,28 @@ void CAmRoutingSender::loadPlugins(const std::vector& listOfPluginD } // iterate all communicator plugins and start them - std::vector::iterator iter = sharedLibraryNameList.begin(); + std::vector::iterator iter = sharedLibraryNameList.begin(); std::vector::iterator iterEnd = sharedLibraryNameList.end(); for (; iter != iterEnd; ++iter) { - logInfo(__METHOD_NAME__,"try loading: ", *iter); + logInfo(__METHOD_NAME__, "try loading: ", *iter); - IAmRoutingSend* (*createFunc)(); - void* tempLibHandle = NULL; - createFunc = getCreateFunction(*iter, tempLibHandle); + IAmRoutingSend *(*createFunc)(); + void *tempLibHandle = NULL; + createFunc = getCreateFunction(*iter, tempLibHandle); if (!createFunc) { - logError(__METHOD_NAME__,"Entry point of RoutingPlugin not found"); + logError(__METHOD_NAME__, "Entry point of RoutingPlugin not found"); continue; } - IAmRoutingSend* router = createFunc(); + IAmRoutingSend *router = createFunc(); if (!router) { - logError(__METHOD_NAME__,"initialization of plugin ",*iter,"failed. Entry Function not callable"); + logError(__METHOD_NAME__, "initialization of plugin ", *iter, "failed. Entry Function not callable"); dlclose(tempLibHandle); continue; } @@ -185,7 +186,7 @@ void CAmRoutingSender::loadPlugins(const std::vector& listOfPluginD InterfaceNamePairs routerInterface; routerInterface.routingInterface = router; - //check libversion + // check libversion std::string version, cVersion(RoutingVersion); router->getInterfaceVersion(version); uint16_t minorVersion, majorVersion, cMinorVersion, cMajorVersion; @@ -196,12 +197,12 @@ void CAmRoutingSender::loadPlugins(const std::vector& listOfPluginD if (majorVersion < cMajorVersion || ((majorVersion == cMajorVersion) && (minorVersion > cMinorVersion))) { - logError(__METHOD_NAME__,"Routing initialization failed. Version of Interface to old"); + logError(__METHOD_NAME__, "Routing initialization failed. Version of Interface to old"); dlclose(tempLibHandle); continue; } - //here, the busname is saved together with the interface. Later The domains will register with the name and sinks, sources etc with the domain.... + // here, the busname is saved together with the interface. Later The domains will register with the name and sinks, sources etc with the domain.... router->returnBusName(routerInterface.busName); assert(!routerInterface.busName.empty()); mListInterfaces.push_back(routerInterface); @@ -211,13 +212,13 @@ void CAmRoutingSender::loadPlugins(const std::vector& listOfPluginD CAmRoutingSender::~CAmRoutingSender() { - //unloadLibraries(); + // unloadLibraries(); HandlesMap::iterator it = mlistActiveHandles.begin(); - //every open handle is assumed to be an error... + // every open handle is assumed to be an error... for (; it != mlistActiveHandles.end(); ++it) { - logError(__METHOD_NAME__,"The action for the handle",it->first,"is still open"); + logError(__METHOD_NAME__, "The action for the handle", it->first, "is still open"); } } @@ -226,7 +227,7 @@ am_Error_e CAmRoutingSender::startupInterfaces(CAmRoutingReceiver *iRoutingRecei mpRoutingReceiver = iRoutingReceiver; am_Error_e returnError = E_OK; - std::vector::iterator iter = mListInterfaces.begin(); + std::vector::iterator iter = mListInterfaces.begin(); std::vector::iterator iterEnd = mListInterfaces.end(); for (; iter < iterEnd; ++iter) { @@ -236,410 +237,428 @@ am_Error_e CAmRoutingSender::startupInterfaces(CAmRoutingReceiver *iRoutingRecei returnError = error; } } + return (returnError); } -am_Error_e CAmRoutingSender::asyncAbort(const am_Handle_s& handle) +am_Error_e CAmRoutingSender::asyncAbort(const am_Handle_s &handle) { - auto iter (mlistActiveHandles.find(handle)); + auto iter(mlistActiveHandles.find(handle)); if (iter == mlistActiveHandles.end()) { - logError(__METHOD_NAME__,"Could not find handle",handle); - return (E_NON_EXISTENT); + logError(__METHOD_NAME__, "Could not find handle", handle); + return (E_NON_EXISTENT); } - logInfo(__METHOD_NAME__," handle", handle); - return (iter->second->returnInterface()->asyncAbort(handle)); + + logInfo(__METHOD_NAME__, " handle", handle); + return (iter->second->returnInterface()->asyncAbort(handle)); } -am_Error_e CAmRoutingSender::asyncConnect(am_Handle_s& handle, am_connectionID_t& connectionID, const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_CustomConnectionFormat_t connectionFormat) +am_Error_e CAmRoutingSender::asyncConnect(am_Handle_s &handle, am_connectionID_t &connectionID, const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_CustomConnectionFormat_t connectionFormat) { - auto iter (mMapSinkInterface.find(sinkID)); - if (iter == mMapSinkInterface.end()) - { - logError(__METHOD_NAME__,"Could not find sink",sinkID); - return (E_NON_EXISTENT); - } - - if(handleExists(handle)) - { - if (handle.handleType==am_Handle_e::H_CONNECT) - { - logInfo(__METHOD_NAME__,"Resending for handle",handle); - } - else - { - logError(__METHOD_NAME__,"Handle exists but wrong type",handle); - return(E_UNKNOWN); - } - } - else - { - - am_Connection_s tempConnection; - tempConnection.sinkID = sinkID; - tempConnection.sourceID = sourceID; - tempConnection.connectionFormat = connectionFormat; - tempConnection.connectionID = 0; - tempConnection.delay=-1; - - am_Error_e connError(mpDatabaseHandler->enterConnectionDB(tempConnection, connectionID)); - if (connError) - { - return(connError); - } - mMapConnectionInterface.insert(std::make_pair(connectionID, iter->second)); - auto handleData = std::make_shared(iter->second,connectionID,mpDatabaseHandler); - handle = createHandle(handleData, am_Handle_e::H_CONNECT); - } - - logInfo(__METHOD_NAME__,"connectionID=",connectionID,"connectionFormat=", connectionFormat, "sourceID=", sourceID, "sinkID=", sinkID,"handle=",handle); - am_Error_e syncError(iter->second->asyncConnect(handle, connectionID, sourceID, sinkID, connectionFormat)); - if (syncError) - { - removeHandle(handle); - logError(__METHOD_NAME__,"Error while calling connect connectionID:",connectionID,"sourceID:",sourceID,"sinkID:",sinkID,"connectionFormat:",connectionFormat,"handle",handle); - mpDatabaseHandler->removeConnection(connectionID); - } - return(syncError); + auto iter(mMapSinkInterface.find(sinkID)); + if (iter == mMapSinkInterface.end()) + { + logError(__METHOD_NAME__, "Could not find sink", sinkID); + return (E_NON_EXISTENT); + } + + if (handleExists(handle)) + { + if (handle.handleType == am_Handle_e::H_CONNECT) + { + logInfo(__METHOD_NAME__, "Resending for handle", handle); + } + else + { + logError(__METHOD_NAME__, "Handle exists but wrong type", handle); + return(E_UNKNOWN); + } + } + else + { + + am_Connection_s tempConnection; + tempConnection.sinkID = sinkID; + tempConnection.sourceID = sourceID; + tempConnection.connectionFormat = connectionFormat; + tempConnection.connectionID = 0; + tempConnection.delay = -1; + + am_Error_e connError(mpDatabaseHandler->enterConnectionDB(tempConnection, connectionID)); + if (connError) + { + return(connError); + } + + mMapConnectionInterface.insert(std::make_pair(connectionID, iter->second)); + auto handleData = std::make_shared(iter->second, connectionID, mpDatabaseHandler); + handle = createHandle(handleData, am_Handle_e::H_CONNECT); + } + + logInfo(__METHOD_NAME__, "connectionID=", connectionID, "connectionFormat=", connectionFormat, "sourceID=", sourceID, "sinkID=", sinkID, "handle=", handle); + am_Error_e syncError(iter->second->asyncConnect(handle, connectionID, sourceID, sinkID, connectionFormat)); + if (syncError) + { + removeHandle(handle); + logError(__METHOD_NAME__, "Error while calling connect connectionID:", connectionID, "sourceID:", sourceID, "sinkID:", sinkID, "connectionFormat:", connectionFormat, "handle", handle); + mpDatabaseHandler->removeConnection(connectionID); + } + + return(syncError); } -am_Error_e CAmRoutingSender::asyncDisconnect(am_Handle_s& handle, const am_connectionID_t connectionID) +am_Error_e CAmRoutingSender::asyncDisconnect(am_Handle_s &handle, const am_connectionID_t connectionID) { - auto iter(mMapConnectionInterface.find(connectionID)); - if (iter == mMapConnectionInterface.end()) - { - logError(__METHOD_NAME__,"Could not find connection",connectionID); - return (E_NON_EXISTENT); - } - - if(handleExists(handle)) - { - if (handle.handleType==am_Handle_e::H_DISCONNECT) - { - logInfo(__METHOD_NAME__,"Resending for handle",handle); - } - else - { - logError(__METHOD_NAME__,"Handle exists but wrong type",handle); - return(E_UNKNOWN); - } + auto iter(mMapConnectionInterface.find(connectionID)); + if (iter == mMapConnectionInterface.end()) + { + logError(__METHOD_NAME__, "Could not find connection", connectionID); + return (E_NON_EXISTENT); + } + + if (handleExists(handle)) + { + if (handle.handleType == am_Handle_e::H_DISCONNECT) + { + logInfo(__METHOD_NAME__, "Resending for handle", handle); + } + else + { + logError(__METHOD_NAME__, "Handle exists but wrong type", handle); + return(E_UNKNOWN); + } } else { - auto handleData = std::make_shared(iter->second,connectionID,mpDatabaseHandler,this); - handle = createHandle(handleData, am_Handle_e::H_DISCONNECT); - } - - logInfo(__METHOD_NAME__,"connectionID=", connectionID, "handle=",handle); - am_Error_e syncError(iter->second->asyncDisconnect(handle, connectionID)); - if (syncError) - { - removeHandle(handle); - logError(__METHOD_NAME__,"Error while calling disconnect connectionID:",connectionID,"handle",handle); - } - return(syncError); + auto handleData = std::make_shared(iter->second, connectionID, mpDatabaseHandler, this); + handle = createHandle(handleData, am_Handle_e::H_DISCONNECT); + } + + logInfo(__METHOD_NAME__, "connectionID=", connectionID, "handle=", handle); + am_Error_e syncError(iter->second->asyncDisconnect(handle, connectionID)); + if (syncError) + { + removeHandle(handle); + logError(__METHOD_NAME__, "Error while calling disconnect connectionID:", connectionID, "handle", handle); + } + + return(syncError); } -am_Error_e CAmRoutingSender::asyncSetSinkVolume(am_Handle_s& handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_CustomRampType_t ramp, const am_time_t time) +am_Error_e CAmRoutingSender::asyncSetSinkVolume(am_Handle_s &handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_CustomRampType_t ramp, const am_time_t time) { - auto iter (mMapSinkInterface.find(sinkID)); - if (iter == mMapSinkInterface.end()) - { - logError(__METHOD_NAME__,"Could not find sink",sinkID); - return (E_NON_EXISTENT); - } - - if(handleExists(handle)) - { - if (handle.handleType==am_Handle_e::H_SETSINKVOLUME) - { - logInfo(__METHOD_NAME__,"Resending for handle",handle); - } - else - { - logError(__METHOD_NAME__,"Handle exists but wrong type",handle); - return(E_UNKNOWN); - } - } - else - { - auto handleData = std::make_shared(iter->second,sinkID,mpDatabaseHandler,volume); + auto iter(mMapSinkInterface.find(sinkID)); + if (iter == mMapSinkInterface.end()) + { + logError(__METHOD_NAME__, "Could not find sink", sinkID); + return (E_NON_EXISTENT); + } + + if (handleExists(handle)) + { + if (handle.handleType == am_Handle_e::H_SETSINKVOLUME) + { + logInfo(__METHOD_NAME__, "Resending for handle", handle); + } + else + { + logError(__METHOD_NAME__, "Handle exists but wrong type", handle); + return(E_UNKNOWN); + } + } + else + { + auto handleData = std::make_shared(iter->second, sinkID, mpDatabaseHandler, volume); handle = createHandle(handleData, H_SETSINKVOLUME); } - - logInfo(__METHOD_NAME__,"sinkID=", sinkID, "volume=", volume, "ramp=", ramp, "time=", time,"handle=",handle); - am_Error_e syncError(iter->second->asyncSetSinkVolume(handle, sinkID, volume, ramp, time)); - if (syncError) - { - removeHandle(handle); - logError(__METHOD_NAME__,"Error while calling asyncSetSinkVolume sinkID:",sinkID,"handle:",handle,"volume:",volume,"ramp:",ramp,"time:",time); - } - return(syncError); + + logInfo(__METHOD_NAME__, "sinkID=", sinkID, "volume=", volume, "ramp=", ramp, "time=", time, "handle=", handle); + am_Error_e syncError(iter->second->asyncSetSinkVolume(handle, sinkID, volume, ramp, time)); + if (syncError) + { + removeHandle(handle); + logError(__METHOD_NAME__, "Error while calling asyncSetSinkVolume sinkID:", sinkID, "handle:", handle, "volume:", volume, "ramp:", ramp, "time:", time); + } + + return(syncError); } -am_Error_e CAmRoutingSender::asyncSetSourceVolume(am_Handle_s& handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_CustomRampType_t ramp, const am_time_t time) +am_Error_e CAmRoutingSender::asyncSetSourceVolume(am_Handle_s &handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_CustomRampType_t ramp, const am_time_t time) { - auto iter (mMapSourceInterface.find(sourceID)); - if (iter == mMapSourceInterface.end()) - { - logError(__METHOD_NAME__,"Could not find sourceID",sourceID); - return (E_NON_EXISTENT); - } - - if(handleExists(handle)) - { - if (handle.handleType==am_Handle_e::H_SETSOURCEVOLUME) - { - logInfo(__METHOD_NAME__,"Resending for handle",handle); - } - else - { - logError(__METHOD_NAME__,"Handle exists but wrong type",handle); - return(E_UNKNOWN); - } - } - else - { - auto handleData = std::make_shared(iter->second,sourceID,mpDatabaseHandler,volume); + auto iter(mMapSourceInterface.find(sourceID)); + if (iter == mMapSourceInterface.end()) + { + logError(__METHOD_NAME__, "Could not find sourceID", sourceID); + return (E_NON_EXISTENT); + } + + if (handleExists(handle)) + { + if (handle.handleType == am_Handle_e::H_SETSOURCEVOLUME) + { + logInfo(__METHOD_NAME__, "Resending for handle", handle); + } + else + { + logError(__METHOD_NAME__, "Handle exists but wrong type", handle); + return(E_UNKNOWN); + } + } + else + { + auto handleData = std::make_shared(iter->second, sourceID, mpDatabaseHandler, volume); handle = createHandle(handleData, H_SETSOURCEVOLUME); } - - logInfo(__METHOD_NAME__,"sourceID=", sourceID,"volume=", volume, "ramp=", ramp, "time=", time,"handle=",handle); - am_Error_e syncError(iter->second->asyncSetSourceVolume(handle, sourceID, volume, ramp, time)); - if (syncError) - { - removeHandle(handle); - logError(__METHOD_NAME__,"Error while calling asyncSetSourceVolume sourceID:",sourceID,"handle:",handle,"volume:",volume,"ramp:",ramp,"time:",time); - } - return(syncError); + + logInfo(__METHOD_NAME__, "sourceID=", sourceID, "volume=", volume, "ramp=", ramp, "time=", time, "handle=", handle); + am_Error_e syncError(iter->second->asyncSetSourceVolume(handle, sourceID, volume, ramp, time)); + if (syncError) + { + removeHandle(handle); + logError(__METHOD_NAME__, "Error while calling asyncSetSourceVolume sourceID:", sourceID, "handle:", handle, "volume:", volume, "ramp:", ramp, "time:", time); + } + + return(syncError); } -am_Error_e CAmRoutingSender::asyncSetSourceState(am_Handle_s& handle, const am_sourceID_t sourceID, const am_SourceState_e state) +am_Error_e CAmRoutingSender::asyncSetSourceState(am_Handle_s &handle, const am_sourceID_t sourceID, const am_SourceState_e state) { - auto iter (mMapSourceInterface.find(sourceID)); - if (iter == mMapSourceInterface.end()) - { - logError(__METHOD_NAME__,"Could not find sourceID",sourceID); - return (E_NON_EXISTENT); - } - - if(handleExists(handle)) - { - if (handle.handleType==am_Handle_e::H_SETSOURCESTATE) - { - logInfo(__METHOD_NAME__,"Resending for handle",handle); - } - else - { - logError(__METHOD_NAME__,"Handle exists but wrong type",handle); - return(E_UNKNOWN); - } - } - else - { - auto handleData = std::make_shared(iter->second,sourceID,state,mpDatabaseHandler); - handle = createHandle(handleData, H_SETSOURCESTATE); - } - logInfo(__METHOD_NAME__,"sourceID=", sourceID, "state=", state,"handle=",handle); - am_Error_e syncError(iter->second->asyncSetSourceState(handle, sourceID, state)); - if (syncError) - { - removeHandle(handle); - logError(__METHOD_NAME__,"Error while calling asyncSetSourceState sourceID:",sourceID,"handle:",handle,"state:",state); - } - return(syncError); + auto iter(mMapSourceInterface.find(sourceID)); + if (iter == mMapSourceInterface.end()) + { + logError(__METHOD_NAME__, "Could not find sourceID", sourceID); + return (E_NON_EXISTENT); + } + + if (handleExists(handle)) + { + if (handle.handleType == am_Handle_e::H_SETSOURCESTATE) + { + logInfo(__METHOD_NAME__, "Resending for handle", handle); + } + else + { + logError(__METHOD_NAME__, "Handle exists but wrong type", handle); + return(E_UNKNOWN); + } + } + else + { + auto handleData = std::make_shared(iter->second, sourceID, state, mpDatabaseHandler); + handle = createHandle(handleData, H_SETSOURCESTATE); + } + + logInfo(__METHOD_NAME__, "sourceID=", sourceID, "state=", state, "handle=", handle); + am_Error_e syncError(iter->second->asyncSetSourceState(handle, sourceID, state)); + if (syncError) + { + removeHandle(handle); + logError(__METHOD_NAME__, "Error while calling asyncSetSourceState sourceID:", sourceID, "handle:", handle, "state:", state); + } + + return(syncError); } -am_Error_e CAmRoutingSender::asyncSetSinkSoundProperty(am_Handle_s& handle, const am_sinkID_t sinkID, const am_SoundProperty_s & soundProperty) +am_Error_e CAmRoutingSender::asyncSetSinkSoundProperty(am_Handle_s &handle, const am_sinkID_t sinkID, const am_SoundProperty_s &soundProperty) { - auto iter (mMapSinkInterface.find(sinkID)); - if (iter == mMapSinkInterface.end()) - { - logError(__METHOD_NAME__,"Could not find sink",sinkID); - return (E_NON_EXISTENT); - } - - if(handleExists(handle)) - { - if (handle.handleType==am_Handle_e::H_SETSINKSOUNDPROPERTY) - { - logInfo(__METHOD_NAME__,"Resending for handle",handle); - } - else - { - logError(__METHOD_NAME__,"Handle exists but wrong type",handle); - return(E_UNKNOWN); - } - } - else - { - auto handleData = std::make_shared(iter->second,sinkID,soundProperty,mpDatabaseHandler); + auto iter(mMapSinkInterface.find(sinkID)); + if (iter == mMapSinkInterface.end()) + { + logError(__METHOD_NAME__, "Could not find sink", sinkID); + return (E_NON_EXISTENT); + } + + if (handleExists(handle)) + { + if (handle.handleType == am_Handle_e::H_SETSINKSOUNDPROPERTY) + { + logInfo(__METHOD_NAME__, "Resending for handle", handle); + } + else + { + logError(__METHOD_NAME__, "Handle exists but wrong type", handle); + return(E_UNKNOWN); + } + } + else + { + auto handleData = std::make_shared(iter->second, sinkID, soundProperty, mpDatabaseHandler); handle = createHandle(handleData, H_SETSINKSOUNDPROPERTY); - } - - logInfo(__METHOD_NAME__,"sinkID=", sinkID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value,"handle=",handle); - am_Error_e syncError(iter->second->asyncSetSinkSoundProperty(handle, sinkID, soundProperty)); - if (syncError) - { - removeHandle(handle); - logError(__METHOD_NAME__,"Error while calling asyncSetSinkSoundProperty sinkID:",sinkID,"handle:",handle,"soundProperty:",soundProperty.type,soundProperty.value); - } - return(syncError); + } + + logInfo(__METHOD_NAME__, "sinkID=", sinkID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value, "handle=", handle); + am_Error_e syncError(iter->second->asyncSetSinkSoundProperty(handle, sinkID, soundProperty)); + if (syncError) + { + removeHandle(handle); + logError(__METHOD_NAME__, "Error while calling asyncSetSinkSoundProperty sinkID:", sinkID, "handle:", handle, "soundProperty:", soundProperty.type, soundProperty.value); + } + + return(syncError); } -am_Error_e CAmRoutingSender::asyncSetSourceSoundProperty(am_Handle_s& handle, const am_sourceID_t sourceID, const am_SoundProperty_s & soundProperty) +am_Error_e CAmRoutingSender::asyncSetSourceSoundProperty(am_Handle_s &handle, const am_sourceID_t sourceID, const am_SoundProperty_s &soundProperty) { - auto iter (mMapSourceInterface.find(sourceID)); - if (iter == mMapSourceInterface.end()) - { - logError(__METHOD_NAME__,"Could not find sourceID",sourceID); - return (E_NON_EXISTENT); - } - - if(handleExists(handle)) - { - if (handle.handleType==am_Handle_e::H_SETSOURCESOUNDPROPERTY) - { - logInfo(__METHOD_NAME__,"Resending for handle",handle); - } - else - { - logError(__METHOD_NAME__,"Handle exists but wrong type",handle); - return(E_UNKNOWN); - } - } - else - { - auto handleData = std::make_shared(iter->second,sourceID,soundProperty,mpDatabaseHandler); + auto iter(mMapSourceInterface.find(sourceID)); + if (iter == mMapSourceInterface.end()) + { + logError(__METHOD_NAME__, "Could not find sourceID", sourceID); + return (E_NON_EXISTENT); + } + + if (handleExists(handle)) + { + if (handle.handleType == am_Handle_e::H_SETSOURCESOUNDPROPERTY) + { + logInfo(__METHOD_NAME__, "Resending for handle", handle); + } + else + { + logError(__METHOD_NAME__, "Handle exists but wrong type", handle); + return(E_UNKNOWN); + } + } + else + { + auto handleData = std::make_shared(iter->second, sourceID, soundProperty, mpDatabaseHandler); handle = createHandle(handleData, H_SETSOURCESOUNDPROPERTY); } - logInfo(__METHOD_NAME__,"sourceID=", sourceID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value,"handle=",handle); - am_Error_e syncError(iter->second->asyncSetSourceSoundProperty(handle, sourceID, soundProperty)); - if (syncError) - { - removeHandle(handle); - logError(__METHOD_NAME__,"Error while calling asyncSetSourceSoundProperty sourceID:",sourceID,"handle:",handle,"soundProperty:",soundProperty.type,soundProperty.value); - } - return(syncError); + + logInfo(__METHOD_NAME__, "sourceID=", sourceID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value, "handle=", handle); + am_Error_e syncError(iter->second->asyncSetSourceSoundProperty(handle, sourceID, soundProperty)); + if (syncError) + { + removeHandle(handle); + logError(__METHOD_NAME__, "Error while calling asyncSetSourceSoundProperty sourceID:", sourceID, "handle:", handle, "soundProperty:", soundProperty.type, soundProperty.value); + } + + return(syncError); } -am_Error_e CAmRoutingSender::asyncSetSourceSoundProperties(am_Handle_s& handle, const std::vector & listSoundProperties, const am_sourceID_t sourceID) +am_Error_e CAmRoutingSender::asyncSetSourceSoundProperties(am_Handle_s &handle, const std::vector &listSoundProperties, const am_sourceID_t sourceID) { - auto iter (mMapSourceInterface.find(sourceID)); - if (iter == mMapSourceInterface.end()) - { - logError(__METHOD_NAME__,"Could not find sourceID",sourceID); - return (E_NON_EXISTENT); - } - - if(handleExists(handle)) - { - if (handle.handleType==am_Handle_e::H_SETSOURCESOUNDPROPERTIES) - { - logInfo(__METHOD_NAME__,"Resending for handle",handle); - } - else - { - logError(__METHOD_NAME__,"Handle exists but wrong type",handle); - return(E_UNKNOWN); - } - } - else - { - auto handleData = std::make_shared(iter->second,sourceID,listSoundProperties,mpDatabaseHandler); + auto iter(mMapSourceInterface.find(sourceID)); + if (iter == mMapSourceInterface.end()) + { + logError(__METHOD_NAME__, "Could not find sourceID", sourceID); + return (E_NON_EXISTENT); + } + + if (handleExists(handle)) + { + if (handle.handleType == am_Handle_e::H_SETSOURCESOUNDPROPERTIES) + { + logInfo(__METHOD_NAME__, "Resending for handle", handle); + } + else + { + logError(__METHOD_NAME__, "Handle exists but wrong type", handle); + return(E_UNKNOWN); + } + } + else + { + auto handleData = std::make_shared(iter->second, sourceID, listSoundProperties, mpDatabaseHandler); handle = createHandle(handleData, H_SETSOURCESOUNDPROPERTIES); } - - logInfo(__METHOD_NAME__,"sourceID=", sourceID); - am_Error_e syncError(iter->second->asyncSetSourceSoundProperties(handle, sourceID, listSoundProperties)); - if (syncError) - { - removeHandle(handle); - logError(__METHOD_NAME__,"Error while calling asyncSetSourceSoundProperties sourceID:",sourceID,"handle:",handle); - } - return(syncError); + + logInfo(__METHOD_NAME__, "sourceID=", sourceID); + am_Error_e syncError(iter->second->asyncSetSourceSoundProperties(handle, sourceID, listSoundProperties)); + if (syncError) + { + removeHandle(handle); + logError(__METHOD_NAME__, "Error while calling asyncSetSourceSoundProperties sourceID:", sourceID, "handle:", handle); + } + + return(syncError); } -am_Error_e CAmRoutingSender::asyncSetSinkSoundProperties(am_Handle_s& handle, const std::vector & listSoundProperties, const am_sinkID_t sinkID) +am_Error_e CAmRoutingSender::asyncSetSinkSoundProperties(am_Handle_s &handle, const std::vector &listSoundProperties, const am_sinkID_t sinkID) { - auto iter (mMapSinkInterface.find(sinkID)); - if (iter == mMapSinkInterface.end()) - { - logError(__METHOD_NAME__,"Could not find sink",sinkID); - return (E_NON_EXISTENT); - } - - if(handleExists(handle)) - { - if (handle.handleType==am_Handle_e::H_SETSINKSOUNDPROPERTIES) - { - logInfo(__METHOD_NAME__,"Resending for handle",handle); - } - else - { - logError(__METHOD_NAME__,"Handle exists but wrong type",handle); - return(E_UNKNOWN); - } - } - else - { - auto handleData = std::make_shared(iter->second,sinkID,listSoundProperties,mpDatabaseHandler); + auto iter(mMapSinkInterface.find(sinkID)); + if (iter == mMapSinkInterface.end()) + { + logError(__METHOD_NAME__, "Could not find sink", sinkID); + return (E_NON_EXISTENT); + } + + if (handleExists(handle)) + { + if (handle.handleType == am_Handle_e::H_SETSINKSOUNDPROPERTIES) + { + logInfo(__METHOD_NAME__, "Resending for handle", handle); + } + else + { + logError(__METHOD_NAME__, "Handle exists but wrong type", handle); + return(E_UNKNOWN); + } + } + else + { + auto handleData = std::make_shared(iter->second, sinkID, listSoundProperties, mpDatabaseHandler); handle = createHandle(handleData, H_SETSINKSOUNDPROPERTIES); } - - logInfo(__METHOD_NAME__,"sinkID=", sinkID,"handle=",handle); - am_Error_e syncError(iter->second->asyncSetSinkSoundProperties(handle, sinkID, listSoundProperties)); - if (syncError) - { - removeHandle(handle); - logError(__METHOD_NAME__,"Error while calling asyncSetSinkSoundProperties sinkID:",sinkID,"handle:",handle); - } - return(syncError); + + logInfo(__METHOD_NAME__, "sinkID=", sinkID, "handle=", handle); + am_Error_e syncError(iter->second->asyncSetSinkSoundProperties(handle, sinkID, listSoundProperties)); + if (syncError) + { + removeHandle(handle); + logError(__METHOD_NAME__, "Error while calling asyncSetSinkSoundProperties sinkID:", sinkID, "handle:", handle); + } + + return(syncError); } -am_Error_e CAmRoutingSender::asyncCrossFade(am_Handle_s& handle, const am_crossfaderID_t crossfaderID, const am_HotSink_e hotSink, const am_CustomRampType_t rampType, const am_time_t time) +am_Error_e CAmRoutingSender::asyncCrossFade(am_Handle_s &handle, const am_crossfaderID_t crossfaderID, const am_HotSink_e hotSink, const am_CustomRampType_t rampType, const am_time_t time) { - auto iter (mMapCrossfaderInterface.find(crossfaderID)); - if (iter == mMapCrossfaderInterface.end()) - { - logError(__METHOD_NAME__,"Could not find crossfaderID",crossfaderID); - return (E_NON_EXISTENT); - } - - if(handleExists(handle)) - { - if (handle.handleType==am_Handle_e::H_CROSSFADE) - { - logInfo(__METHOD_NAME__,"Resending for handle",handle); - } - else - { - logError(__METHOD_NAME__,"Handle exists but wrong type",handle); - return(E_UNKNOWN); - } - } - else - { - auto handleData = std::make_shared(iter->second,crossfaderID,hotSink,mpDatabaseHandler); + auto iter(mMapCrossfaderInterface.find(crossfaderID)); + if (iter == mMapCrossfaderInterface.end()) + { + logError(__METHOD_NAME__, "Could not find crossfaderID", crossfaderID); + return (E_NON_EXISTENT); + } + + if (handleExists(handle)) + { + if (handle.handleType == am_Handle_e::H_CROSSFADE) + { + logInfo(__METHOD_NAME__, "Resending for handle", handle); + } + else + { + logError(__METHOD_NAME__, "Handle exists but wrong type", handle); + return(E_UNKNOWN); + } + } + else + { + auto handleData = std::make_shared(iter->second, crossfaderID, hotSink, mpDatabaseHandler); handle = createHandle(handleData, H_CROSSFADE); - } - - logInfo(__METHOD_NAME__,"hotSource=", hotSink, "crossfaderID=", crossfaderID, "rampType=", rampType, "rampTime=", time,"handle=",handle); - am_Error_e syncError(iter->second->asyncCrossFade(handle, crossfaderID, hotSink, rampType, time)); - if (syncError) - { - removeHandle(handle); - } - return(syncError); + } + + logInfo(__METHOD_NAME__, "hotSource=", hotSink, "crossfaderID=", crossfaderID, "rampType=", rampType, "rampTime=", time, "handle=", handle); + am_Error_e syncError(iter->second->asyncCrossFade(handle, crossfaderID, hotSink, rampType, time)); + if (syncError) + { + removeHandle(handle); + } + + return(syncError); } am_Error_e CAmRoutingSender::setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState) { - logInfo(__METHOD_NAME__,"domainID=", domainID, "domainState=", domainState); + logInfo(__METHOD_NAME__, "domainID=", domainID, "domainState=", domainState); DomainInterfaceMap::iterator iter = mMapDomainInterface.begin(); iter = mMapDomainInterface.find(domainID); if (iter != mMapDomainInterface.end()) + { return (iter->second->setDomainState(domainID, domainState)); + } + return (E_NON_EXISTENT); } @@ -648,9 +667,9 @@ am_Error_e CAmRoutingSender::setDomainState(const am_domainID_t domainID, const * this adds the domain to the lookup table of the Router. The data is used to have a quick lookup of the correct pluginInterface. * This must be done whenever a domain is registered. */ -am_Error_e CAmRoutingSender::addDomainLookup(const am_Domain_s& domainData) +am_Error_e CAmRoutingSender::addDomainLookup(const am_Domain_s &domainData) { - std::vector::iterator iter = mListInterfaces.begin(); + std::vector::iterator iter = mListInterfaces.begin(); std::vector::iterator iterEnd = mListInterfaces.end(); for (; iter < iterEnd; ++iter) { @@ -660,7 +679,8 @@ am_Error_e CAmRoutingSender::addDomainLookup(const am_Domain_s& domainData) return (E_OK); } } - logError(__PRETTY_FUNCTION__," Could not find busname for bus",domainData.busname); + + logError(__PRETTY_FUNCTION__, " Could not find busname for bus", domainData.busname); return (E_UNKNOWN); } @@ -669,7 +689,7 @@ am_Error_e CAmRoutingSender::addDomainLookup(const am_Domain_s& domainData) * this adds the Source to the lookup table of the Router. The data is used to have a quick lookup of the correct pluginInterface. * This must be done whenever a Source is registered. */ -am_Error_e CAmRoutingSender::addSourceLookup(const am_Source_s& sourceData) +am_Error_e CAmRoutingSender::addSourceLookup(const am_Source_s &sourceData) { DomainInterfaceMap::iterator iter = mMapDomainInterface.begin(); iter = mMapDomainInterface.find(sourceData.domainID); @@ -678,7 +698,8 @@ am_Error_e CAmRoutingSender::addSourceLookup(const am_Source_s& sourceData) mMapSourceInterface.insert(std::make_pair(sourceData.sourceID, iter->second)); return (E_OK); } - logError(__PRETTY_FUNCTION__," Could not find domainInterface for domainID",sourceData.domainID); + + logError(__PRETTY_FUNCTION__, " Could not find domainInterface for domainID", sourceData.domainID); return (E_UNKNOWN); } @@ -687,7 +708,7 @@ am_Error_e CAmRoutingSender::addSourceLookup(const am_Source_s& sourceData) * this adds the Sink to the lookup table of the Router. The data is used to have a quick lookup of the correct pluginInterface. * This must be done whenever a Sink is registered. */ -am_Error_e CAmRoutingSender::addSinkLookup(const am_Sink_s& sinkData) +am_Error_e CAmRoutingSender::addSinkLookup(const am_Sink_s &sinkData) { DomainInterfaceMap::iterator iter = mMapDomainInterface.begin(); iter = mMapDomainInterface.find(sinkData.domainID); @@ -696,7 +717,8 @@ am_Error_e CAmRoutingSender::addSinkLookup(const am_Sink_s& sinkData) mMapSinkInterface.insert(std::make_pair(sinkData.sinkID, iter->second)); return (E_OK); } - logError(__PRETTY_FUNCTION__,"Could not find domainInterface for domainID",sinkData.domainID); + + logError(__PRETTY_FUNCTION__, "Could not find domainInterface for domainID", sinkData.domainID); return (E_UNKNOWN); } @@ -705,7 +727,7 @@ am_Error_e CAmRoutingSender::addSinkLookup(const am_Sink_s& sinkData) * this adds the Crossfader to the lookup table of the Router. The data is used to have a quick lookup of the correct pluginInterface. * This must be done whenever a Crossfader is registered. */ -am_Error_e CAmRoutingSender::addCrossfaderLookup(const am_Crossfader_s& crossfaderData) +am_Error_e CAmRoutingSender::addCrossfaderLookup(const am_Crossfader_s &crossfaderData) { DomainInterfaceMap::iterator iter = mMapSourceInterface.begin(); iter = mMapSourceInterface.find(crossfaderData.sourceID); @@ -714,7 +736,8 @@ am_Error_e CAmRoutingSender::addCrossfaderLookup(const am_Crossfader_s& crossfad mMapSourceInterface.insert(std::make_pair(crossfaderData.crossfaderID, iter->second)); return (E_OK); } - logError(__PRETTY_FUNCTION__," Could not find sourceInterface for source",crossfaderData.sourceID); + + logError(__PRETTY_FUNCTION__, " Could not find sourceInterface for source", crossfaderData.sourceID); return (E_UNKNOWN); } @@ -791,17 +814,18 @@ am_Error_e CAmRoutingSender::removeCrossfaderLookup(const am_crossfaderID_t cros * @param handle to be removed * @return E_OK in case of success */ -am_Error_e CAmRoutingSender::removeHandle(const am_Handle_s& handle) +am_Error_e CAmRoutingSender::removeHandle(const am_Handle_s &handle) { if (mlistActiveHandles.erase(handle)) { return (E_OK); } - logError(__METHOD_NAME__,"Could not remove handle",handle.handle); + + logError(__METHOD_NAME__, "Could not remove handle", handle.handle); return (E_NON_EXISTENT); } -am_Error_e CAmRoutingSender::getListHandles(std::vector & listHandles) const +am_Error_e CAmRoutingSender::getListHandles(std::vector &listHandles) const { listHandles.clear(); HandlesMap::const_iterator it = mlistActiveHandles.begin(); @@ -809,6 +833,7 @@ am_Error_e CAmRoutingSender::getListHandles(std::vector & listHandl { listHandles.push_back(it->first); } + return (E_OK); } @@ -822,30 +847,32 @@ am_Handle_s CAmRoutingSender::createHandle(std::shared_ptr handl { am_Handle_s handle; handle.handleType = type; - - for (int checkOverflow=0;checkOverflow<1024;checkOverflow++) - { - if (++mHandleCount>=1024) //defined by 10 bit (out if structure!) - { - mHandleCount=1; - } - handle.handle = mHandleCount; - - if ( mlistActiveHandles.find(handle) == mlistActiveHandles.end() ) - { - mlistActiveHandles.insert(std::make_pair(handle, handleData)); - if (mlistActiveHandles.size()>100) - { - logWarning(__METHOD_NAME__,"too many open handles, number of handles: ", mlistActiveHandles.size()); - } - logInfo(__METHOD_NAME__,handle.handle, handle.handleType); - return (handle); - } - } - - logError(__METHOD_NAME__,"could not create new handle, all handles in use!"); - handle.handle=0; - + + for (int checkOverflow = 0; checkOverflow < 1024; checkOverflow++) + { + if (++mHandleCount >= 1024) // defined by 10 bit (out if structure!) + { + mHandleCount = 1; + } + + handle.handle = mHandleCount; + + if ( mlistActiveHandles.find(handle) == mlistActiveHandles.end()) + { + mlistActiveHandles.insert(std::make_pair(handle, handleData)); + if (mlistActiveHandles.size() > 100) + { + logWarning(__METHOD_NAME__, "too many open handles, number of handles: ", mlistActiveHandles.size()); + } + + logInfo(__METHOD_NAME__, handle.handle, handle.handleType); + return (handle); + } + } + + logError(__METHOD_NAME__, "could not create new handle, all handles in use!"); + handle.handle = 0; + return(handle); } @@ -853,19 +880,19 @@ void CAmRoutingSender::setRoutingReady() { mpRoutingReceiver->waitOnStartup(false); - //create a list of handles + // create a list of handles std::vector listStartupHandles; for (size_t i = 0; i < mListInterfaces.size(); i++) { listStartupHandles.push_back(mpRoutingReceiver->getStartupHandle()); } - //set the receiver ready to wait for replies + // set the receiver ready to wait for replies mpRoutingReceiver->waitOnStartup(true); - std::vector::iterator iter = mListInterfaces.begin(); + std::vector::iterator iter = mListInterfaces.begin(); std::vector::iterator iterEnd = mListInterfaces.end(); - std::vector::const_iterator handleIter(listStartupHandles.begin()); + std::vector::const_iterator handleIter(listStartupHandles.begin()); for (; iter < iterEnd; ++iter) { (*iter).routingInterface->setRoutingReady(*(handleIter++)); @@ -875,301 +902,328 @@ void CAmRoutingSender::setRoutingReady() void CAmRoutingSender::setRoutingRundown() { mpRoutingReceiver->waitOnRundown(false); - //create a list of handles + // create a list of handles std::vector listStartupHandles; for (size_t i = 0; i < mListInterfaces.size(); i++) { listStartupHandles.push_back(mpRoutingReceiver->getRundownHandle()); } - //set the receiver ready to wait for replies + // set the receiver ready to wait for replies mpRoutingReceiver->waitOnRundown(true); - std::vector::iterator iter = mListInterfaces.begin(); + std::vector::iterator iter = mListInterfaces.begin(); std::vector::iterator iterEnd = mListInterfaces.end(); - std::vector::const_iterator handleIter(listStartupHandles.begin()); + std::vector::const_iterator handleIter(listStartupHandles.begin()); for (; iter < iterEnd; ++iter) { (*iter).routingInterface->setRoutingRundown(*(handleIter++)); } } -am_Error_e CAmRoutingSender::asyncSetVolumes(am_Handle_s& handle, const std::vector& listVolumes) +am_Error_e CAmRoutingSender::asyncSetVolumes(am_Handle_s &handle, const std::vector &listVolumes) { - IAmRoutingSend* pRoutingInterface(NULL); + IAmRoutingSend *pRoutingInterface(NULL); if (listVolumes.empty()) + { return (E_NOT_POSSIBLE); + } - //we need an interface so lets get either the sink or source ID from the first entry in the listVolumes - if (listVolumes[0].volumeType==VT_SINK) + // we need an interface so lets get either the sink or source ID from the first entry in the listVolumes + if (listVolumes[0].volumeType == VT_SINK) { - am_sinkID_t sinkID=listVolumes[0].volumeID.sink; - SinkInterfaceMap::iterator iter = mMapSinkInterface.begin(); + am_sinkID_t sinkID = listVolumes[0].volumeID.sink; + SinkInterfaceMap::iterator iter = mMapSinkInterface.begin(); iter = mMapSinkInterface.find(sinkID); - if(iter!=mMapSinkInterface.end()) - pRoutingInterface=iter->second; + if (iter != mMapSinkInterface.end()) + { + pRoutingInterface = iter->second; + } else + { return(E_NON_EXISTENT); + } } - - else if (listVolumes[0].volumeType==VT_SOURCE) + else if (listVolumes[0].volumeType == VT_SOURCE) { - am_sourceID_t sourceID=listVolumes[0].volumeID.source; - SourceInterfaceMap::iterator iter = mMapSourceInterface.begin(); + am_sourceID_t sourceID = listVolumes[0].volumeID.source; + SourceInterfaceMap::iterator iter = mMapSourceInterface.begin(); iter = mMapSourceInterface.find(sourceID); - if (iter!=mMapSourceInterface.end()) - pRoutingInterface=iter->second; + if (iter != mMapSourceInterface.end()) + { + pRoutingInterface = iter->second; + } else + { return(E_NON_EXISTENT); + } } else + { return (E_NON_EXISTENT); + } - auto handleData = std::make_shared(pRoutingInterface,listVolumes,mpDatabaseHandler); + auto handleData = std::make_shared(pRoutingInterface, listVolumes, mpDatabaseHandler); handle = createHandle(handleData, H_SETVOLUMES); logInfo(__METHOD_NAME__, "handle=", handle); am_Error_e syncError(pRoutingInterface->asyncSetVolumes(handle, listVolumes)); if (syncError) - { - removeHandle(handle); - } - return(syncError); + { + removeHandle(handle); + } + + return(syncError); } -am_Error_e CAmRoutingSender::asyncSetSinkNotificationConfiguration(am_Handle_s& handle, const am_sinkID_t sinkID, const am_NotificationConfiguration_s& notificationConfiguration) +am_Error_e CAmRoutingSender::asyncSetSinkNotificationConfiguration(am_Handle_s &handle, const am_sinkID_t sinkID, const am_NotificationConfiguration_s ¬ificationConfiguration) { - auto iter (mMapSinkInterface.find(sinkID)); - if (iter == mMapSinkInterface.end()) - { - logError(__METHOD_NAME__,"Could not find sink",sinkID); - return (E_NON_EXISTENT); - } - - if(handleExists(handle)) - { - if (handle.handleType==am_Handle_e::H_SETSINKNOTIFICATION) - { - logInfo(__METHOD_NAME__,"Resending for handle",handle); - } - else - { - logError(__METHOD_NAME__,"Handle exists but wrong type",handle); - return(E_UNKNOWN); - } - } - else - { - auto handleData = std::make_shared(iter->second,sinkID,notificationConfiguration,mpDatabaseHandler); + auto iter(mMapSinkInterface.find(sinkID)); + if (iter == mMapSinkInterface.end()) + { + logError(__METHOD_NAME__, "Could not find sink", sinkID); + return (E_NON_EXISTENT); + } + + if (handleExists(handle)) + { + if (handle.handleType == am_Handle_e::H_SETSINKNOTIFICATION) + { + logInfo(__METHOD_NAME__, "Resending for handle", handle); + } + else + { + logError(__METHOD_NAME__, "Handle exists but wrong type", handle); + return(E_UNKNOWN); + } + } + else + { + auto handleData = std::make_shared(iter->second, sinkID, notificationConfiguration, mpDatabaseHandler); handle = createHandle(handleData, H_SETSINKNOTIFICATION); } - logInfo(__METHOD_NAME__,"sinkID=",sinkID,"notificationConfiguration.type=",notificationConfiguration.type,"notificationConfiguration.status",notificationConfiguration.status,"notificationConfiguration.parameter",notificationConfiguration.parameter); - am_Error_e syncError(iter->second->asyncSetSinkNotificationConfiguration(handle, sinkID, notificationConfiguration)); - if (syncError) - { - removeHandle(handle); - logError(__METHOD_NAME__,"Error while calling asyncSetSinkNotificationConfiguration sinkID:",sinkID,"handle:",handle); - } - return(syncError); + logInfo(__METHOD_NAME__, "sinkID=", sinkID, "notificationConfiguration.type=", notificationConfiguration.type, "notificationConfiguration.status", notificationConfiguration.status, "notificationConfiguration.parameter", notificationConfiguration.parameter); + am_Error_e syncError(iter->second->asyncSetSinkNotificationConfiguration(handle, sinkID, notificationConfiguration)); + if (syncError) + { + removeHandle(handle); + logError(__METHOD_NAME__, "Error while calling asyncSetSinkNotificationConfiguration sinkID:", sinkID, "handle:", handle); + } + + return(syncError); } -am_Error_e CAmRoutingSender::asyncSetSourceNotificationConfiguration(am_Handle_s& handle, const am_sourceID_t sourceID, const am_NotificationConfiguration_s& notificationConfiguration) +am_Error_e CAmRoutingSender::asyncSetSourceNotificationConfiguration(am_Handle_s &handle, const am_sourceID_t sourceID, const am_NotificationConfiguration_s ¬ificationConfiguration) { - auto iter (mMapSourceInterface.find(sourceID)); - if (iter == mMapSourceInterface.end()) - { - logError(__METHOD_NAME__,"Could not find sourceID",sourceID); - return (E_NON_EXISTENT); - } - - if(handleExists(handle)) - { - if (handle.handleType==am_Handle_e::H_SETSOURCENOTIFICATION) - { - logInfo(__METHOD_NAME__,"Resending for handle",handle); - } - else - { - logError(__METHOD_NAME__,"Handle exists but wrong type",handle); - return(E_UNKNOWN); - } - } - else - { - auto handleData = std::make_shared(iter->second,sourceID,notificationConfiguration,mpDatabaseHandler); + auto iter(mMapSourceInterface.find(sourceID)); + if (iter == mMapSourceInterface.end()) + { + logError(__METHOD_NAME__, "Could not find sourceID", sourceID); + return (E_NON_EXISTENT); + } + + if (handleExists(handle)) + { + if (handle.handleType == am_Handle_e::H_SETSOURCENOTIFICATION) + { + logInfo(__METHOD_NAME__, "Resending for handle", handle); + } + else + { + logError(__METHOD_NAME__, "Handle exists but wrong type", handle); + return(E_UNKNOWN); + } + } + else + { + auto handleData = std::make_shared(iter->second, sourceID, notificationConfiguration, mpDatabaseHandler); handle = createHandle(handleData, H_SETSOURCENOTIFICATION); } - logInfo(__METHOD_NAME__,"sourceID=",sourceID,"notificationConfiguration.type=",notificationConfiguration.type,"notificationConfiguration.status",notificationConfiguration.status,"notificationConfiguration.parameter",notificationConfiguration.parameter); - am_Error_e syncError(iter->second->asyncSetSourceNotificationConfiguration(handle, sourceID, notificationConfiguration)); - if (syncError) - { - removeHandle(handle); - logError(__METHOD_NAME__,"Error while calling asyncSetSourceNotificationConfiguration sourceID:",sourceID,"handle:",handle); - } - return(syncError); + logInfo(__METHOD_NAME__, "sourceID=", sourceID, "notificationConfiguration.type=", notificationConfiguration.type, "notificationConfiguration.status", notificationConfiguration.status, "notificationConfiguration.parameter", notificationConfiguration.parameter); + am_Error_e syncError(iter->second->asyncSetSourceNotificationConfiguration(handle, sourceID, notificationConfiguration)); + if (syncError) + { + removeHandle(handle); + logError(__METHOD_NAME__, "Error while calling asyncSetSourceNotificationConfiguration sourceID:", sourceID, "handle:", handle); + } + + return(syncError); } void CAmRoutingSender::unloadLibraries(void) { - std::vector::iterator iterator = mListLibraryHandles.begin(); + std::vector::iterator iterator = mListLibraryHandles.begin(); for (; iterator < mListLibraryHandles.end(); ++iterator) { dlclose(*iterator); } + mListLibraryHandles.clear(); } -am_Error_e CAmRoutingSender::getListPlugins(std::vector& interfaces) const +am_Error_e CAmRoutingSender::getListPlugins(std::vector &interfaces) const { std::vector::const_iterator it = mListInterfaces.begin(); for (; it != mListInterfaces.end(); ++it) { interfaces.push_back(it->busName); } + return (E_OK); } -void CAmRoutingSender::getInterfaceVersion(std::string & version) const +void CAmRoutingSender::getInterfaceVersion(std::string &version) const { version = RoutingVersion; } -am_Error_e CAmRoutingSender::resyncConnectionState(const am_domainID_t domainID,std::vector& listOfExistingConnections) + +am_Error_e CAmRoutingSender::resyncConnectionState(const am_domainID_t domainID, std::vector &listOfExistingConnections) { DomainInterfaceMap::iterator iter = mMapDomainInterface.begin(); iter = mMapDomainInterface.find(domainID); if (iter != mMapDomainInterface.end()) + { return (iter->second->resyncConnectionState(domainID, listOfExistingConnections)); + } + return (E_NON_EXISTENT); } am_Error_e CAmRoutingSender::writeToDatabaseAndRemove(const am_Handle_s handle) { auto it(mlistActiveHandles.find(handle)); - if (it!=mlistActiveHandles.end()) + if (it != mlistActiveHandles.end()) { - am_Error_e error(it->second->writeDataToDatabase()); - mlistActiveHandles.erase(handle); + am_Error_e error(it->second->writeDataToDatabase()); + mlistActiveHandles.erase(handle); return (error); } - logError(__METHOD_NAME__,"could not find handle data for handle",handle); - return (am_Error_e::E_NON_EXISTENT); + + logError(__METHOD_NAME__, "could not find handle data for handle", handle); + return (am_Error_e::E_NON_EXISTENT); } void CAmRoutingSender::checkVolume(const am_Handle_s handle, const am_volume_t volume) { auto it(mlistActiveHandles.find(handle)); - if (it!=mlistActiveHandles.end()) + if (it != mlistActiveHandles.end()) { - handleVolumeBase* basePtr = static_cast(it->second.get()); - if (basePtr->returnVolume()!=volume) - { - logError(__METHOD_NAME__,"volume returned for handle does not match: ",volume,"expected:",basePtr->returnVolume()); - } - return; + handleVolumeBase *basePtr = static_cast(it->second.get()); + if (basePtr->returnVolume() != volume) + { + logError(__METHOD_NAME__, "volume returned for handle does not match: ", volume, "expected:", basePtr->returnVolume()); + } + + return; } - logError(__METHOD_NAME__,"could not find handle data for handle",handle); + + logError(__METHOD_NAME__, "could not find handle data for handle", handle); } bool CAmRoutingSender::handleExists(const am_Handle_s handle) { auto iter(mlistActiveHandles.find(handle)); - if (iter!=mlistActiveHandles.end()) + if (iter != mlistActiveHandles.end()) { - return (true); - } - return (false); + return (true); + } + + return (false); } am_Error_e CAmRoutingSender::handleSinkSoundProperty::writeDataToDatabase() { - return (mpDatabaseHandler->changeSinkSoundPropertyDB(mSoundProperty,mSinkID)); + return (mpDatabaseHandler->changeSinkSoundPropertyDB(mSoundProperty, mSinkID)); } am_Error_e CAmRoutingSender::handleSinkSoundProperties::writeDataToDatabase() { - std::vector::const_iterator it = mlistSoundProperties.begin(); - for (; it != mlistSoundProperties.end(); ++it) - { - mpDatabaseHandler->changeSinkSoundPropertyDB(*it, mSinkID); - } - return (am_Error_e::E_OK); + std::vector::const_iterator it = mlistSoundProperties.begin(); + for (; it != mlistSoundProperties.end(); ++it) + { + mpDatabaseHandler->changeSinkSoundPropertyDB(*it, mSinkID); + } + + return (am_Error_e::E_OK); } am_Error_e CAmRoutingSender::handleSourceSoundProperty::writeDataToDatabase() { - return (mpDatabaseHandler->changeSourceSoundPropertyDB(mSoundProperty,mSourceID)); + return (mpDatabaseHandler->changeSourceSoundPropertyDB(mSoundProperty, mSourceID)); } am_Error_e CAmRoutingSender::handleSourceSoundProperties::writeDataToDatabase() { - std::vector::const_iterator it = mlistSoundProperties.begin(); - for (; it != mlistSoundProperties.end(); ++it) - { - mpDatabaseHandler->changeSourceSoundPropertyDB(*it, mSourceID); - } - return (am_Error_e::E_OK); + std::vector::const_iterator it = mlistSoundProperties.begin(); + for (; it != mlistSoundProperties.end(); ++it) + { + mpDatabaseHandler->changeSourceSoundPropertyDB(*it, mSourceID); + } + + return (am_Error_e::E_OK); } am_Error_e CAmRoutingSender::handleSourceState::writeDataToDatabase() { - return (mpDatabaseHandler->changeSourceState(mSourceID,mSourceState)); + return (mpDatabaseHandler->changeSourceState(mSourceID, mSourceState)); } am_Error_e CAmRoutingSender::handleSourceVolume::writeDataToDatabase() { - return (mpDatabaseHandler->changeSourceVolume(mSourceID,returnVolume())); + return (mpDatabaseHandler->changeSourceVolume(mSourceID, returnVolume())); } am_Error_e CAmRoutingSender::handleSinkVolume::writeDataToDatabase() { - return (mpDatabaseHandler->changeSinkVolume(mSinkID,returnVolume())); + return (mpDatabaseHandler->changeSinkVolume(mSinkID, returnVolume())); } am_Error_e CAmRoutingSender::handleCrossFader::writeDataToDatabase() { - return (mpDatabaseHandler->changeCrossFaderHotSink(mCrossfaderID, mHotSink)); + return (mpDatabaseHandler->changeCrossFaderHotSink(mCrossfaderID, mHotSink)); } am_Error_e CAmRoutingSender::handleConnect::writeDataToDatabase() { - mConnectionPending = false; - return (mpDatabaseHandler->changeConnectionFinal(mConnectionID)); + mConnectionPending = false; + return (mpDatabaseHandler->changeConnectionFinal(mConnectionID)); } am_Error_e CAmRoutingSender::handleDisconnect::writeDataToDatabase() { - return E_OK; + return E_OK; } am_Error_e CAmRoutingSender::handleSetVolumes::writeDataToDatabase() { - std::vector::const_iterator iterator (mlistVolumes.begin()); - - for (;iterator!=mlistVolumes.end();++iterator) - { - if (iterator->volumeType==VT_SINK) - { - return (mpDatabaseHandler->changeSinkVolume(iterator->volumeID.sink,iterator->volume)); - } - else if (iterator->volumeType==VT_SOURCE) - { - return (mpDatabaseHandler->changeSourceVolume(iterator->volumeID.source,iterator->volume)); - } - } - return (am_Error_e::E_WRONG_FORMAT); + std::vector::const_iterator iterator(mlistVolumes.begin()); + + for (; iterator != mlistVolumes.end(); ++iterator) + { + if (iterator->volumeType == VT_SINK) + { + return (mpDatabaseHandler->changeSinkVolume(iterator->volumeID.sink, iterator->volume)); + } + else if (iterator->volumeType == VT_SOURCE) + { + return (mpDatabaseHandler->changeSourceVolume(iterator->volumeID.source, iterator->volume)); + } + } + + return (am_Error_e::E_WRONG_FORMAT); } am_Error_e CAmRoutingSender::handleSetSinkNotificationConfiguration::writeDataToDatabase() { - return (mpDatabaseHandler->changeSinkNotificationConfigurationDB(mSinkID,mNotificationConfiguration)); + return (mpDatabaseHandler->changeSinkNotificationConfigurationDB(mSinkID, mNotificationConfiguration)); } am_Error_e CAmRoutingSender::handleSetSourceNotificationConfiguration::writeDataToDatabase() { - return (mpDatabaseHandler->changeSourceNotificationConfigurationDB(mSourceID,mNotificationConfiguration)); + return (mpDatabaseHandler->changeSourceNotificationConfigurationDB(mSourceID, mNotificationConfiguration)); } am_Error_e CAmRoutingSender::removeConnectionLookup(const am_connectionID_t connectionID) @@ -1181,21 +1235,21 @@ am_Error_e CAmRoutingSender::removeConnectionLookup(const am_connectionID_t conn mMapConnectionInterface.erase(iter); return (E_OK); } + return (E_UNKNOWN); } CAmRoutingSender::handleConnect::~handleConnect() { - if (mConnectionPending) - { - mpDatabaseHandler->removeConnection(mConnectionID); - } + if (mConnectionPending) + { + mpDatabaseHandler->removeConnection(mConnectionID); + } } CAmRoutingSender::handleDisconnect::~handleDisconnect() { - mpDatabaseHandler->removeConnection(mConnectionID); + mpDatabaseHandler->removeConnection(mConnectionID); } } - -- cgit v1.2.1