* changing logical wrong assert

Signed-off-by: christian mueller <christian.ei.mueller@bmw.de>

1 files changed, 45 insertions, 45 deletions

diff --git a/AudioManagerDaemon/src/CAmControlSender.cpp b/AudioManagerDaemon/src/CAmControlSender.cpp
index b3a0480..77cec9f 100644
--- a/AudioManagerDaemon/src/CAmControlSender.cpp
+++ b/AudioManagerDaemon/src/CAmControlSender.cpp
@@ -77,211 +77,211 @@ CAmControlSender::~CAmControlSender()
 
 am_Error_e CAmControlSender::hookUserConnectionRequest(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t & mainConnectionID)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookUserConnectionRequest(sourceID, sinkID, mainConnectionID));
 }
 
 am_Error_e CAmControlSender::hookUserDisconnectionRequest(const am_mainConnectionID_t connectionID)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookUserDisconnectionRequest(connectionID));
 }
 
 am_Error_e CAmControlSender::hookUserSetMainSinkSoundProperty(const am_sinkID_t sinkID, const am_MainSoundProperty_s & soundProperty)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookUserSetMainSinkSoundProperty(sinkID, soundProperty));
 }
 
 am_Error_e CAmControlSender::hookUserSetMainSourceSoundProperty(const am_sourceID_t sourceID, const am_MainSoundProperty_s & soundProperty)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookUserSetMainSourceSoundProperty(sourceID, soundProperty));
 }
 
 am_Error_e CAmControlSender::hookUserSetSystemProperty(const am_SystemProperty_s & property)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookUserSetSystemProperty(property));
 }
 
 am_Error_e CAmControlSender::hookUserVolumeChange(const am_sinkID_t sinkID, const am_mainVolume_t newVolume)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookUserVolumeChange(sinkID, newVolume));
 }
 
 am_Error_e CAmControlSender::hookUserVolumeStep(const am_sinkID_t sinkID, const int16_t increment)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookUserVolumeStep(sinkID, increment));
 }
 
 am_Error_e CAmControlSender::hookUserSetSinkMuteState(const am_sinkID_t sinkID, const am_MuteState_e muteState)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookUserSetSinkMuteState(sinkID, muteState));
 }
 
 am_Error_e CAmControlSender::hookSystemRegisterDomain(const am_Domain_s & domainData, am_domainID_t & domainID)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookSystemRegisterDomain(domainData, domainID));
 }
 
 am_Error_e CAmControlSender::hookSystemDeregisterDomain(const am_domainID_t domainID)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookSystemDeregisterDomain(domainID));
 }
 
 void CAmControlSender::hookSystemDomainRegistrationComplete(const am_domainID_t domainID)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookSystemDomainRegistrationComplete(domainID));
 }
 
 am_Error_e CAmControlSender::hookSystemRegisterSink(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookSystemRegisterSink(sinkData, sinkID));
 }
 
 am_Error_e CAmControlSender::hookSystemDeregisterSink(const am_sinkID_t sinkID)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookSystemDeregisterSink(sinkID));
 }
 
 am_Error_e CAmControlSender::hookSystemRegisterSource(const am_Source_s & sourceData, am_sourceID_t & sourceID)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookSystemRegisterSource(sourceData, sourceID));
 }
 
 am_Error_e CAmControlSender::hookSystemDeregisterSource(const am_sourceID_t sourceID)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookSystemDeregisterSource(sourceID));
 }
 
 am_Error_e CAmControlSender::hookSystemRegisterGateway(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookSystemRegisterGateway(gatewayData, gatewayID));
 }
 
 am_Error_e CAmControlSender::hookSystemDeregisterGateway(const am_gatewayID_t gatewayID)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookSystemDeregisterGateway(gatewayID));
 }
 
 am_Error_e CAmControlSender::hookSystemRegisterCrossfader(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookSystemRegisterCrossfader(crossfaderData, crossfaderID));
 }
 
 am_Error_e CAmControlSender::hookSystemDeregisterCrossfader(const am_crossfaderID_t crossfaderID)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->hookSystemDeregisterCrossfader(crossfaderID));
 }
 
 void CAmControlSender::hookSystemSinkVolumeTick(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume)
 {
-    assert(!mController);
+    assert(mController);
     mController->hookSystemSinkVolumeTick(handle, sinkID, volume);
 }
 
 void CAmControlSender::hookSystemSourceVolumeTick(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume)
 {
-    assert(!mController);
+    assert(mController);
     mController->hookSystemSourceVolumeTick(handle, sourceID, volume);
 }
 
 void CAmControlSender::hookSystemInterruptStateChange(const am_sourceID_t sourceID, const am_InterruptState_e interruptState)
 {
-    assert(!mController);
+    assert(mController);
     mController->hookSystemInterruptStateChange(sourceID, interruptState);
 }
 
 void CAmControlSender::hookSystemSinkAvailablityStateChange(const am_sinkID_t sinkID, const am_Availability_s & availability)
 {
-    assert(!mController);
+    assert(mController);
     mController->hookSystemSinkAvailablityStateChange(sinkID, availability);
 }
 
 void CAmControlSender::hookSystemSourceAvailablityStateChange(const am_sourceID_t sourceID, const am_Availability_s & availability)
 {
-    assert(!mController);
+    assert(mController);
     mController->hookSystemSourceAvailablityStateChange(sourceID, availability);
 }
 
 void CAmControlSender::hookSystemDomainStateChange(const am_domainID_t domainID, const am_DomainState_e state)
 {
-    assert(!mController);
+    assert(mController);
     mController->hookSystemDomainStateChange(domainID, state);
 }
 
 void CAmControlSender::hookSystemReceiveEarlyData(const std::vector<am_EarlyData_s> & data)
 {
-    assert(!mController);
+    assert(mController);
     mController->hookSystemReceiveEarlyData(data);
 }
 
 void CAmControlSender::hookSystemSpeedChange(const am_speed_t speed)
 {
-    assert(!mController);
+    assert(mController);
     mController->hookSystemSpeedChange(speed);
 }
 
 void CAmControlSender::hookSystemTimingInformationChanged(const am_mainConnectionID_t mainConnectionID, const am_timeSync_t time)
 {
-    assert(!mController);
+    assert(mController);
     mController->hookSystemTimingInformationChanged(mainConnectionID, time);
 }
 
 void CAmControlSender::cbAckConnect(const am_Handle_s handle, const am_Error_e errorID)
 {
-    assert(!mController);
+    assert(mController);
     mController->cbAckConnect(handle, errorID);
 }
 
 void CAmControlSender::cbAckDisconnect(const am_Handle_s handle, const am_Error_e errorID)
 {
-    assert(!mController);
+    assert(mController);
     mController->cbAckDisconnect(handle, errorID);
 }
 
 void CAmControlSender::cbAckCrossFade(const am_Handle_s handle, const am_HotSink_e hostsink, const am_Error_e error)
 {
-    assert(!mController);
+    assert(mController);
     mController->cbAckCrossFade(handle, hostsink, error);
 }
 
 void CAmControlSender::cbAckSetSinkVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
 {
-    assert(!mController);
+    assert(mController);
     mController->cbAckSetSinkVolumeChange(handle, volume, error);
 }
 
 void CAmControlSender::cbAckSetSourceVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
 {
-    assert(!mController);
+    assert(mController);
     mController->cbAckSetSourceVolumeChange(handle, volume, error);
 }
 
 void CAmControlSender::cbAckSetSourceState(const am_Handle_s handle, const am_Error_e error)
 {
-    assert(!mController);
+    assert(mController);
     mController->cbAckSetSourceState(handle, error);
 }
 
 void CAmControlSender::cbAckSetSourceSoundProperty(const am_Handle_s handle, const am_Error_e error)
 {
-    assert(!mController);
+    assert(mController);
     mController->cbAckSetSourceSoundProperty(handle, error);
 }
 
