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 "ControlReceiver.h"
  26 #include <dlt/dlt.h>
  27 #include <assert.h>
  28
  29 DLT_IMPORT_CONTEXT(AudioManager)
  30
  31 ControlReceiver::ControlReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, CommandSender *iCommandSender)
  32         : mDatabaseHandler(iDatabaseHandler),
  33           mRoutingSender(iRoutingSender),
  34           mCommandSender(iCommandSender)
  35 {
  36         assert(mDatabaseHandler!=NULL);
  37         assert(mRoutingSender!=NULL);
  38         assert(mCommandSender!=NULL);
  39 }
  40
  41 ControlReceiver::~ControlReceiver()
  42 {
  43 }
  44
  45 am_Error_e ControlReceiver::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s> & returnList)
  46 {
  47         //todo: implement routing algorithm
  48 }
  49
  50
  51
  52 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)
  53 {
  54         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));
  55
  56         am_Connection_s tempConnection;
  57         tempConnection.sinkID=sinkID;
  58         tempConnection.sourceID=sourceID;
  59         tempConnection.connectionFormat=format;
  60         tempConnection.connectionID=0;
  61
  62         //todo: enter function to find out what happends if the same connection is in the course of being build up.
  63         if (mDatabaseHandler->existConnection(tempConnection)) return E_ALREADY_EXISTS; //todo:enter the correct connectionID here?
  64
  65         mDatabaseHandler->enterConnectionDB(tempConnection,connectionID);
  66         return mRoutingSender->asyncConnect(handle,connectionID,sourceID,sinkID,format);
  67 }
  68
  69
  70
  71 am_Error_e ControlReceiver::disconnect(am_Handle_s & handle, const am_connectionID_t connectionID)
  72 {
  73         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::disconnect got called, connectionID="),DLT_INT(connectionID));
  74
  75         if (!mDatabaseHandler->existConnectionID(connectionID)) return E_NON_EXISTENT;   //todo: check with EA model and correct
  76         return mRoutingSender->asyncDisconnect(handle,connectionID);
  77 }
  78
  79
  80
  81 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)
  82 {
  83         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));
  84
  85         if (!mDatabaseHandler->existcrossFader(crossfaderID)) return E_NON_EXISTENT;
  86         return mRoutingSender->asyncCrossFade(handle,crossfaderID,hotSource,rampType,rampTime);
  87 }
  88
  89
  90
  91 am_Error_e ControlReceiver::setSourceState(am_Handle_s & handle, const am_sourceID_t sourceID, const am_SourceState_e state)
  92 {
  93         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::setSourceState got called, sourceID="),DLT_INT(sourceID),DLT_STRING("state="),DLT_INT(state));
  94
  95         am_SourceState_e sourceState;
  96         if(mDatabaseHandler->getSoureState(sourceID,sourceState)!=E_OK) return E_UNKNOWN;
  97         if(sourceState==state) return E_NO_CHANGE;
  98         return mRoutingSender->asyncSetSourceState(handle,sourceID,state);
  99 }
 100
 101
 102
 103 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)
 104 {
 105         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));
 106
 107         am_volume_t tempVolume;
 108         if(mDatabaseHandler->getSinkVolume(sinkID,tempVolume)!=E_OK) return E_UNKNOWN;
 109         if(tempVolume==volume) return E_NO_CHANGE;
 110         return mRoutingSender->asyncSetSinkVolume(handle,sinkID,volume,ramp,time);
 111 }
 112
 113
 114
 115 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)
 116 {
 117         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));
 118
 119         am_volume_t tempVolume;
 120         if(mDatabaseHandler->getSourceVolume(sourceID,tempVolume)!=E_OK) return E_UNKNOWN;
 121         if(tempVolume==volume) return E_NO_CHANGE;
 122         return mRoutingSender->asyncSetSourceVolume(handle,sourceID,volume,rampType,time);
 123 }
 124
 125
 126
 127 am_Error_e ControlReceiver::setSinkSoundProperty(am_Handle_s & handle, const am_sinkID_t sinkID, const am_SoundProperty_s & soundProperty)
 128 {
 129         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));
 130
 131         uint16_t value;
 132         if(mDatabaseHandler->getSinkSoundPropertyValue(sinkID,soundProperty.type,value)!=E_OK) return E_UNKNOWN;
 133         if(value==soundProperty.value) return E_NO_CHANGE;
 134         return mRoutingSender->asyncSetSinkSoundProperty(handle,sinkID,soundProperty);
 135 }
 136
 137
 138
 139 am_Error_e ControlReceiver::setSourceSoundProperty(am_Handle_s & handle, const am_sourceID_t sourceID, const am_SoundProperty_s & soundProperty)
 140 {
 141         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));
 142
 143         uint16_t value;
 144         if(mDatabaseHandler->getSourceSoundPropertyValue(sourceID,soundProperty.type,value)!=E_OK) return E_UNKNOWN;
 145         if(value==soundProperty.value) return E_NO_CHANGE;
 146         return mRoutingSender->asyncSetSourceSoundProperty(handle,sourceID,soundProperty);
 147 }
 148
 149
 150
 151 am_Error_e ControlReceiver::setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState)
 152 {
 153         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::setDomainState got called, domainID="),DLT_INT(domainID),DLT_STRING("domainState="),DLT_INT(domainState));
 154
 155         am_DomainState_e tempState=DS_MIN;
 156         if(mDatabaseHandler->getDomainState(domainID,tempState)!=E_OK) return E_UNKNOWN;
 157         if(tempState==domainState) return E_NO_CHANGE;
 158         return mRoutingSender->setDomainState(domainID,domainState);
 159 }
 160
 161
 162
 163 am_Error_e ControlReceiver::abortAction(const am_Handle_s handle)
 164 {
 165         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));
 166
 167         return mRoutingSender->asyncAbort(handle);
 168 }
 169
 170
 171
 172 am_Error_e ControlReceiver::enterDomainDB(const am_Domain_s & domainData, am_domainID_t & domainID)
 173 {
 174         return mDatabaseHandler->enterDomainDB(domainData,domainID);
 175 }
 176
 177
 178
 179 am_Error_e ControlReceiver::enterMainConnectionDB(const am_MainConnection_s & mainConnectionData, am_mainConnectionID_t & connectionID)
 180 {
 181         return mDatabaseHandler->enterMainConnectionDB(mainConnectionData,connectionID);
 182 }
 183
 184
 185
 186 am_Error_e ControlReceiver::enterSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
 187 {
 188         return mDatabaseHandler->enterSinkDB(sinkData,sinkID);
 189 }
 190
 191
 192
 193 am_Error_e ControlReceiver::enterCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
 194 {
 195         return mDatabaseHandler->enterCrossfaderDB(crossfaderData,crossfaderID);
 196 }
 197
 198
 199
 200 am_Error_e ControlReceiver::enterGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
 201 {
 202         return mDatabaseHandler->enterGatewayDB(gatewayData,gatewayID);
 203 }
 204
 205
 206
 207 am_Error_e ControlReceiver::enterSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID)
 208 {
 209         return mDatabaseHandler->enterSourceDB(sourceData,sourceID);
 210 }
 211
 212 am_Error_e ControlReceiver::enterSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID)
 213 {
 214         return mDatabaseHandler->enterSinkClassDB(sinkClass,sinkClassID);
 215 }
 216
 217 am_Error_e ControlReceiver::enterSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass)
 218 {
 219         return mDatabaseHandler->enterSourceClassDB(sourceClassID,sourceClass);
 220 }
 221
 222
 223 am_Error_e ControlReceiver::enterSystemPropertiesListDB(const std::vector<am_SystemProperty_s> & listSystemProperties)
 224 {
 225         return mDatabaseHandler->enterSystemProperties(listSystemProperties);
 226 }
 227
 228
 229 am_Error_e ControlReceiver::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const am_Route_s & route)
 230 {
 231         return mDatabaseHandler->changeMainConnectionRouteDB(mainconnectionID,route);
 232 }
 233
 234
 235
 236 am_Error_e ControlReceiver::changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState)
 237 {
 238         return mDatabaseHandler->changeMainConnectionStateDB(mainconnectionID,connectionState);
 239 }
 240
 241
 242
 243 am_Error_e ControlReceiver::changeSinkMainVolumeDB(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID)
 244 {
 245         return mDatabaseHandler->changeSinkMainVolumeDB(mainVolume,sinkID);
 246 }
 247
 248
 249
 250 am_Error_e ControlReceiver::changeSinkAvailabilityDB(const am_Availability_s & availability, const am_sinkID_t sinkID)
 251 {
 252         return mDatabaseHandler->changeSinkAvailabilityDB(availability,sinkID);
 253 }
 254
 255
 256
 257 am_Error_e ControlReceiver::changDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID)
 258 {
 259         return mDatabaseHandler->changDomainStateDB(domainState,domainID);
 260 }
 261
 262
 263
 264 am_Error_e ControlReceiver::changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID)
 265 {
 266         return mDatabaseHandler->changeSinkMuteStateDB(muteState,sinkID);
 267 }
 268
 269
 270
 271 am_Error_e ControlReceiver::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID)
 272 {
 273         return mDatabaseHandler->changeMainSinkSoundPropertyDB(soundProperty,sinkID);
 274 }
 275
 276
 277
 278 am_Error_e ControlReceiver::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID)
 279 {
 280         return mDatabaseHandler->changeMainSinkSoundPropertyDB(soundProperty,sourceID);
 281 }
 282
 283
 284
 285 am_Error_e ControlReceiver::changeSourceAvailabilityDB(const am_Availability_s & availability, const am_sourceID_t sourceID)
 286 {
 287         return mDatabaseHandler->changeSourceAvailabilityDB(availability,sourceID);
 288 }
 289
 290
 291
 292 am_Error_e ControlReceiver::changeSystemPropertyDB(const am_SystemProperty_s & property)
 293 {
 294         return mDatabaseHandler->changeSystemPropertyDB(property);
 295 }
 296
 297
 298
 299 am_Error_e ControlReceiver::removeMainConnectionDB(const am_mainConnectionID_t mainConnectionID)
 300 {
 301         return mDatabaseHandler->removeMainConnectionDB(mainConnectionID);
 302 }
 303
 304
 305
 306 am_Error_e ControlReceiver::removeSinkDB(const am_sinkID_t sinkID)
 307 {
 308         return mDatabaseHandler->removeSinkDB(sinkID);
 309 }
 310
 311
 312
 313 am_Error_e ControlReceiver::removeSourceDB(const am_sourceID_t sourceID)
 314 {
 315         return mDatabaseHandler->removeSourceDB(sourceID);
 316 }
 317
 318
 319
 320 am_Error_e ControlReceiver::removeGatewayDB(const am_gatewayID_t gatewayID)
 321 {
 322         return mDatabaseHandler->removeGatewayDB(gatewayID);
 323 }
 324
 325
 326
 327 am_Error_e ControlReceiver::removeCrossfaderDB(const am_crossfaderID_t crossfaderID)
 328 {
 329         return mDatabaseHandler->removeCrossfaderDB(crossfaderID);
 330 }
 331
 332
 333
 334 am_Error_e ControlReceiver::removeDomainDB(const am_domainID_t domainID)
 335 {
 336         return mDatabaseHandler->removeDomainDB(domainID);
 337 }
 338
 339
 340
 341 am_Error_e ControlReceiver::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s & classInfo) const
 342 {
 343         return mDatabaseHandler->getSourceClassInfoDB(sourceID,classInfo);
 344 }
 345
 346
 347 am_Error_e ControlReceiver::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s & sinkClass) const
 348 {
 349         return mDatabaseHandler->getSinkClassInfoDB(sinkID,sinkClass);
 350 }
 351
 352
 353
 354 am_Error_e ControlReceiver::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s & gatewayData) const
 355 {
 356         return mDatabaseHandler->getGatewayInfoDB(gatewayID,gatewayData);
 357 }
 358
 359
 360
 361 am_Error_e ControlReceiver::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s & crossfaderData) const
 362 {
 363         return mDatabaseHandler->getCrossfaderInfoDB(crossfaderID,crossfaderData);
 364 }
 365
 366
 367
 368 am_Error_e ControlReceiver::getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t> & listSinkID) const
 369 {
 370         return mDatabaseHandler->getListSinksOfDomain(domainID,listSinkID);
 371 }
 372
 373
 374
 375 am_Error_e ControlReceiver::getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t> & listSourceID) const
 376 {
 377         return mDatabaseHandler->getListSourcesOfDomain(domainID,listSourceID);
 378 }
 379
 380
 381
 382 am_Error_e ControlReceiver::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t> & listGatewaysID) const
 383 {
 384         return mDatabaseHandler->getListCrossfadersOfDomain(domainID,listGatewaysID);
 385 }
 386
 387
 388
 389 am_Error_e ControlReceiver::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t> & listGatewaysID) const
 390 {
 391         return mDatabaseHandler->getListGatewaysOfDomain(domainID,listGatewaysID);
 392 }
 393
 394
 395
 396 am_Error_e ControlReceiver::getListMainConnections(std::vector<am_MainConnection_s> & listMainConnections) const
 397 {
 398         return mDatabaseHandler->getListMainConnections(listMainConnections);
 399 }
 400
 401
 402
 403 am_Error_e ControlReceiver::getListDomains(std::vector<am_Domain_s> & listDomains) const
 404 {
 405         return mDatabaseHandler->getListDomains(listDomains);
 406 }
 407
 408
 409
 410 am_Error_e ControlReceiver::getListConnections(std::vector<am_Connection_s> & listConnections) const
 411 {
 412         return mDatabaseHandler->getListConnections(listConnections);
 413 }
 414
 415
 416
 417 am_Error_e ControlReceiver::getListSinks(std::vector<am_Sink_s> & listSinks) const
 418 {
 419         return mDatabaseHandler->getListSinks(listSinks);
 420 }
 421
 422
 423
 424 am_Error_e ControlReceiver::getListSources(std::vector<am_Source_s> & listSources) const
 425 {
 426         return mDatabaseHandler->getListSources(listSources);
 427 }
 428
 429
 430
 431 am_Error_e ControlReceiver::getListSourceClasses(std::vector<am_SourceClass_s> & listSourceClasses) const
 432 {
 433         return mDatabaseHandler->getListSourceClasses(listSourceClasses);
 434 }
 435
 436
 437
 438 am_Error_e ControlReceiver::getListHandles(std::vector<am_Handle_s> & listHandles) const
 439 {
 440         return mRoutingSender->getListHandles(listHandles);
 441 }
 442
 443
 444
 445 am_Error_e ControlReceiver::getListCrossfaders(std::vector<am_Crossfader_s> & listCrossfaders) const
 446 {
 447         return mDatabaseHandler->getListCrossfaders(listCrossfaders);
 448 }
 449
 450
 451
 452 am_Error_e ControlReceiver::getListGateways(std::vector<am_Gateway_s> & listGateways) const
 453 {
 454         return mDatabaseHandler->getListGateways(listGateways);
 455 }
 456
 457
 458
 459 am_Error_e ControlReceiver::getListSinkClasses(std::vector<am_SinkClass_s> & listSinkClasses) const
 460 {
 461         return mDatabaseHandler->getListSinkClasses(listSinkClasses);
 462 }
 463
 464
 465 am_Error_e ControlReceiver::getListSystemProperties(std::vector<am_SystemProperty_s> & listSystemProperties) const
 466 {
 467         return mDatabaseHandler->getListSystemProperties(listSystemProperties);
 468 }
 469
 470
 471 am_Error_e ControlReceiver::changeSinkClassInfoDB(const am_SinkClass_s & classInfo)
 472 {
 473         mDatabaseHandler->changeSinkClassInfoDB(classInfo);
 474 }
 475
 476 am_Error_e ControlReceiver::changeSourceClassInfoDB(const am_SourceClass_s & classInfo)
 477 {
 478         mDatabaseHandler->changeSourceClassInfoDB(classInfo);
 479 }
 480
 481 am_Error_e ControlReceiver::removeSinkClassDB(const am_sinkClass_t sinkClassID)
 482 {
 483         mDatabaseHandler->removeSinkClassDB(sinkClassID);
 484 }
 485
 486 am_Error_e ControlReceiver::removeSourceClassDB(const am_sourceClass_t sourceClassID)
 487 {
 488         mDatabaseHandler->removeSourceClassDB(sourceClassID);
 489 }
 490
 491 void ControlReceiver::setCommandReady()
 492 {
 493         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::setCommandReady got called"));
 494         mCommandSender->cbCommunicationReady();
 495 }
 496
 497 void ControlReceiver::setRoutingReady()
 498 {
 499         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("ControlReceiver::setRoutingReady got called"));
 500         mRoutingSender->routingInterfacesReady();
 501 }
 502
 503
 504