AudioManagerDaemon/src/CAmRoutingReceiver.cpp

   1 /**
   2  * Copyright (C) 2012, BMW AG
   3  *
   4  * This file is part of GENIVI Project AudioManager.
   5  *
   6  * Contributions are licensed to the GENIVI Alliance under one or more
   7  * Contribution License Agreements.
   8  *
   9  * \copyright
  10  * This Source Code Form is subject to the terms of the
  11  * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
  12  * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
  13  *
  14  *
  15  * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012
  16  *
  17  * \file CAmRoutingReceiver.cpp
  18  * For further information see http://www.genivi.org/.
  19  *
  20  */
  21
  22 #include "CAmRoutingReceiver.h"
  23 #include <cassert>
  24 #include <algorithm>
  25 #include "CAmDatabaseHandler.h"
  26 #include "CAmRoutingSender.h"
  27 #include "CAmControlSender.h"
  28 #include "shared/CAmDltWrapper.h"
  29 #include "shared/CAmSocketHandler.h"
  30
  31 namespace am
  32 {
  33
  34 CAmRoutingReceiver::CAmRoutingReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler) :
  35         mpDatabaseHandler(iDatabaseHandler), //
  36         mpRoutingSender(iRoutingSender), //
  37         mpControlSender(iControlSender), //
  38         mpSocketHandler(iSocketHandler), //
  39         mListStartupHandles(), //
  40         mListRundownHandles(), //
  41         handleCount(0), //
  42         mWaitStartup(false), //
  43         mWaitRundown(false)
  44 {
  45     assert(mpDatabaseHandler!=NULL);
  46     assert(mpRoutingSender!=NULL);
  47     assert(mpControlSender!=NULL);
  48     assert(mpSocketHandler!=NULL);
  49 }
  50
  51 CAmRoutingReceiver::CAmRoutingReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper) :
  52         mpDatabaseHandler(iDatabaseHandler), //
  53         mpRoutingSender(iRoutingSender), //
  54         mpControlSender(iControlSender), //
  55         mpSocketHandler(iSocketHandler), //
  56         mpDBusWrapper(iDBusWrapper), //
  57         mListStartupHandles(), //
  58         mListRundownHandles(), //
  59         handleCount(0), //
  60         mWaitStartup(false), //
  61         mWaitRundown(false)
  62 {
  63     assert(mpDatabaseHandler!=NULL);
  64     assert(mpRoutingSender!=NULL);
  65     assert(mpControlSender!=NULL);
  66     assert(mpSocketHandler!=NULL);
  67     assert(mpDBusWrapper!=NULL);
  68 }
  69
  70 CAmRoutingReceiver::~CAmRoutingReceiver()
  71 {
  72 }
  73
  74 void CAmRoutingReceiver::ackConnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_Error_e error)
  75 {
  76     mpRoutingSender->removeHandle(handle);
  77     if (error == E_OK)
  78     {
  79         mpDatabaseHandler->changeConnectionFinal(connectionID);
  80     }
  81     else
  82     {
  83         mpDatabaseHandler->removeConnection(connectionID);
  84     }
  85     mpControlSender->cbAckConnect(handle, error);
  86 }
  87
  88 void CAmRoutingReceiver::ackDisconnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_Error_e error)
  89 {
  90     mpRoutingSender->removeHandle(handle);
  91     if (error == E_OK)
  92     {
  93         mpDatabaseHandler->removeConnection(connectionID);
  94     }
  95     mpControlSender->cbAckDisconnect(handle, error);
  96 }
  97
  98 void CAmRoutingReceiver::ackSetSinkVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
  99 {
 100     CAmRoutingSender::am_handleData_c handleData = mpRoutingSender->returnHandleData(handle);
 101     if (error == E_OK && handleData.sinkID != 0)
 102     {
 103         //todo: check if volume in handleData is same than volume. React to it.
 104         mpDatabaseHandler->changeSinkVolume(handleData.sinkID, volume);
 105     }
 106     mpRoutingSender->removeHandle(handle);
 107     mpControlSender->cbAckSetSinkVolumeChange(handle, volume, error);
 108 }
 109
 110 void CAmRoutingReceiver::ackSetSourceVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
 111 {
 112     CAmRoutingSender::am_handleData_c handleData = mpRoutingSender->returnHandleData(handle);
 113     if (error == E_OK && handleData.sourceID != 0)
 114     {
 115         //todo: check if volume in handleData is same than volume. React to it.
 116         mpDatabaseHandler->changeSourceVolume(handleData.sourceID, volume);
 117     }
 118     mpRoutingSender->removeHandle(handle);
 119     mpControlSender->cbAckSetSourceVolumeChange(handle, volume, error);
 120 }
 121
 122 void CAmRoutingReceiver::ackSetSourceState(const am_Handle_s handle, const am_Error_e error)
 123 {
 124     CAmRoutingSender::am_handleData_c handleData = mpRoutingSender->returnHandleData(handle);
 125     if (error == E_OK && handleData.sourceID != 0)
 126     {
 127         //todo: check if volume in handleData is same than volume. React to it.
 128         mpDatabaseHandler->changeSourceState(handleData.sourceID, handleData.sourceState);
 129     }
 130     mpRoutingSender->removeHandle(handle);
 131     mpControlSender->cbAckSetSourceState(handle, error);
 132 }
 133
 134 void CAmRoutingReceiver::ackSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error)
 135 {
 136     CAmRoutingSender::am_handleData_c handleData = mpRoutingSender->returnHandleData(handle);
 137     if (error == E_OK && handleData.sinkID != 0)
 138     {
 139         mpDatabaseHandler->changeSinkSoundPropertyDB(handleData.soundPropery, handleData.sinkID);
 140     }
 141     mpRoutingSender->removeHandle(handle);
 142     mpControlSender->cbAckSetSinkSoundProperty(handle, error);
 143
 144 }
 145
 146 void am::CAmRoutingReceiver::ackSetSinkSoundProperties(const am_Handle_s handle, const am_Error_e error)
 147 {
 148     CAmRoutingSender::am_handleData_c handleData = mpRoutingSender->returnHandleData(handle);
 149     if (error == E_OK && handleData.sinkID != 0)
 150     {
 151         std::vector<am_SoundProperty_s>::const_iterator it = handleData.soundProperties->begin();
 152         for (; it != handleData.soundProperties->end(); ++it)
 153         {
 154             mpDatabaseHandler->changeSinkSoundPropertyDB(*it, handleData.sinkID);
 155         }
 156         delete handleData.soundProperties;
 157     }
 158     mpRoutingSender->removeHandle(handle);
 159     mpControlSender->cbAckSetSinkSoundProperties(handle, error);
 160 }
 161
 162 void CAmRoutingReceiver::ackSetSourceSoundProperty(const am_Handle_s handle, const am_Error_e error)
 163 {
 164     CAmRoutingSender::am_handleData_c handleData = mpRoutingSender->returnHandleData(handle);
 165     if (error == E_OK && handleData.sourceID != 0)
 166     {
 167         mpDatabaseHandler->changeSourceSoundPropertyDB(handleData.soundPropery, handleData.sourceID);
 168     }
 169     mpRoutingSender->removeHandle(handle);
 170     mpControlSender->cbAckSetSourceSoundProperty(handle, error);
 171 }
 172
 173 void am::CAmRoutingReceiver::ackSetSourceSoundProperties(const am_Handle_s handle, const am_Error_e error)
 174 {
 175     CAmRoutingSender::am_handleData_c handleData = mpRoutingSender->returnHandleData(handle);
 176     if (error == E_OK && handleData.sourceID != 0)
 177     {
 178         std::vector<am_SoundProperty_s>::const_iterator it = handleData.soundProperties->begin();
 179         for (; it != handleData.soundProperties->end(); ++it)
 180         {
 181             mpDatabaseHandler->changeSourceSoundPropertyDB(*it, handleData.sourceID);
 182         }
 183         delete handleData.soundProperties;
 184     }
 185     mpRoutingSender->removeHandle(handle);
 186     mpControlSender->cbAckSetSourceSoundProperties(handle, error);
 187 }
 188
 189 void CAmRoutingReceiver::ackCrossFading(const am_Handle_s handle, const am_HotSink_e hotSink, const am_Error_e error)
 190 {
 191     CAmRoutingSender::am_handleData_c handleData = mpRoutingSender->returnHandleData(handle);
 192     if (error == E_OK && handleData.crossfaderID != 0)
 193     {
 194         //todo: check if volume in handleData is same than volume. React to it.
 195         mpDatabaseHandler->changeCrossFaderHotSink(handleData.crossfaderID, hotSink);
 196     }
 197     mpRoutingSender->removeHandle(handle);
 198     mpControlSender->cbAckCrossFade(handle, hotSink, error);
 199 }
 200
 201 void CAmRoutingReceiver::ackSourceVolumeTick(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume)
 202 {
 203     mpControlSender->hookSystemSourceVolumeTick(handle, sourceID, volume);
 204 }
 205
 206 void CAmRoutingReceiver::ackSinkVolumeTick(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume)
 207 {
 208     mpControlSender->hookSystemSinkVolumeTick(handle, sinkID, volume);
 209 }
 210
 211 am_Error_e CAmRoutingReceiver::peekDomain(const std::string & name, am_domainID_t & domainID)
 212 {
 213     return (mpDatabaseHandler->peekDomain(name, domainID));
 214
 215 }
 216
 217 am_Error_e CAmRoutingReceiver::registerDomain(const am_Domain_s & domainData, am_domainID_t & domainID)
 218 {
 219     return (mpControlSender->hookSystemRegisterDomain(domainData, domainID));
 220 }
 221
 222 am_Error_e CAmRoutingReceiver::deregisterDomain(const am_domainID_t domainID)
 223 {
 224     return (mpControlSender->hookSystemDeregisterDomain(domainID));
 225 }
 226
 227 am_Error_e CAmRoutingReceiver::registerGateway(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
 228 {
 229     return (mpControlSender->hookSystemRegisterGateway(gatewayData, gatewayID));
 230 }
 231
 232 am_Error_e CAmRoutingReceiver::deregisterGateway(const am_gatewayID_t gatewayID)
 233 {
 234     return (mpControlSender->hookSystemDeregisterGateway(gatewayID));
 235 }
 236
 237 am_Error_e CAmRoutingReceiver::peekSink(const std::string& name, am_sinkID_t & sinkID)
 238 {
 239     return (mpDatabaseHandler->peekSink(name, sinkID));
 240 }
 241
 242 am_Error_e CAmRoutingReceiver::registerSink(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
 243 {
 244     return (mpControlSender->hookSystemRegisterSink(sinkData, sinkID));
 245 }
 246
 247 am_Error_e CAmRoutingReceiver::deregisterSink(const am_sinkID_t sinkID)
 248 {
 249     return (mpControlSender->hookSystemDeregisterSink(sinkID));
 250 }
 251
 252 am_Error_e CAmRoutingReceiver::peekSource(const std::string & name, am_sourceID_t & sourceID)
 253 {
 254     return (mpDatabaseHandler->peekSource(name, sourceID));
 255 }
 256
 257 am_Error_e CAmRoutingReceiver::registerSource(const am_Source_s & sourceData, am_sourceID_t & sourceID)
 258 {
 259     return (mpControlSender->hookSystemRegisterSource(sourceData, sourceID));
 260 }
 261
 262 am_Error_e CAmRoutingReceiver::deregisterSource(const am_sourceID_t sourceID)
 263 {
 264     return (mpControlSender->hookSystemDeregisterSource(sourceID));
 265 }
 266
 267 am_Error_e CAmRoutingReceiver::registerCrossfader(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
 268 {
 269     return (mpControlSender->hookSystemRegisterCrossfader(crossfaderData, crossfaderID));
 270 }
 271
 272 am_Error_e CAmRoutingReceiver::deregisterCrossfader(const am_crossfaderID_t crossfaderID)
 273 {
 274     return (mpControlSender->hookSystemDeregisterCrossfader(crossfaderID));
 275 }
 276
 277 void CAmRoutingReceiver::hookInterruptStatusChange(const am_sourceID_t sourceID, const am_InterruptState_e interruptState)
 278 {
 279     return (mpControlSender->hookSystemInterruptStateChange(sourceID, interruptState));
 280 }
 281
 282 void CAmRoutingReceiver::hookDomainRegistrationComplete(const am_domainID_t domainID)
 283 {
 284     mpControlSender->hookSystemDomainRegistrationComplete(domainID);
 285 }
 286
 287 void CAmRoutingReceiver::hookSinkAvailablityStatusChange(const am_sinkID_t sinkID, const am_Availability_s & availability)
 288 {
 289     mpControlSender->hookSystemSinkAvailablityStateChange(sinkID, availability);
 290 }
 291
 292 void CAmRoutingReceiver::hookSourceAvailablityStatusChange(const am_sourceID_t sourceID, const am_Availability_s & availability)
 293 {
 294     mpControlSender->hookSystemSourceAvailablityStateChange(sourceID, availability);
 295 }
 296
 297 void CAmRoutingReceiver::hookDomainStateChange(const am_domainID_t domainID, const am_DomainState_e domainState)
 298 {
 299     mpControlSender->hookSystemDomainStateChange(domainID, domainState);
 300 }
 301
 302 void CAmRoutingReceiver::hookTimingInformationChanged(const am_connectionID_t connectionID, const am_timeSync_t delay)
 303 {
 304     mpDatabaseHandler->changeConnectionTimingInformation(connectionID, delay);
 305 }
 306
 307 void CAmRoutingReceiver::sendChangedData(const std::vector<am_EarlyData_s> & earlyData)
 308 {
 309     mpControlSender->hookSystemReceiveEarlyData(earlyData);
 310 }
 311
 312 am_Error_e CAmRoutingReceiver::peekSinkClassID(const std::string& name, am_sinkClass_t& sinkClassID)
 313 {
 314     return (mpDatabaseHandler->peekSinkClassID(name, sinkClassID));
 315 }
 316
 317 am_Error_e CAmRoutingReceiver::peekSourceClassID(const std::string& name, am_sourceClass_t& sourceClassID)
 318 {
 319     return (mpDatabaseHandler->peekSourceClassID(name, sourceClassID));
 320 }
 321
 322 am_Error_e CAmRoutingReceiver::getDBusConnectionWrapper(CAmDbusWrapper *& dbusConnectionWrapper) const
 323 {
 324 #ifdef WITH_DBUS_WRAPPER
 325     dbusConnectionWrapper = mpDBusWrapper;
 326     return (E_OK);
 327 #else
 328     return (E_UNKNOWN);
 329 #endif
 330 }
 331
 332 am_Error_e CAmRoutingReceiver::getSocketHandler(CAmSocketHandler *& socketHandler) const
 333 {
 334     socketHandler = mpSocketHandler;
 335     return (E_OK);
 336 }
 337
 338 void CAmRoutingReceiver::getInterfaceVersion(std::string & version) const
 339 {
 340     version = RoutingReceiveVersion;
 341 }
 342
 343 void CAmRoutingReceiver::confirmRoutingReady(const uint16_t handle)
 344 {
 345     mListStartupHandles.erase(std::remove(mListStartupHandles.begin(), mListStartupHandles.end(), handle), mListStartupHandles.end());
 346     if (mWaitStartup && mListStartupHandles.empty())
 347         mpControlSender->confirmRoutingReady();
 348 }
 349
 350 void CAmRoutingReceiver::confirmRoutingRundown(const uint16_t handle)
 351 {
 352     mListRundownHandles.erase(std::remove(mListRundownHandles.begin(), mListRundownHandles.end(), handle), mListRundownHandles.end());
 353     if (mWaitRundown && mListRundownHandles.empty())
 354         mpControlSender->confirmCommandRundown();
 355 }
 356
 357 uint16_t am::CAmRoutingReceiver::getStartupHandle()
 358 {
 359     uint16_t handle = ++handleCount; //todo: handle overflow
 360     mListStartupHandles.push_back(handle);
 361     return (handle);
 362 }
 363
 364 uint16_t am::CAmRoutingReceiver::getRundownHandle()
 365 {
 366     uint16_t handle = ++handleCount; //todo: handle overflow
 367     mListRundownHandles.push_back(handle);
 368     return (handle);
 369 }
 370
 371 void am::CAmRoutingReceiver::waitOnStartup(bool startup)
 372 {
 373     mWaitStartup = startup;
 374 }
 375
 376 void am::CAmRoutingReceiver::waitOnRundown(bool rundown)
 377 {
 378     mWaitRundown = rundown;
 379 }
 380 }