AudioManagerDaemon/src/ControlReceiver.cpp

   1 /**
   2 * Copyright (C) 2011, BMW AG
   3 *
   4 * GeniviAudioMananger AudioManagerDaemon
   5 *
   6 * \file ControlReceiver.cpp
   7 *
   8 * \date 20-Oct-2011 3:42:04 PM
   9 * \author Christian Mueller (christian.ei.mueller@bmw.de)
  10 *
  11 * \section License
  12 * GNU Lesser General Public License, version 2.1, with special exception (GENIVI clause)
  13 * Copyright (C) 2011, BMW AG Christian Mueller  Christian.ei.mueller@bmw.de
  14 *
  15 * This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License, version 2.1, as published by the Free Software Foundation.
  16 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License, version 2.1, for more details.
  17 * You should have received a copy of the GNU Lesser General Public License, version 2.1, along with this program; if not, see <http://www.gnu.org/licenses/lgpl-2.1.html>.
  18 * Note that the copyright holders assume that the GNU Lesser General Public License, version 2.1, may also be applicable to programs even in cases in which the program is not a library in the technical sense.
  19 * Linking AudioManager statically or dynamically with other modules is making a combined work based on AudioManager. You may license such other modules under the GNU Lesser General Public License, version 2.1. If you do not want to license your linked modules under the GNU Lesser General Public License, version 2.1, you may use the program under the following exception.
  20 * As a special exception, the copyright holders of AudioManager give you permission to combine AudioManager with software programs or libraries that are released under any license unless such a combination is not permitted by the license of such a software program or library. You may copy and distribute such a system following the terms of the GNU Lesser General Public License, version 2.1, including this special exception, for AudioManager and the licenses of the other code concerned.
  21 * Note that people who make modified versions of AudioManager are not obligated to grant this special exception for their modified versions; it is their choice whether to do so. The GNU Lesser General Public License, version 2.1, gives permission to release a modified version without this exception; this exception also makes it possible to release a modified version which carries forward this exception.
  22 *
  23 */
  24
  25 #include <config.h>
  26 #include <SocketHandler.h>
  27 #include "ControlReceiver.h"
  28 #include "DatabaseHandler.h"
  29 #include "RoutingSender.h"
  30 #include "CommandSender.h"
  31 #include <assert.h>
  32 #include <dlt/dlt.h>
  33
  34 DLT_IMPORT_CONTEXT(AudioManager)
  35
  36 using namespace am;
  37
  38 ControlReceiver::ControlReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, CommandSender *iCommandSender, SocketHandler *iSocketHandler)
  39         : mDatabaseHandler(iDatabaseHandler),
  40           mRoutingSender(iRoutingSender),
  41           mCommandSender(iCommandSender),
  42           mSocketHandler(iSocketHandler)
  43 {
  44         assert(mDatabaseHandler!=NULL);
  45         assert(mRoutingSender!=NULL);
  46         assert(mCommandSender!=NULL);
  47         assert(mSocketHandler!=NULL);
  48 }
  49
  50 ControlReceiver::ControlReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, CommandSender *iCommandSender)
  51         : mDatabaseHandler(iDatabaseHandler),
  52           mRoutingSender(iRoutingSender),
  53           mCommandSender(iCommandSender)
  54 {
  55 assert(mDatabaseHandler!=NULL);
  56 assert(mRoutingSender!=NULL);
  57 assert(mCommandSender!=NULL);
  58 }
  59
  60
  61 ControlReceiver::~ControlReceiver()
  62 {
  63 }
  64
  65 am_Error_e ControlReceiver::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s> & returnList)
  66 {
  67         //todo: implement routing algorithm
  68         return E_NOT_USED;
  69 }
  70
  71
  72
  73 am_Error_e ControlReceiver::connect(am_Handle_s & handle, am_connectionID_t & connectionID, const am_ConnectionFormat_e format, const am_sourceID_t sourceID, const am_sinkID_t sinkID)
  74 {
  75         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::connect got called, connectionFormat"),DLT_INT(format),DLT_STRING("sourceID"),DLT_INT(sourceID),DLT_STRING("sinkID"),DLT_INT(sinkID));
  76
  77         am_Connection_s tempConnection;
  78         tempConnection.sinkID=sinkID;
  79         tempConnection.sourceID=sourceID;
  80         tempConnection.connectionFormat=format;
  81         tempConnection.connectionID=0;
  82
  83         //todo: enter function to find out what happends if the same connection is in the course of being build up.
  84         if (mDatabaseHandler->existConnection(tempConnection)) return E_ALREADY_EXISTS; //todo:enter the correct connectionID here?
  85
  86         mDatabaseHandler->enterConnectionDB(tempConnection,connectionID);
  87         return mRoutingSender->asyncConnect(handle,connectionID,sourceID,sinkID,format);
  88 }
  89
  90
  91
  92 am_Error_e ControlReceiver::disconnect(am_Handle_s & handle, const am_connectionID_t connectionID)
  93 {
  94         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::disconnect got called, connectionID="),DLT_INT(connectionID));
  95
  96         if (!mDatabaseHandler->existConnectionID(connectionID)) return E_NON_EXISTENT;   //todo: check with EA model and correct
  97         return mRoutingSender->asyncDisconnect(handle,connectionID);
  98 }
  99
 100
 101
 102 am_Error_e ControlReceiver::crossfade(am_Handle_s & handle, const am_HotSink_e hotSource, const am_crossfaderID_t crossfaderID, const am_RampType_e rampType, const am_time_t rampTime)
 103 {
 104         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::crossfade got called, hotSource="),DLT_INT(hotSource),DLT_STRING("crossfaderID="),DLT_INT(crossfaderID),DLT_STRING("rampType="),DLT_INT(rampType),DLT_STRING("rampTime="),DLT_INT(rampTime));
 105
 106         if (!mDatabaseHandler->existcrossFader(crossfaderID)) return E_NON_EXISTENT;
 107         return mRoutingSender->asyncCrossFade(handle,crossfaderID,hotSource,rampType,rampTime);
 108 }
 109
 110
 111
 112 am_Error_e ControlReceiver::setSourceState(am_Handle_s & handle, const am_sourceID_t sourceID, const am_SourceState_e state)
 113 {
 114         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::setSourceState got called, sourceID="),DLT_INT(sourceID),DLT_STRING("state="),DLT_INT(state));
 115
 116         am_SourceState_e sourceState;
 117         if(mDatabaseHandler->getSoureState(sourceID,sourceState)!=E_OK) return E_UNKNOWN;
 118         if(sourceState==state) return E_NO_CHANGE;
 119         return mRoutingSender->asyncSetSourceState(handle,sourceID,state);
 120 }
 121
 122
 123
 124 am_Error_e ControlReceiver::setSinkVolume(am_Handle_s & handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time)
 125 {
 126         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::setSinkVolume got called, sinkID="),DLT_INT(sinkID),DLT_STRING("volume="),DLT_INT(volume),DLT_STRING("ramp="),DLT_INT(ramp),DLT_STRING("time="),DLT_INT(time));
 127
 128         am_volume_t tempVolume;
 129         if(mDatabaseHandler->getSinkVolume(sinkID,tempVolume)!=E_OK) return E_UNKNOWN;
 130         if(tempVolume==volume) return E_NO_CHANGE;
 131         return mRoutingSender->asyncSetSinkVolume(handle,sinkID,volume,ramp,time);
 132 }
 133
 134
 135
 136 am_Error_e ControlReceiver::setSourceVolume(am_Handle_s & handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_RampType_e rampType, const am_time_t time)
 137 {
 138         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::setSourceVolume got called, sourceID="),DLT_INT(sourceID),DLT_STRING("volume="),DLT_INT(volume),DLT_STRING("ramp="),DLT_INT(rampType),DLT_STRING("time="),DLT_INT(time));
 139
 140         am_volume_t tempVolume;
 141         if(mDatabaseHandler->getSourceVolume(sourceID,tempVolume)!=E_OK) return E_UNKNOWN;
 142         if(tempVolume==volume) return E_NO_CHANGE;
 143         return mRoutingSender->asyncSetSourceVolume(handle,sourceID,volume,rampType,time);
 144 }
 145
 146
 147
 148 am_Error_e ControlReceiver::setSinkSoundProperty(am_Handle_s & handle, const am_sinkID_t sinkID, const am_SoundProperty_s & soundProperty)
 149 {
 150         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::setSinkSoundProperty got called, sinkID="),DLT_INT(sinkID),DLT_STRING("soundProperty.Type="),DLT_INT(soundProperty.type),DLT_STRING("soundProperty.value="),DLT_INT(soundProperty.value));
 151
 152         uint16_t value;
 153         if(mDatabaseHandler->getSinkSoundPropertyValue(sinkID,soundProperty.type,value)!=E_OK) return E_UNKNOWN;
 154         if(value==soundProperty.value) return E_NO_CHANGE;
 155         return mRoutingSender->asyncSetSinkSoundProperty(handle,sinkID,soundProperty);
 156 }
 157
 158 am_Error_e am::ControlReceiver::setSinkSoundProperties(am_Handle_s & handle, const am_sinkID_t sinkID, const std::vector<am_SoundProperty_s> & listSoundProperties)
 159 {
 160         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::setSinkSoundProperties got called, sinkID="),DLT_INT(sinkID));
 161
 162         uint16_t value;
 163         bool noChange=true;
 164         std::vector<am_SoundProperty_s>::const_iterator it=listSoundProperties.begin();
 165         for(;it!=listSoundProperties.end();++it)
 166         {
 167                 if(mDatabaseHandler->getSinkSoundPropertyValue(sinkID,it->type,value)!=E_OK) return (E_UNKNOWN);
 168                 if(value!=it->value) noChange=false;
 169         }
 170         if (noChange) return (E_NO_CHANGE);
 171         return (mRoutingSender->asyncSetSinkSoundProperties(handle,listSoundProperties,sinkID));
 172 }
 173
 174 am_Error_e ControlReceiver::setSourceSoundProperty(am_Handle_s & handle, const am_sourceID_t sourceID, const am_SoundProperty_s & soundProperty)
 175 {
 176         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::setSourceSoundProperty got called, sourceID="),DLT_INT(sourceID),DLT_STRING("soundProperty.Type="),DLT_INT(soundProperty.type),DLT_STRING("soundProperty.value="),DLT_INT(soundProperty.value));
 177
 178         uint16_t value;
 179         if(mDatabaseHandler->getSourceSoundPropertyValue(sourceID,soundProperty.type,value)!=E_OK) return E_UNKNOWN;
 180         if(value==soundProperty.value) return E_NO_CHANGE;
 181         return mRoutingSender->asyncSetSourceSoundProperty(handle,sourceID,soundProperty);
 182 }
 183
 184 am_Error_e am::ControlReceiver::setSourceSoundProperties(am_Handle_s & handle, const am_sourceID_t sourceID, const std::vector<am_SoundProperty_s> & listSoundProperties)
 185 {
 186         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::setSourceSoundProperties got called, sourceID="),DLT_INT(sourceID));
 187
 188         uint16_t value;
 189         bool noChange=true;
 190         std::vector<am_SoundProperty_s>::const_iterator it=listSoundProperties.begin();
 191         for(;it!=listSoundProperties.end();++it)
 192         {
 193                 if(mDatabaseHandler->getSourceSoundPropertyValue(sourceID,it->type,value)!=E_OK) return (E_UNKNOWN);
 194                 if(value!=it->value) noChange=false;
 195         }
 196         if (noChange) return (E_NO_CHANGE);
 197         return (mRoutingSender->asyncSetSourceSoundProperties(handle,listSoundProperties,sourceID));
 198 }
 199
 200
 201 am_Error_e ControlReceiver::setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState)
 202 {
 203         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::setDomainState got called, domainID="),DLT_INT(domainID),DLT_STRING("domainState="),DLT_INT(domainState));
 204
 205         am_DomainState_e tempState=DS_MIN;
 206         if(mDatabaseHandler->getDomainState(domainID,tempState)!=E_OK) return E_UNKNOWN;
 207         if(tempState==domainState) return E_NO_CHANGE;
 208         return mRoutingSender->setDomainState(domainID,domainState);
 209 }
 210
 211
 212
 213 am_Error_e ControlReceiver::abortAction(const am_Handle_s handle)
 214 {
 215         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::abortAction got called, handle.type="),DLT_INT(handle.handle),DLT_STRING("handle.handleType="),DLT_INT(handle.handleType));
 216
 217         return mRoutingSender->asyncAbort(handle);
 218 }
 219
 220
 221
 222 am_Error_e ControlReceiver::enterDomainDB(const am_Domain_s & domainData, am_domainID_t & domainID)
 223 {
 224         return mDatabaseHandler->enterDomainDB(domainData,domainID);
 225 }
 226
 227
 228
 229 am_Error_e ControlReceiver::enterMainConnectionDB(const am_MainConnection_s & mainConnectionData, am_mainConnectionID_t & connectionID)
 230 {
 231         return mDatabaseHandler->enterMainConnectionDB(mainConnectionData,connectionID);
 232 }
 233
 234
 235
 236 am_Error_e ControlReceiver::enterSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
 237 {
 238         return mDatabaseHandler->enterSinkDB(sinkData,sinkID);
 239 }
 240
 241
 242
 243 am_Error_e ControlReceiver::enterCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
 244 {
 245         return mDatabaseHandler->enterCrossfaderDB(crossfaderData,crossfaderID);
 246 }
 247
 248
 249
 250 am_Error_e ControlReceiver::enterGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
 251 {
 252         return mDatabaseHandler->enterGatewayDB(gatewayData,gatewayID);
 253 }
 254
 255
 256
 257 am_Error_e ControlReceiver::enterSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID)
 258 {
 259         return mDatabaseHandler->enterSourceDB(sourceData,sourceID);
 260 }
 261
 262 am_Error_e ControlReceiver::enterSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID)
 263 {
 264         return mDatabaseHandler->enterSinkClassDB(sinkClass,sinkClassID);
 265 }
 266
 267 am_Error_e ControlReceiver::enterSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass)
 268 {
 269         return mDatabaseHandler->enterSourceClassDB(sourceClassID,sourceClass);
 270 }
 271
 272
 273 am_Error_e ControlReceiver::enterSystemPropertiesListDB(const std::vector<am_SystemProperty_s> & listSystemProperties)
 274 {
 275         return mDatabaseHandler->enterSystemProperties(listSystemProperties);
 276 }
 277
 278
 279 am_Error_e ControlReceiver::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const am_Route_s & route)
 280 {
 281         return mDatabaseHandler->changeMainConnectionRouteDB(mainconnectionID,route);
 282 }
 283
 284
 285
 286 am_Error_e ControlReceiver::changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState)
 287 {
 288         return mDatabaseHandler->changeMainConnectionStateDB(mainconnectionID,connectionState);
 289 }
 290
 291
 292
 293 am_Error_e ControlReceiver::changeSinkMainVolumeDB(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID)
 294 {
 295         return mDatabaseHandler->changeSinkMainVolumeDB(mainVolume,sinkID);
 296 }
 297
 298
 299
 300 am_Error_e ControlReceiver::changeSinkAvailabilityDB(const am_Availability_s & availability, const am_sinkID_t sinkID)
 301 {
 302         return mDatabaseHandler->changeSinkAvailabilityDB(availability,sinkID);
 303 }
 304
 305
 306
 307 am_Error_e ControlReceiver::changDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID)
 308 {
 309         return mDatabaseHandler->changDomainStateDB(domainState,domainID);
 310 }
 311
 312
 313
 314 am_Error_e ControlReceiver::changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID)
 315 {
 316         return mDatabaseHandler->changeSinkMuteStateDB(muteState,sinkID);
 317 }
 318
 319
 320
 321 am_Error_e ControlReceiver::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID)
 322 {
 323         return mDatabaseHandler->changeMainSinkSoundPropertyDB(soundProperty,sinkID);
 324 }
 325
 326
 327
 328 am_Error_e ControlReceiver::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID)
 329 {
 330         return mDatabaseHandler->changeMainSinkSoundPropertyDB(soundProperty,sourceID);
 331 }
 332
 333
 334
 335 am_Error_e ControlReceiver::changeSourceAvailabilityDB(const am_Availability_s & availability, const am_sourceID_t sourceID)
 336 {
 337         return mDatabaseHandler->changeSourceAvailabilityDB(availability,sourceID);
 338 }
 339
 340
 341
 342 am_Error_e ControlReceiver::changeSystemPropertyDB(const am_SystemProperty_s & property)
 343 {
 344         return mDatabaseHandler->changeSystemPropertyDB(property);
 345 }
 346
 347
 348
 349 am_Error_e ControlReceiver::removeMainConnectionDB(const am_mainConnectionID_t mainConnectionID)
 350 {
 351         return mDatabaseHandler->removeMainConnectionDB(mainConnectionID);
 352 }
 353
 354
 355
 356 am_Error_e ControlReceiver::removeSinkDB(const am_sinkID_t sinkID)
 357 {
 358         return mDatabaseHandler->removeSinkDB(sinkID);
 359 }
 360
 361
 362
 363 am_Error_e ControlReceiver::removeSourceDB(const am_sourceID_t sourceID)
 364 {
 365         return mDatabaseHandler->removeSourceDB(sourceID);
 366 }
 367
 368
 369
 370 am_Error_e ControlReceiver::removeGatewayDB(const am_gatewayID_t gatewayID)
 371 {
 372         return mDatabaseHandler->removeGatewayDB(gatewayID);
 373 }
 374
 375
 376
 377 am_Error_e ControlReceiver::removeCrossfaderDB(const am_crossfaderID_t crossfaderID)
 378 {
 379         return mDatabaseHandler->removeCrossfaderDB(crossfaderID);
 380 }
 381
 382
 383
 384 am_Error_e ControlReceiver::removeDomainDB(const am_domainID_t domainID)
 385 {
 386         return mDatabaseHandler->removeDomainDB(domainID);
 387 }
 388
 389
 390
 391 am_Error_e ControlReceiver::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s & classInfo) const
 392 {
 393         return mDatabaseHandler->getSourceClassInfoDB(sourceID,classInfo);
 394 }
 395
 396
 397 am_Error_e ControlReceiver::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s & sinkClass) const
 398 {
 399         return mDatabaseHandler->getSinkClassInfoDB(sinkID,sinkClass);
 400 }
 401
 402
 403
 404 am_Error_e ControlReceiver::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s & gatewayData) const
 405 {
 406         return mDatabaseHandler->getGatewayInfoDB(gatewayID,gatewayData);
 407 }
 408
 409
 410
 411 am_Error_e ControlReceiver::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s & crossfaderData) const
 412 {
 413         return mDatabaseHandler->getCrossfaderInfoDB(crossfaderID,crossfaderData);
 414 }
 415
 416
 417
 418 am_Error_e ControlReceiver::getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t> & listSinkID) const
 419 {
 420         return mDatabaseHandler->getListSinksOfDomain(domainID,listSinkID);
 421 }
 422
 423
 424
 425 am_Error_e ControlReceiver::getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t> & listSourceID) const
 426 {
 427         return mDatabaseHandler->getListSourcesOfDomain(domainID,listSourceID);
 428 }
 429
 430
 431
 432 am_Error_e ControlReceiver::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t> & listGatewaysID) const
 433 {
 434         return mDatabaseHandler->getListCrossfadersOfDomain(domainID,listGatewaysID);
 435 }
 436
 437
 438
 439 am_Error_e ControlReceiver::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t> & listGatewaysID) const
 440 {
 441         return mDatabaseHandler->getListGatewaysOfDomain(domainID,listGatewaysID);
 442 }
 443
 444
 445
 446 am_Error_e ControlReceiver::getListMainConnections(std::vector<am_MainConnection_s> & listMainConnections) const
 447 {
 448         return mDatabaseHandler->getListMainConnections(listMainConnections);
 449 }
 450
 451
 452
 453 am_Error_e ControlReceiver::getListDomains(std::vector<am_Domain_s> & listDomains) const
 454 {
 455         return mDatabaseHandler->getListDomains(listDomains);
 456 }
 457
 458
 459
 460 am_Error_e ControlReceiver::getListConnections(std::vector<am_Connection_s> & listConnections) const
 461 {
 462         return mDatabaseHandler->getListConnections(listConnections);
 463 }
 464
 465
 466
 467 am_Error_e ControlReceiver::getListSinks(std::vector<am_Sink_s> & listSinks) const
 468 {
 469         return mDatabaseHandler->getListSinks(listSinks);
 470 }
 471
 472
 473
 474 am_Error_e ControlReceiver::getListSources(std::vector<am_Source_s> & listSources) const
 475 {
 476         return mDatabaseHandler->getListSources(listSources);
 477 }
 478
 479
 480
 481 am_Error_e ControlReceiver::getListSourceClasses(std::vector<am_SourceClass_s> & listSourceClasses) const
 482 {
 483         return mDatabaseHandler->getListSourceClasses(listSourceClasses);
 484 }
 485
 486
 487
 488 am_Error_e ControlReceiver::getListHandles(std::vector<am_Handle_s> & listHandles) const
 489 {
 490         return mRoutingSender->getListHandles(listHandles);
 491 }
 492
 493
 494
 495 am_Error_e ControlReceiver::getListCrossfaders(std::vector<am_Crossfader_s> & listCrossfaders) const
 496 {
 497         return mDatabaseHandler->getListCrossfaders(listCrossfaders);
 498 }
 499
 500
 501
 502 am_Error_e ControlReceiver::getListGateways(std::vector<am_Gateway_s> & listGateways) const
 503 {
 504         return mDatabaseHandler->getListGateways(listGateways);
 505 }
 506
 507
 508
 509 am_Error_e ControlReceiver::getListSinkClasses(std::vector<am_SinkClass_s> & listSinkClasses) const
 510 {
 511         return mDatabaseHandler->getListSinkClasses(listSinkClasses);
 512 }
 513
 514
 515 am_Error_e ControlReceiver::getListSystemProperties(std::vector<am_SystemProperty_s> & listSystemProperties) const
 516 {
 517         return mDatabaseHandler->getListSystemProperties(listSystemProperties);
 518 }
 519
 520
 521 am_Error_e ControlReceiver::changeSinkClassInfoDB(const am_SinkClass_s & classInfo)
 522 {
 523         return mDatabaseHandler->changeSinkClassInfoDB(classInfo);
 524 }
 525
 526 am_Error_e ControlReceiver::changeSourceClassInfoDB(const am_SourceClass_s & classInfo)
 527 {
 528         return mDatabaseHandler->changeSourceClassInfoDB(classInfo);
 529 }
 530
 531 am_Error_e ControlReceiver::removeSinkClassDB(const am_sinkClass_t sinkClassID)
 532 {
 533         return mDatabaseHandler->removeSinkClassDB(sinkClassID);
 534 }
 535
 536 am_Error_e ControlReceiver::removeSourceClassDB(const am_sourceClass_t sourceClassID)
 537 {
 538         return mDatabaseHandler->removeSourceClassDB(sourceClassID);
 539 }
 540
 541 void ControlReceiver::setCommandReady()
 542 {
 543         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::setCommandReady got called"));
 544         mCommandSender->cbCommunicationReady();
 545 }
 546
 547 void ControlReceiver::setRoutingReady()
 548 {
 549         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::setRoutingReady got called"));
 550         mRoutingSender->routingInterfacesReady();
 551 }
 552
 553 am_Error_e am::ControlReceiver::getSocketHandler(SocketHandler *& socketHandler)
 554 {
 555 #ifdef WITH_SOCKETHANDLER_LOOP
 556         socketHandler=mSocketHandler;
 557         return E_OK;
 558 #else
 559         return E_UNKNOWN;
 560 #endif
 561 }
 562
 563
 564 uint16_t ControlReceiver::getInterfaceVersion() const
 565 {
 566         return ControlReceiveVersion;
 567 }
 568
 569
 570
 571
 572
 573
 574