@@ -298,37 +298,37 @@ am_Error_e CAmControlSender::startupController(IAmControlReceive *controlreceive
 
 void CAmControlSender::cbAckSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error)
 {
-    assert(!mController);
+    assert(mController);
     mController->cbAckSetSinkSoundProperty(handle, error);
 }
 
 void CAmControlSender::cbAckSetSinkSoundProperties(const am_Handle_s handle, const am_Error_e error)
 {
-    assert(!mController);
+    assert(mController);
     mController->cbAckSetSinkSoundProperties(handle, error);
 }
 
 void CAmControlSender::cbAckSetSourceSoundProperties(const am_Handle_s handle, const am_Error_e error)
 {
-    assert(!mController);
+    assert(mController);
     mController->cbAckSetSourceSoundProperties(handle, error);
 }
 
 void CAmControlSender::setControllerReady()
 {
-    assert(!mController);
+    assert(mController);
     mController->setControllerReady();
 }
 
 void CAmControlSender::setControllerRundown()
 {
-    assert(!mController);
+    assert(mController);
     mController->setControllerRundown();
 }
 
 am_Error_e am::CAmControlSender::getConnectionFormatChoice(const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_Route_s listRoute, const std::vector<am_ConnectionFormat_e> listPossibleConnectionFormats, std::vector<am_ConnectionFormat_e> & listPrioConnectionFormats)
 {
-    assert(!mController);
+    assert(mController);
     return (mController->getConnectionFormatChoice(sourceID, sinkID, listRoute, listPossibleConnectionFormats, listPrioConnectionFormats));
 }
 
@@ -339,25 +339,25 @@ void CAmControlSender::getInterfaceVersion(std::string & version) const
 
 void CAmControlSender::confirmCommandReady()
 {
-    assert(!mController);
+    assert(mController);
     mController->confirmCommandReady();
 }
 
 void CAmControlSender::confirmRoutingReady()
 {
-    assert(!mController);
+    assert(mController);
     mController->confirmRoutingReady();
 }
 
 void CAmControlSender::confirmCommandRundown()
 {
-    assert(!mController);
+    assert(mController);
     mController->confirmCommandRundown();
 }
 
 void CAmControlSender::confirmRoutingRundown()
 {
-    assert(!mController);
+    assert(mController);
     mController->confirmRoutingRundown();
 }
 }