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