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