PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlObserverStubDefault.cpp

   1 /*
   2 * This file was generated by the CommonAPI Generators.
   3 * Used org.genivi.commonapi.core 2.1.5.201312121915.
   4 * Used org.franca.core 0.8.11.201401091023.
   5 *
   6 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
   7 * If a copy of the MPL was not distributed with this file, You can obtain one at
   8 * http://mozilla.org/MPL/2.0/.
   9 */
  10 #include <org/genivi/am/RoutingControlObserverStubDefault.h>
  11
  12 namespace org {
  13 namespace genivi {
  14 namespace am {
  15
  16 RoutingControlObserverStubDefault::RoutingControlObserverStubDefault():
  17         remoteEventHandler_(this),
  18         interfaceVersion_(RoutingControlObserver::getInterfaceVersion()) {
  19 }
  20
  21 const CommonAPI::Version& RoutingControlObserverStubDefault::getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> clientId) {
  22     return interfaceVersion_;
  23 }
  24
  25 RoutingControlObserverStubRemoteEvent* RoutingControlObserverStubDefault::initStubAdapter(const std::shared_ptr<RoutingControlObserverStubAdapter>& stubAdapter) {
  26     CommonAPI::Stub<RoutingControlObserverStubAdapter, RoutingControlObserverStubRemoteEvent>::stubAdapter_ = stubAdapter;
  27     return &remoteEventHandler_;
  28 }
  29
  30 const am_RoutingReady_e& RoutingControlObserverStubDefault::getRoutingReadyAttribute() {
  31     return routingReadyAttributeValue_;
  32 }
  33
  34 const am_RoutingReady_e& RoutingControlObserverStubDefault::getRoutingReadyAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) {
  35     return getRoutingReadyAttribute();
  36 }
  37
  38 void RoutingControlObserverStubDefault::setRoutingReadyAttribute(am_RoutingReady_e value) {
  39     const bool valueChanged = trySetRoutingReadyAttribute(std::move(value));
  40     if (valueChanged) {
  41         stubAdapter_->fireRoutingReadyAttributeChanged(routingReadyAttributeValue_);
  42     }
  43 }
  44
  45 bool RoutingControlObserverStubDefault::trySetRoutingReadyAttribute(am_RoutingReady_e value) {
  46     if (!validateRoutingReadyAttributeRequestedValue(value))
  47         return false;
  48
  49     const bool valueChanged = (routingReadyAttributeValue_ != value);
  50     routingReadyAttributeValue_ = std::move(value);
  51     return valueChanged;
  52 }
  53
  54 bool RoutingControlObserverStubDefault::validateRoutingReadyAttributeRequestedValue(const am_RoutingReady_e& value) {
  55     return true;
  56 }
  57
  58
  59
  60 /**
  61  * acknowledges a asyncConnect
  62  */
  63 void RoutingControlObserverStubDefault::ackConnect(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Handle_s handle, am_connectionID_t connectionID, am_Error_e error) {
  64     // Call old style methods in default
  65     ackConnect(handle, connectionID, error);
  66 }
  67 void RoutingControlObserverStubDefault::ackConnect(am_Handle_s handle, am_connectionID_t connectionID, am_Error_e error) {
  68     // No operation in default
  69 }
  70
  71 /**
  72  * acknowledges a asyncDisconnect
  73  */
  74 void RoutingControlObserverStubDefault::ackDisconnect(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Handle_s handle, am_connectionID_t connectionID, am_Error_e error) {
  75     // Call old style methods in default
  76     ackDisconnect(handle, connectionID, error);
  77 }
  78 void RoutingControlObserverStubDefault::ackDisconnect(am_Handle_s handle, am_connectionID_t connectionID, am_Error_e error) {
  79     // No operation in default
  80 }
  81
  82 /**
  83  * acknowledges a asyncsetSinkVolume
  84  */
  85 void RoutingControlObserverStubDefault::ackSetSinkVolumeChange(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Handle_s handle, am_volume_t volume, am_Error_e error) {
  86     // Call old style methods in default
  87     ackSetSinkVolumeChange(handle, volume, error);
  88 }
  89 void RoutingControlObserverStubDefault::ackSetSinkVolumeChange(am_Handle_s handle, am_volume_t volume, am_Error_e error) {
  90     // No operation in default
  91 }
  92
  93 /**
  94  * acknowledges a asyncsetSourceVolume
  95  */
  96 void RoutingControlObserverStubDefault::ackSetSourceVolumeChange(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Handle_s handle, am_volume_t volume, am_Error_e error) {
  97     // Call old style methods in default
  98     ackSetSourceVolumeChange(handle, volume, error);
  99 }
 100 void RoutingControlObserverStubDefault::ackSetSourceVolumeChange(am_Handle_s handle, am_volume_t volume, am_Error_e error) {
 101     // No operation in default
 102 }
 103
 104 /**
 105  * acknowlegde for asyncSetSourceState
 106  */
 107 void RoutingControlObserverStubDefault::ackSetSourceState(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Handle_s handle, am_Error_e error) {
 108     // Call old style methods in default
 109     ackSetSourceState(handle, error);
 110 }
 111 void RoutingControlObserverStubDefault::ackSetSourceState(am_Handle_s handle, am_Error_e error) {
 112     // No operation in default
 113 }
 114
 115 /**
 116  * acknowledges asyncSetSinkSoundProperties
 117  */
 118 void RoutingControlObserverStubDefault::ackSetSinkSoundProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Handle_s handle, am_Error_e error) {
 119     // Call old style methods in default
 120     ackSetSinkSoundProperties(handle, error);
 121 }
 122 void RoutingControlObserverStubDefault::ackSetSinkSoundProperties(am_Handle_s handle, am_Error_e error) {
 123     // No operation in default
 124 }
 125
 126 /**
 127  * acknowledges asyncSetSinkSoundProperty
 128  */
 129 void RoutingControlObserverStubDefault::ackSetSinkSoundProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Handle_s handle, am_Error_e error) {
 130     // Call old style methods in default
 131     ackSetSinkSoundProperty(handle, error);
 132 }
 133 void RoutingControlObserverStubDefault::ackSetSinkSoundProperty(am_Handle_s handle, am_Error_e error) {
 134     // No operation in default
 135 }
 136
 137 /**
 138  * acknowledges asyncSetSourceSoundProperties
 139  */
 140 void RoutingControlObserverStubDefault::ackSetSourceSoundProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Handle_s handle, am_Error_e error) {
 141     // Call old style methods in default
 142     ackSetSourceSoundProperties(handle, error);
 143 }
 144 void RoutingControlObserverStubDefault::ackSetSourceSoundProperties(am_Handle_s handle, am_Error_e error) {
 145     // No operation in default
 146 }
 147
 148 /**
 149  * acknowledges asyncSetSourceSoundProperty
 150  */
 151 void RoutingControlObserverStubDefault::ackSetSourceSoundProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Handle_s handle, am_Error_e error) {
 152     // Call old style methods in default
 153     ackSetSourceSoundProperty(handle, error);
 154 }
 155 void RoutingControlObserverStubDefault::ackSetSourceSoundProperty(am_Handle_s handle, am_Error_e error) {
 156     // No operation in default
 157 }
 158
 159 /**
 160  * acknowledges asyncCrossFade
 161  */
 162 void RoutingControlObserverStubDefault::ackCrossFading(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Handle_s handle, am_HotSink_e hotSink, am_Error_e error) {
 163     // Call old style methods in default
 164     ackCrossFading(handle, hotSink, error);
 165 }
 166 void RoutingControlObserverStubDefault::ackCrossFading(am_Handle_s handle, am_HotSink_e hotSink, am_Error_e error) {
 167     // No operation in default
 168 }
 169
 170 /**
 171  * acknowledges a volume tick. This can be used to display volumechanges during
 172  *  ramps
 173  */
 174 void RoutingControlObserverStubDefault::ackSourceVolumeTick(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Handle_s handle, am_sourceID_t sourceID, am_volume_t volume) {
 175     // Call old style methods in default
 176     ackSourceVolumeTick(handle, sourceID, volume);
 177 }
 178 void RoutingControlObserverStubDefault::ackSourceVolumeTick(am_Handle_s handle, am_sourceID_t sourceID, am_volume_t volume) {
 179     // No operation in default
 180 }
 181
 182 /**
 183  * acknowledges a volume tick. This can be used to display volumechanges during
 184  *  ramps
 185  */
 186 void RoutingControlObserverStubDefault::ackSinkVolumeTick(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Handle_s handle, am_sinkID_t sinkID, am_volume_t volume) {
 187     // Call old style methods in default
 188     ackSinkVolumeTick(handle, sinkID, volume);
 189 }
 190 void RoutingControlObserverStubDefault::ackSinkVolumeTick(am_Handle_s handle, am_sinkID_t sinkID, am_volume_t volume) {
 191     // No operation in default
 192 }
 193
 194 /**
 195  * This function returns the ID to the given domainName. If already a domain is
 196  *  registered with this name, it will return the corresponding ID, if not it will
 197  *  reserve an ID but not register the domain. The other parameters of the domain
 198  *  will be overwritten when the domain is registered.
 199 (at)return E_OK on
 200  *  success, E_UNKNOWN on error
 201  */
 202 void RoutingControlObserverStubDefault::peekDomain(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string name, am_domainID_t& domainID, am_Error_e& error) {
 203     // Call old style methods in default
 204     peekDomain(name, domainID, error);
 205 }
 206 void RoutingControlObserverStubDefault::peekDomain(std::string name, am_domainID_t& domainID, am_Error_e& error) {
 207     // No operation in default
 208 }
 209
 210 /**
 211  * registers a domain
 212 (at)return E_OK on succes, E_ALREADY_EXISTENT if already
 213  *  registered E_UNKOWN on error
 214  */
 215 void RoutingControlObserverStubDefault::registerDomain(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Domain_s domainData, std::string returnBusname, std::string returnInterface, am_domainID_t& domainID, am_Error_e& error) {
 216     // Call old style methods in default
 217     registerDomain(domainData, returnBusname, returnInterface, domainID, error);
 218 }
 219 void RoutingControlObserverStubDefault::registerDomain(am_Domain_s domainData, std::string returnBusname, std::string returnInterface, am_domainID_t& domainID, am_Error_e& error) {
 220     // No operation in default
 221 }
 222
 223 /**
 224  * deregisters a domain. All sources, sinks, gateways and crossfaders from that
 225  *  domain will be removed as well.
 226 (at)return E_OK on succes, E_NON_EXISTENT if
 227  *  not found E_UNKOWN on error
 228  */
 229 void RoutingControlObserverStubDefault::deregisterDomain(const std::shared_ptr<CommonAPI::ClientId> clientId, am_domainID_t domainID, am_Error_e& error) {
 230     // Call old style methods in default
 231     deregisterDomain(domainID, error);
 232 }
 233 void RoutingControlObserverStubDefault::deregisterDomain(am_domainID_t domainID, am_Error_e& error) {
 234     // No operation in default
 235 }
 236
 237 /**
 238  * registers a gateway. (at)return E_OK on succes, E_ALREADY_EXISTENT if already
 239  *  registered E_UNKOWN on error
 240  */
 241 void RoutingControlObserverStubDefault::registerGateway(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Gateway_s gatewayData, am_gatewayID_t& gatewayID, am_Error_e& error) {
 242     // Call old style methods in default
 243     registerGateway(gatewayData, gatewayID, error);
 244 }
 245 void RoutingControlObserverStubDefault::registerGateway(am_Gateway_s gatewayData, am_gatewayID_t& gatewayID, am_Error_e& error) {
 246     // No operation in default
 247 }
 248
 249 /**
 250  * deregisters a gateway. Also removes all sinks and sources of the controlling
 251  *  domain.
 252 (at)return E_OK on succes, E_NON_EXISTENT if not found E_UNKOWN on
 253  *  error
 254  */
 255 void RoutingControlObserverStubDefault::deregisterGateway(const std::shared_ptr<CommonAPI::ClientId> clientId, am_gatewayID_t gatewayID, am_Error_e& error) {
 256     // Call old style methods in default
 257     deregisterGateway(gatewayID, error);
 258 }
 259 void RoutingControlObserverStubDefault::deregisterGateway(am_gatewayID_t gatewayID, am_Error_e& error) {
 260     // No operation in default
 261 }
 262
 263 /**
 264  * This function returns the ID to the given sinkName. If already a sink is
 265  *  registered with this name, it will return the corresponding ID, if not it will
 266  *  reserve an ID but not register the sink. The other parameters of the sink will
 267  *  be overwritten when the sink is registered.
 268 (at)return E_OK on success,
 269  *  E_UNKNOWN on error
 270  */
 271 void RoutingControlObserverStubDefault::peekSink(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string name, am_sinkID_t& sinkID, am_Error_e& error) {
 272     // Call old style methods in default
 273     peekSink(name, sinkID, error);
 274 }
 275 void RoutingControlObserverStubDefault::peekSink(std::string name, am_sinkID_t& sinkID, am_Error_e& error) {
 276     // No operation in default
 277 }
 278
 279 /**
 280  * Registers a sink. If the sink is part of a gateway, the listconnectionFormats
 281  *  is copied to the gatewayInformation
 282 (at)return E_OK on succes,
 283  *  E_ALREADY_EXISTENT if already registered E_UNKOWN on error
 284  */
 285 void RoutingControlObserverStubDefault::registerSink(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Sink_s sinkData, am_sinkID_t& sinkID, am_Error_e& error) {
 286     // Call old style methods in default
 287     registerSink(sinkData, sinkID, error);
 288 }
 289 void RoutingControlObserverStubDefault::registerSink(am_Sink_s sinkData, am_sinkID_t& sinkID, am_Error_e& error) {
 290     // No operation in default
 291 }
 292
 293 /**
 294  * deregisters a sink.
 295 (at)return E_OK on succes, E_NON_EXISTENT if not found
 296  *  E_UNKOWN on error
 297  */
 298 void RoutingControlObserverStubDefault::deregisterSink(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_Error_e& error) {
 299     // Call old style methods in default
 300     deregisterSink(sinkID, error);
 301 }
 302 void RoutingControlObserverStubDefault::deregisterSink(am_sinkID_t sinkID, am_Error_e& error) {
 303     // No operation in default
 304 }
 305
 306 /**
 307  * This function returns the ID to the given sourceName. If already a source is
 308  *  registered with this name, it will return the corresponding ID, if not it will
 309  *  reserve an ID but not register the source. The other parameters of the source
 310  *  will be overwritten when the source is registered.
 311 (at)return E_OK on
 312  *  success, E_UNKNOWN on error
 313  */
 314 void RoutingControlObserverStubDefault::peekSource(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string name, am_sourceID_t& sourceID, am_Error_e& error) {
 315     // Call old style methods in default
 316     peekSource(name, sourceID, error);
 317 }
 318 void RoutingControlObserverStubDefault::peekSource(std::string name, am_sourceID_t& sourceID, am_Error_e& error) {
 319     // No operation in default
 320 }
 321
 322 /**
 323  * registers a source.  If the source is part of a gateway, the
 324  *  listconnectionFormats is copied to the gatewayInformation
 325 (at)return E_OK on
 326  *  success, E_UNKNOWN on error, E_ALREADY_EXIST if either name or sourceID
 327  *  already exists
 328  */
 329 void RoutingControlObserverStubDefault::registerSource(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Source_s sourceData, am_sourceID_t& sourceID, am_Error_e& error) {
 330     // Call old style methods in default
 331     registerSource(sourceData, sourceID, error);
 332 }
 333 void RoutingControlObserverStubDefault::registerSource(am_Source_s sourceData, am_sourceID_t& sourceID, am_Error_e& error) {
 334     // No operation in default
 335 }
 336
 337 /**
 338  * deregisters a source
 339 (at)return E_OK on succes, E_NON_EXISTENT if not found
 340  *  E_UNKOWN on error
 341  */
 342 void RoutingControlObserverStubDefault::deregisterSource(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_Error_e& error) {
 343     // Call old style methods in default
 344     deregisterSource(sourceID, error);
 345 }
 346 void RoutingControlObserverStubDefault::deregisterSource(am_sourceID_t sourceID, am_Error_e& error) {
 347     // No operation in default
 348 }
 349
 350 /**
 351  * this function registers a crossfader.
 352 (at)return E_OK on succes,
 353  *  E_ALREADY_EXISTENT if already registered E_UNKOWN on error
 354  */
 355 void RoutingControlObserverStubDefault::registerCrossfader(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Crossfader_s crossfaderData, am_crossfaderID_t& crossfaderID, am_Error_e& error) {
 356     // Call old style methods in default
 357     registerCrossfader(crossfaderData, crossfaderID, error);
 358 }
 359 void RoutingControlObserverStubDefault::registerCrossfader(am_Crossfader_s crossfaderData, am_crossfaderID_t& crossfaderID, am_Error_e& error) {
 360     // No operation in default
 361 }
 362
 363 /**
 364  * this function deregisters a crossfader. removes all sources and sinks assiated
 365  *  as well.
 366 (at)return E_OK on succes, E_NON_EXISTENT if not found E_UNKOWN on
 367  *  error
 368  */
 369 void RoutingControlObserverStubDefault::deregisterCrossfader(const std::shared_ptr<CommonAPI::ClientId> clientId, am_crossfaderID_t crossfaderID, am_Error_e& error) {
 370     // Call old style methods in default
 371     deregisterCrossfader(crossfaderID, error);
 372 }
 373 void RoutingControlObserverStubDefault::deregisterCrossfader(am_crossfaderID_t crossfaderID, am_Error_e& error) {
 374     // No operation in default
 375 }
 376
 377 /**
 378  * this function peeks a sourceclassID. It is used by the RoutingPlugins to
 379  *  determine the SinkClassIDs of a sinkClass.
 380 (at)return E_OK on succes,
 381  *  E_DATABASE_ERROR on error
 382  */
 383 void RoutingControlObserverStubDefault::peekSourceClassID(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string name, am_sourceClass_t& sourceClassID, am_Error_e& error) {
 384     // Call old style methods in default
 385     peekSourceClassID(name, sourceClassID, error);
 386 }
 387 void RoutingControlObserverStubDefault::peekSourceClassID(std::string name, am_sourceClass_t& sourceClassID, am_Error_e& error) {
 388     // No operation in default
 389 }
 390
 391 /**
 392  * this function peeks a sourceclassID. It is used by the RoutingPlugins to
 393  *  determine the SinkClassIDs of a sinkClass.
 394 (at)return E_OK on succes,
 395  *  E_DATABASE_ERROR on error
 396  */
 397 void RoutingControlObserverStubDefault::peekSinkClassID(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string name, am_sinkClass_t& sinkClassID, am_Error_e& error) {
 398     // Call old style methods in default
 399     peekSinkClassID(name, sinkClassID, error);
 400 }
 401 void RoutingControlObserverStubDefault::peekSinkClassID(std::string name, am_sinkClass_t& sinkClassID, am_Error_e& error) {
 402     // No operation in default
 403 }
 404
 405 /**
 406  * is called when a low level interrupt changes it status.
 407  */
 408 void RoutingControlObserverStubDefault::hookInterruptStatusChange(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_InterruptState_e interruptState) {
 409     // Call old style methods in default
 410     hookInterruptStatusChange(sourceID, interruptState);
 411 }
 412 void RoutingControlObserverStubDefault::hookInterruptStatusChange(am_sourceID_t sourceID, am_InterruptState_e interruptState) {
 413     // No operation in default
 414 }
 415
 416 /**
 417  * This hook is called when all elements from a domain are registered.
 418 Is used by
 419  *  the Controller to know when all expected domains are finally registered
 420  */
 421 void RoutingControlObserverStubDefault::hookDomainRegistrationComplete(const std::shared_ptr<CommonAPI::ClientId> clientId, am_domainID_t domainID) {
 422     // Call old style methods in default
 423     hookDomainRegistrationComplete(domainID);
 424 }
 425 void RoutingControlObserverStubDefault::hookDomainRegistrationComplete(am_domainID_t domainID) {
 426     // No operation in default
 427 }
 428
 429 /**
 430  * is called when a sink changes its availability
 431  */
 432 void RoutingControlObserverStubDefault::hookSinkAvailablityStatusChange(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_Availability_s availability) {
 433     // Call old style methods in default
 434     hookSinkAvailablityStatusChange(sinkID, availability);
 435 }
 436 void RoutingControlObserverStubDefault::hookSinkAvailablityStatusChange(am_sinkID_t sinkID, am_Availability_s availability) {
 437     // No operation in default
 438 }
 439
 440 /**
 441  * is called when a source changes its availability
 442  */
 443 void RoutingControlObserverStubDefault::hookSourceAvailablityStatusChange(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_Availability_s availability) {
 444     // Call old style methods in default
 445     hookSourceAvailablityStatusChange(sourceID, availability);
 446 }
 447 void RoutingControlObserverStubDefault::hookSourceAvailablityStatusChange(am_sourceID_t sourceID, am_Availability_s availability) {
 448     // No operation in default
 449 }
 450
 451 /**
 452  * is called when a domain changes its status. This used for early domains only
 453  */
 454 void RoutingControlObserverStubDefault::hookDomainStateChange(const std::shared_ptr<CommonAPI::ClientId> clientId, am_domainID_t domainID, am_DomainState_e domainState) {
 455     // Call old style methods in default
 456     hookDomainStateChange(domainID, domainState);
 457 }
 458 void RoutingControlObserverStubDefault::hookDomainStateChange(am_domainID_t domainID, am_DomainState_e domainState) {
 459     // No operation in default
 460 }
 461
 462 /**
 463  * is called when the timinginformation (delay) changed for a connection.
 464  */
 465 void RoutingControlObserverStubDefault::hookTimingInformationChanged(const std::shared_ptr<CommonAPI::ClientId> clientId, am_connectionID_t connectionID, am_timeSync_t delay) {
 466     // Call old style methods in default
 467     hookTimingInformationChanged(connectionID, delay);
 468 }
 469 void RoutingControlObserverStubDefault::hookTimingInformationChanged(am_connectionID_t connectionID, am_timeSync_t delay) {
 470     // No operation in default
 471 }
 472
 473 /**
 474  * this function is used to send out all data that has been changed in an early
 475  *  state.
 476 (at)return E_OK on success, E_UNKNOWN on error
 477  */
 478 void RoutingControlObserverStubDefault::sendChangedData(const std::shared_ptr<CommonAPI::ClientId> clientId, am_EarlyData_L earlyData) {
 479     // Call old style methods in default
 480     sendChangedData(earlyData);
 481 }
 482 void RoutingControlObserverStubDefault::sendChangedData(am_EarlyData_L earlyData) {
 483     // No operation in default
 484 }
 485
 486 /**
 487  * updates data of an gateway. (at)return E_OK on success, E_NON_EXISTENT if the
 488  *  gatewayID is not valid.
 489  */
 490 void RoutingControlObserverStubDefault::updateGateway(const std::shared_ptr<CommonAPI::ClientId> clientId, am_gatewayID_t gatewayID, am_ConnectionFormat_L listSourceFormats, am_ConnectionFormat_L listSinkFormats, am_Convertion_L convertionMatrix, am_Error_e& error) {
 491     // Call old style methods in default
 492     updateGateway(gatewayID, listSourceFormats, listSinkFormats, convertionMatrix, error);
 493 }
 494 void RoutingControlObserverStubDefault::updateGateway(am_gatewayID_t gatewayID, am_ConnectionFormat_L listSourceFormats, am_ConnectionFormat_L listSinkFormats, am_Convertion_L convertionMatrix, am_Error_e& error) {
 495     // No operation in default
 496 }
 497
 498 /**
 499  * updates data of an gateway. (at)return E_OK on success, E_NON_EXISTENT if the
 500  *  sinkID is not valid.
 501  */
 502 void RoutingControlObserverStubDefault::updateSink(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_sinkClass_t sinkClassID, am_SoundProperty_L listSoundProperties, am_ConnectionFormat_L listConnectionFormats, am_MainSoundProperty_L listMainSoundProperties, am_Error_e& error) {
 503     // Call old style methods in default
 504     updateSink(sinkID, sinkClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties, error);
 505 }
 506 void RoutingControlObserverStubDefault::updateSink(am_sinkID_t sinkID, am_sinkClass_t sinkClassID, am_SoundProperty_L listSoundProperties, am_ConnectionFormat_L listConnectionFormats, am_MainSoundProperty_L listMainSoundProperties, am_Error_e& error) {
 507     // No operation in default
 508 }
 509
 510 /**
 511  * updates data of an source. (at)return E_OK on success, E_NON_EXISTENT if the
 512  *  sourceID in the struct is not valid.
 513 Please note that only the following
 514  *  data out of am_Source_s have effect when they are
 515  *  changed:
 516 sourceClassID,
 517 listSoundProperties,
 518 listConnectionFormats,
 519  *
 520 listMainSoundProperties
 521  */
 522 void RoutingControlObserverStubDefault::updateSource(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_sourceClass_t sourceClassID, am_SoundProperty_L listSoundProperties, am_ConnectionFormat_L listConnectionFormats, am_MainSoundProperty_L listMainSoundProperties, am_Error_e& error) {
 523     // Call old style methods in default
 524     updateSource(sourceID, sourceClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties, error);
 525 }
 526 void RoutingControlObserverStubDefault::updateSource(am_sourceID_t sourceID, am_sourceClass_t sourceClassID, am_SoundProperty_L listSoundProperties, am_ConnectionFormat_L listConnectionFormats, am_MainSoundProperty_L listMainSoundProperties, am_Error_e& error) {
 527     // No operation in default
 528 }
 529
 530 /**
 531  * acknowledges a asyncSetSinkVolumes
 532  */
 533 void RoutingControlObserverStubDefault::ackSetVolumes(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Handle_s handle, am_Volumes_L listvolumes, am_Error_e error) {
 534     // Call old style methods in default
 535     ackSetVolumes(handle, listvolumes, error);
 536 }
 537 void RoutingControlObserverStubDefault::ackSetVolumes(am_Handle_s handle, am_Volumes_L listvolumes, am_Error_e error) {
 538     // No operation in default
 539 }
 540
 541 /**
 542  * The acknowledge of the SinkNotificationConfiguration
 543  */
 544 void RoutingControlObserverStubDefault::ackSinkNotificationConfiguration(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Handle_s handle, am_Error_e error) {
 545     // Call old style methods in default
 546     ackSinkNotificationConfiguration(handle, error);
 547 }
 548 void RoutingControlObserverStubDefault::ackSinkNotificationConfiguration(am_Handle_s handle, am_Error_e error) {
 549     // No operation in default
 550 }
 551
 552 /**
 553  * The acknowledge of the SourceNotificationConfiguration
 554  */
 555 void RoutingControlObserverStubDefault::ackSourceNotificationConfiguration(const std::shared_ptr<CommonAPI::ClientId> clientId, am_Handle_s handle, am_Error_e error) {
 556     // Call old style methods in default
 557     ackSourceNotificationConfiguration(handle, error);
 558 }
 559 void RoutingControlObserverStubDefault::ackSourceNotificationConfiguration(am_Handle_s handle, am_Error_e error) {
 560     // No operation in default
 561 }
 562
 563 /**
 564  * is called whenever a notified value needs to be send
 565  */
 566 void RoutingControlObserverStubDefault::hookSinkNotificationDataChange(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_NotificationPayload_s payload) {
 567     // Call old style methods in default
 568     hookSinkNotificationDataChange(sinkID, payload);
 569 }
 570 void RoutingControlObserverStubDefault::hookSinkNotificationDataChange(am_sinkID_t sinkID, am_NotificationPayload_s payload) {
 571     // No operation in default
 572 }
 573
 574 /**
 575  * is called whenever a notified value needs to be send
 576  */
 577 void RoutingControlObserverStubDefault::hookSourceNotificationDataChange(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_NotificationPayload_s payload) {
 578     // Call old style methods in default
 579     hookSourceNotificationDataChange(sourceID, payload);
 580 }
 581 void RoutingControlObserverStubDefault::hookSourceNotificationDataChange(am_sourceID_t sourceID, am_NotificationPayload_s payload) {
 582     // No operation in default
 583 }
 584
 585 void RoutingControlObserverStubDefault::confirmRoutingRundown(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string domainName) {
 586     // Call old style methods in default
 587     confirmRoutingRundown(domainName);
 588 }
 589 void RoutingControlObserverStubDefault::confirmRoutingRundown(std::string domainName) {
 590     // No operation in default
 591 }
 592
 593
 594
 595
 596 RoutingControlObserverStubDefault::RemoteEventHandler::RemoteEventHandler(RoutingControlObserverStubDefault* defaultStub):
 597         defaultStub_(defaultStub) {
 598 }
 599
 600 } // namespace am
 601 } // namespace genivi
 602 } // namespace org