PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlObserverDBusStubAdapter.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 "RoutingControlObserverDBusStubAdapter.h"
  11 #include <org/genivi/am/RoutingControlObserver.h>
  12
  13 namespace org {
  14 namespace genivi {
  15 namespace am {
  16
  17 std::shared_ptr<CommonAPI::DBus::DBusStubAdapter> createRoutingControlObserverDBusStubAdapter(
  18                    const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
  19                    const std::string& commonApiAddress,
  20                    const std::string& interfaceName,
  21                    const std::string& busName,
  22                    const std::string& objectPath,
  23                    const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyConnection,
  24                    const std::shared_ptr<CommonAPI::StubBase>& stubBase) {
  25     return std::make_shared<RoutingControlObserverDBusStubAdapter>(factory, commonApiAddress, interfaceName, busName, objectPath, dbusProxyConnection, stubBase);
  26 }
  27
  28 __attribute__((constructor)) void registerRoutingControlObserverDBusStubAdapter(void) {
  29     CommonAPI::DBus::DBusFactory::registerAdapterFactoryMethod(RoutingControlObserver::getInterfaceId(),
  30                                                                &createRoutingControlObserverDBusStubAdapter);
  31 }
  32
  33
  34
  35 RoutingControlObserverDBusStubAdapterInternal::~RoutingControlObserverDBusStubAdapterInternal() {
  36     deactivateManagedInstances();
  37     RoutingControlObserverDBusStubAdapterHelper::deinit();
  38 }
  39
  40 void RoutingControlObserverDBusStubAdapterInternal::deactivateManagedInstances() {
  41 }
  42
  43 const char* RoutingControlObserverDBusStubAdapterInternal::getMethodsDBusIntrospectionXmlData() const {
  44     static const std::string introspectionData =
  45         "<method name=\"getInterfaceVersion\">\n"
  46             "<arg name=\"value\" type=\"uu\" direction=\"out\" />"
  47         "</method>\n"
  48         "<method name=\"getRoutingReadyAttribute\">\n"
  49             "<arg name=\"value\" type=\"i\" direction=\"out\" />"
  50         "</method>\n"
  51         "<signal name=\"onRoutingReadyAttributeChanged\">\n"
  52             "<arg name=\"changedValue\" type=\"i\" />\n"
  53         "</signal>\n"
  54         /**
  55          * acknowledges a asyncConnect
  56          */
  57         "<method name=\"ackConnect\">\n"
  58             "<arg name=\"handle\" type=\"(iq)\" direction=\"in\" />\n"
  59             "<arg name=\"connectionID\" type=\"q\" direction=\"in\" />\n"
  60             "<arg name=\"error\" type=\"i\" direction=\"in\" />\n"
  61         "</method>\n"
  62         /**
  63          * acknowledges a asyncDisconnect
  64          */
  65         "<method name=\"ackDisconnect\">\n"
  66             "<arg name=\"handle\" type=\"(iq)\" direction=\"in\" />\n"
  67             "<arg name=\"connectionID\" type=\"q\" direction=\"in\" />\n"
  68             "<arg name=\"error\" type=\"i\" direction=\"in\" />\n"
  69         "</method>\n"
  70         /**
  71          * acknowledges a asyncsetSinkVolume
  72          */
  73         "<method name=\"ackSetSinkVolumeChange\">\n"
  74             "<arg name=\"handle\" type=\"(iq)\" direction=\"in\" />\n"
  75             "<arg name=\"volume\" type=\"n\" direction=\"in\" />\n"
  76             "<arg name=\"error\" type=\"i\" direction=\"in\" />\n"
  77         "</method>\n"
  78         /**
  79          * acknowledges a asyncsetSourceVolume
  80          */
  81         "<method name=\"ackSetSourceVolumeChange\">\n"
  82             "<arg name=\"handle\" type=\"(iq)\" direction=\"in\" />\n"
  83             "<arg name=\"volume\" type=\"n\" direction=\"in\" />\n"
  84             "<arg name=\"error\" type=\"i\" direction=\"in\" />\n"
  85         "</method>\n"
  86         /**
  87          * acknowlegde for asyncSetSourceState
  88          */
  89         "<method name=\"ackSetSourceState\">\n"
  90             "<arg name=\"handle\" type=\"(iq)\" direction=\"in\" />\n"
  91             "<arg name=\"error\" type=\"i\" direction=\"in\" />\n"
  92         "</method>\n"
  93         /**
  94          * acknowledges asyncSetSinkSoundProperties
  95          */
  96         "<method name=\"ackSetSinkSoundProperties\">\n"
  97             "<arg name=\"handle\" type=\"(iq)\" direction=\"in\" />\n"
  98             "<arg name=\"error\" type=\"i\" direction=\"in\" />\n"
  99         "</method>\n"
 100         /**
 101          * acknowledges asyncSetSinkSoundProperty
 102          */
 103         "<method name=\"ackSetSinkSoundProperty\">\n"
 104             "<arg name=\"handle\" type=\"(iq)\" direction=\"in\" />\n"
 105             "<arg name=\"error\" type=\"i\" direction=\"in\" />\n"
 106         "</method>\n"
 107         /**
 108          * acknowledges asyncSetSourceSoundProperties
 109          */
 110         "<method name=\"ackSetSourceSoundProperties\">\n"
 111             "<arg name=\"handle\" type=\"(iq)\" direction=\"in\" />\n"
 112             "<arg name=\"error\" type=\"i\" direction=\"in\" />\n"
 113         "</method>\n"
 114         /**
 115          * acknowledges asyncSetSourceSoundProperty
 116          */
 117         "<method name=\"ackSetSourceSoundProperty\">\n"
 118             "<arg name=\"handle\" type=\"(iq)\" direction=\"in\" />\n"
 119             "<arg name=\"error\" type=\"i\" direction=\"in\" />\n"
 120         "</method>\n"
 121         /**
 122          * acknowledges asyncCrossFade
 123          */
 124         "<method name=\"ackCrossFading\">\n"
 125             "<arg name=\"handle\" type=\"(iq)\" direction=\"in\" />\n"
 126             "<arg name=\"hotSink\" type=\"i\" direction=\"in\" />\n"
 127             "<arg name=\"error\" type=\"i\" direction=\"in\" />\n"
 128         "</method>\n"
 129         /**
 130          * acknowledges a volume tick. This can be used to display volumechanges during
 131          *  ramps
 132          */
 133         "<method name=\"ackSourceVolumeTick\">\n"
 134             "<arg name=\"handle\" type=\"(iq)\" direction=\"in\" />\n"
 135             "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n"
 136             "<arg name=\"volume\" type=\"n\" direction=\"in\" />\n"
 137         "</method>\n"
 138         /**
 139          * acknowledges a volume tick. This can be used to display volumechanges during
 140          *  ramps
 141          */
 142         "<method name=\"ackSinkVolumeTick\">\n"
 143             "<arg name=\"handle\" type=\"(iq)\" direction=\"in\" />\n"
 144             "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n"
 145             "<arg name=\"volume\" type=\"n\" direction=\"in\" />\n"
 146         "</method>\n"
 147         /**
 148          * This function returns the ID to the given domainName. If already a domain is
 149          *  registered with this name, it will return the corresponding ID, if not it will
 150          *  reserve an ID but not register the domain. The other parameters of the domain
 151          *  will be overwritten when the domain is registered.
 152         (at)return E_OK on
 153          *  success, E_UNKNOWN on error
 154          */
 155         "<method name=\"peekDomain\">\n"
 156             "<arg name=\"name\" type=\"s\" direction=\"in\" />\n"
 157             "<arg name=\"domainID\" type=\"q\" direction=\"out\" />\n"
 158             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 159         "</method>\n"
 160         /**
 161          * registers a domain
 162         (at)return E_OK on succes, E_ALREADY_EXISTENT if already
 163          *  registered E_UNKOWN on error
 164          */
 165         "<method name=\"registerDomain\">\n"
 166             "<arg name=\"domainData\" type=\"(qsssbbi)\" direction=\"in\" />\n"
 167             "<arg name=\"returnBusname\" type=\"s\" direction=\"in\" />\n"
 168             "<arg name=\"returnInterface\" type=\"s\" direction=\"in\" />\n"
 169             "<arg name=\"domainID\" type=\"q\" direction=\"out\" />\n"
 170             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 171         "</method>\n"
 172         /**
 173          * deregisters a domain. All sources, sinks, gateways and crossfaders from that
 174          *  domain will be removed as well.
 175         (at)return E_OK on succes, E_NON_EXISTENT if
 176          *  not found E_UNKOWN on error
 177          */
 178         "<method name=\"deregisterDomain\">\n"
 179             "<arg name=\"domainID\" type=\"q\" direction=\"in\" />\n"
 180             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 181         "</method>\n"
 182         /**
 183          * registers a gateway. (at)return E_OK on succes, E_ALREADY_EXISTENT if already
 184          *  registered E_UNKOWN on error
 185          */
 186         "<method name=\"registerGateway\">\n"
 187             "<arg name=\"gatewayData\" type=\"(qsqqqqqaqaqab)\" direction=\"in\" />\n"
 188             "<arg name=\"gatewayID\" type=\"q\" direction=\"out\" />\n"
 189             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 190         "</method>\n"
 191         /**
 192          * deregisters a gateway. Also removes all sinks and sources of the controlling
 193          *  domain.
 194         (at)return E_OK on succes, E_NON_EXISTENT if not found E_UNKOWN on
 195          *  error
 196          */
 197         "<method name=\"deregisterGateway\">\n"
 198             "<arg name=\"gatewayID\" type=\"q\" direction=\"in\" />\n"
 199             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 200         "</method>\n"
 201         /**
 202          * This function returns the ID to the given sinkName. If already a sink is
 203          *  registered with this name, it will return the corresponding ID, if not it will
 204          *  reserve an ID but not register the sink. The other parameters of the sink will
 205          *  be overwritten when the sink is registered.
 206         (at)return E_OK on success,
 207          *  E_UNKNOWN on error
 208          */
 209         "<method name=\"peekSink\">\n"
 210             "<arg name=\"name\" type=\"s\" direction=\"in\" />\n"
 211             "<arg name=\"sinkID\" type=\"q\" direction=\"out\" />\n"
 212             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 213         "</method>\n"
 214         /**
 215          * Registers a sink. If the sink is part of a gateway, the listconnectionFormats
 216          *  is copied to the gatewayInformation
 217         (at)return E_OK on succes,
 218          *  E_ALREADY_EXISTENT if already registered E_UNKOWN on error
 219          */
 220         "<method name=\"registerSink\">\n"
 221             "<arg name=\"sinkData\" type=\"(qsqqnb(iq)ina(qn)aqa(qn)a(qin)a(qin))\" direction=\"in\" />\n"
 222             "<arg name=\"sinkID\" type=\"q\" direction=\"out\" />\n"
 223             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 224         "</method>\n"
 225         /**
 226          * deregisters a sink.
 227         (at)return E_OK on succes, E_NON_EXISTENT if not found
 228          *  E_UNKOWN on error
 229          */
 230         "<method name=\"deregisterSink\">\n"
 231             "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n"
 232             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 233         "</method>\n"
 234         /**
 235          * This function returns the ID to the given sourceName. If already a source is
 236          *  registered with this name, it will return the corresponding ID, if not it will
 237          *  reserve an ID but not register the source. The other parameters of the source
 238          *  will be overwritten when the source is registered.
 239         (at)return E_OK on
 240          *  success, E_UNKNOWN on error
 241          */
 242         "<method name=\"peekSource\">\n"
 243             "<arg name=\"name\" type=\"s\" direction=\"in\" />\n"
 244             "<arg name=\"sourceID\" type=\"q\" direction=\"out\" />\n"
 245             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 246         "</method>\n"
 247         /**
 248          * registers a source.  If the source is part of a gateway, the
 249          *  listconnectionFormats is copied to the gatewayInformation
 250         (at)return E_OK on
 251          *  success, E_UNKNOWN on error, E_ALREADY_EXIST if either name or sourceID
 252          *  already exists
 253          */
 254         "<method name=\"registerSource\">\n"
 255             "<arg name=\"sourceData\" type=\"(qqsqinb(iq)ia(qn)aqa(qn)a(qin)a(qin))\" direction=\"in\" />\n"
 256             "<arg name=\"sourceID\" type=\"q\" direction=\"out\" />\n"
 257             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 258         "</method>\n"
 259         /**
 260          * deregisters a source
 261         (at)return E_OK on succes, E_NON_EXISTENT if not found
 262          *  E_UNKOWN on error
 263          */
 264         "<method name=\"deregisterSource\">\n"
 265             "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n"
 266             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 267         "</method>\n"
 268         /**
 269          * this function registers a crossfader.
 270         (at)return E_OK on succes,
 271          *  E_ALREADY_EXISTENT if already registered E_UNKOWN on error
 272          */
 273         "<method name=\"registerCrossfader\">\n"
 274             "<arg name=\"crossfaderData\" type=\"(qsqqqi)\" direction=\"in\" />\n"
 275             "<arg name=\"crossfaderID\" type=\"q\" direction=\"out\" />\n"
 276             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 277         "</method>\n"
 278         /**
 279          * this function deregisters a crossfader. removes all sources and sinks assiated
 280          *  as well.
 281         (at)return E_OK on succes, E_NON_EXISTENT if not found E_UNKOWN on
 282          *  error
 283          */
 284         "<method name=\"deregisterCrossfader\">\n"
 285             "<arg name=\"crossfaderID\" type=\"q\" direction=\"in\" />\n"
 286             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 287         "</method>\n"
 288         /**
 289          * this function peeks a sourceclassID. It is used by the RoutingPlugins to
 290          *  determine the SinkClassIDs of a sinkClass.
 291         (at)return E_OK on succes,
 292          *  E_DATABASE_ERROR on error
 293          */
 294         "<method name=\"peekSourceClassID\">\n"
 295             "<arg name=\"name\" type=\"s\" direction=\"in\" />\n"
 296             "<arg name=\"sourceClassID\" type=\"q\" direction=\"out\" />\n"
 297             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 298         "</method>\n"
 299         /**
 300          * this function peeks a sourceclassID. It is used by the RoutingPlugins to
 301          *  determine the SinkClassIDs of a sinkClass.
 302         (at)return E_OK on succes,
 303          *  E_DATABASE_ERROR on error
 304          */
 305         "<method name=\"peekSinkClassID\">\n"
 306             "<arg name=\"name\" type=\"s\" direction=\"in\" />\n"
 307             "<arg name=\"sinkClassID\" type=\"q\" direction=\"out\" />\n"
 308             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 309         "</method>\n"
 310         /**
 311          * is called when a low level interrupt changes it status.
 312          */
 313         "<method name=\"hookInterruptStatusChange\">\n"
 314             "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n"
 315             "<arg name=\"interruptState\" type=\"i\" direction=\"in\" />\n"
 316         "</method>\n"
 317         /**
 318          * This hook is called when all elements from a domain are registered.
 319         Is used by
 320          *  the Controller to know when all expected domains are finally registered
 321          */
 322         "<method name=\"hookDomainRegistrationComplete\">\n"
 323             "<arg name=\"domainID\" type=\"q\" direction=\"in\" />\n"
 324         "</method>\n"
 325         /**
 326          * is called when a sink changes its availability
 327          */
 328         "<method name=\"hookSinkAvailablityStatusChange\">\n"
 329             "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n"
 330             "<arg name=\"availability\" type=\"(iq)\" direction=\"in\" />\n"
 331         "</method>\n"
 332         /**
 333          * is called when a source changes its availability
 334          */
 335         "<method name=\"hookSourceAvailablityStatusChange\">\n"
 336             "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n"
 337             "<arg name=\"availability\" type=\"(iq)\" direction=\"in\" />\n"
 338         "</method>\n"
 339         /**
 340          * is called when a domain changes its status. This used for early domains only
 341          */
 342         "<method name=\"hookDomainStateChange\">\n"
 343             "<arg name=\"domainID\" type=\"q\" direction=\"in\" />\n"
 344             "<arg name=\"domainState\" type=\"i\" direction=\"in\" />\n"
 345         "</method>\n"
 346         /**
 347          * is called when the timinginformation (delay) changed for a connection.
 348          */
 349         "<method name=\"hookTimingInformationChanged\">\n"
 350             "<arg name=\"connectionID\" type=\"q\" direction=\"in\" />\n"
 351             "<arg name=\"delay\" type=\"n\" direction=\"in\" />\n"
 352         "</method>\n"
 353         /**
 354          * this function is used to send out all data that has been changed in an early
 355          *  state.
 356         (at)return E_OK on success, E_UNKNOWN on error
 357          */
 358         "<method name=\"sendChangedData\">\n"
 359             "<arg name=\"earlyData\" type=\"a(i(yv)(yv))\" direction=\"in\" />\n"
 360         "</method>\n"
 361         /**
 362          * updates data of an gateway. (at)return E_OK on success, E_NON_EXISTENT if the
 363          *  gatewayID is not valid.
 364          */
 365         "<method name=\"updateGateway\">\n"
 366             "<arg name=\"gatewayID\" type=\"q\" direction=\"in\" />\n"
 367             "<arg name=\"listSourceFormats\" type=\"aq\" direction=\"in\" />\n"
 368             "<arg name=\"listSinkFormats\" type=\"aq\" direction=\"in\" />\n"
 369             "<arg name=\"convertionMatrix\" type=\"ab\" direction=\"in\" />\n"
 370             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 371         "</method>\n"
 372         /**
 373          * updates data of an gateway. (at)return E_OK on success, E_NON_EXISTENT if the
 374          *  sinkID is not valid.
 375          */
 376         "<method name=\"updateSink\">\n"
 377             "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n"
 378             "<arg name=\"sinkClassID\" type=\"q\" direction=\"in\" />\n"
 379             "<arg name=\"listSoundProperties\" type=\"a(qn)\" direction=\"in\" />\n"
 380             "<arg name=\"listConnectionFormats\" type=\"aq\" direction=\"in\" />\n"
 381             "<arg name=\"listMainSoundProperties\" type=\"a(qn)\" direction=\"in\" />\n"
 382             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 383         "</method>\n"
 384         /**
 385          * updates data of an source. (at)return E_OK on success, E_NON_EXISTENT if the
 386          *  sourceID in the struct is not valid.
 387         Please note that only the following
 388          *  data out of am_Source_s have effect when they are
 389          *  changed:
 390         sourceClassID,
 391         listSoundProperties,
 392         listConnectionFormats,
 393          *
 394         listMainSoundProperties
 395          */
 396         "<method name=\"updateSource\">\n"
 397             "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n"
 398             "<arg name=\"sourceClassID\" type=\"q\" direction=\"in\" />\n"
 399             "<arg name=\"listSoundProperties\" type=\"a(qn)\" direction=\"in\" />\n"
 400             "<arg name=\"listConnectionFormats\" type=\"aq\" direction=\"in\" />\n"
 401             "<arg name=\"listMainSoundProperties\" type=\"a(qn)\" direction=\"in\" />\n"
 402             "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
 403         "</method>\n"
 404         /**
 405          * acknowledges a asyncSetSinkVolumes
 406          */
 407         "<method name=\"ackSetVolumes\">\n"
 408             "<arg name=\"handle\" type=\"(iq)\" direction=\"in\" />\n"
 409             "<arg name=\"listvolumes\" type=\"a(i(yv)nqn)\" direction=\"in\" />\n"
 410             "<arg name=\"error\" type=\"i\" direction=\"in\" />\n"
 411         "</method>\n"
 412         /**
 413          * The acknowledge of the SinkNotificationConfiguration
 414          */
 415         "<method name=\"ackSinkNotificationConfiguration\">\n"
 416             "<arg name=\"handle\" type=\"(iq)\" direction=\"in\" />\n"
 417             "<arg name=\"error\" type=\"i\" direction=\"in\" />\n"
 418         "</method>\n"
 419         /**
 420          * The acknowledge of the SourceNotificationConfiguration
 421          */
 422         "<method name=\"ackSourceNotificationConfiguration\">\n"
 423             "<arg name=\"handle\" type=\"(iq)\" direction=\"in\" />\n"
 424             "<arg name=\"error\" type=\"i\" direction=\"in\" />\n"
 425         "</method>\n"
 426         /**
 427          * is called whenever a notified value needs to be send
 428          */
 429         "<method name=\"hookSinkNotificationDataChange\">\n"
 430             "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n"
 431             "<arg name=\"payload\" type=\"(qn)\" direction=\"in\" />\n"
 432         "</method>\n"
 433         /**
 434          * is called whenever a notified value needs to be send
 435          */
 436         "<method name=\"hookSourceNotificationDataChange\">\n"
 437             "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n"
 438             "<arg name=\"payload\" type=\"(qn)\" direction=\"in\" />\n"
 439         "</method>\n"
 440         "<method name=\"confirmRoutingRundown\">\n"
 441             "<arg name=\"domainName\" type=\"s\" direction=\"in\" />\n"
 442         "</method>\n"
 443
 444     ;
 445     return introspectionData.c_str();
 446 }
 447
 448 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 449         RoutingControlObserverStub,
 450         CommonAPI::Version
 451         > getRoutingControlObserverInterfaceVersionStubDispatcher(&RoutingControlObserverStub::getInterfaceVersion, "uu");
 452
 453 /**
 454  * This attribute signals to the clients the current routing state.
 455 A client
 456  *  should notify himself to this attribute in order to know the current state and
 457  *  act accordingly.
 458  */
 459 static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
 460         RoutingControlObserverStub,
 461         am_RoutingReady_e
 462         > getRoutingReadyAttributeStubDispatcher(&RoutingControlObserverStub::getRoutingReadyAttribute, "i");
 463
 464
 465 /**
 466  * acknowledges a asyncConnect
 467  */
 468 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 469     RoutingControlObserverStub,
 470     std::tuple<am_Handle_s, am_connectionID_t, am_Error_e>,
 471     std::tuple<>
 472     > ackConnectStubDispatcher(&RoutingControlObserverStub::ackConnect, "");
 473 /**
 474  * acknowledges a asyncDisconnect
 475  */
 476 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 477     RoutingControlObserverStub,
 478     std::tuple<am_Handle_s, am_connectionID_t, am_Error_e>,
 479     std::tuple<>
 480     > ackDisconnectStubDispatcher(&RoutingControlObserverStub::ackDisconnect, "");
 481 /**
 482  * acknowledges a asyncsetSinkVolume
 483  */
 484 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 485     RoutingControlObserverStub,
 486     std::tuple<am_Handle_s, am_volume_t, am_Error_e>,
 487     std::tuple<>
 488     > ackSetSinkVolumeChangeStubDispatcher(&RoutingControlObserverStub::ackSetSinkVolumeChange, "");
 489 /**
 490  * acknowledges a asyncsetSourceVolume
 491  */
 492 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 493     RoutingControlObserverStub,
 494     std::tuple<am_Handle_s, am_volume_t, am_Error_e>,
 495     std::tuple<>
 496     > ackSetSourceVolumeChangeStubDispatcher(&RoutingControlObserverStub::ackSetSourceVolumeChange, "");
 497 /**
 498  * acknowlegde for asyncSetSourceState
 499  */
 500 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 501     RoutingControlObserverStub,
 502     std::tuple<am_Handle_s, am_Error_e>,
 503     std::tuple<>
 504     > ackSetSourceStateStubDispatcher(&RoutingControlObserverStub::ackSetSourceState, "");
 505 /**
 506  * acknowledges asyncSetSinkSoundProperties
 507  */
 508 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 509     RoutingControlObserverStub,
 510     std::tuple<am_Handle_s, am_Error_e>,
 511     std::tuple<>
 512     > ackSetSinkSoundPropertiesStubDispatcher(&RoutingControlObserverStub::ackSetSinkSoundProperties, "");
 513 /**
 514  * acknowledges asyncSetSinkSoundProperty
 515  */
 516 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 517     RoutingControlObserverStub,
 518     std::tuple<am_Handle_s, am_Error_e>,
 519     std::tuple<>
 520     > ackSetSinkSoundPropertyStubDispatcher(&RoutingControlObserverStub::ackSetSinkSoundProperty, "");
 521 /**
 522  * acknowledges asyncSetSourceSoundProperties
 523  */
 524 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 525     RoutingControlObserverStub,
 526     std::tuple<am_Handle_s, am_Error_e>,
 527     std::tuple<>
 528     > ackSetSourceSoundPropertiesStubDispatcher(&RoutingControlObserverStub::ackSetSourceSoundProperties, "");
 529 /**
 530  * acknowledges asyncSetSourceSoundProperty
 531  */
 532 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 533     RoutingControlObserverStub,
 534     std::tuple<am_Handle_s, am_Error_e>,
 535     std::tuple<>
 536     > ackSetSourceSoundPropertyStubDispatcher(&RoutingControlObserverStub::ackSetSourceSoundProperty, "");
 537 /**
 538  * acknowledges asyncCrossFade
 539  */
 540 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 541     RoutingControlObserverStub,
 542     std::tuple<am_Handle_s, am_HotSink_e, am_Error_e>,
 543     std::tuple<>
 544     > ackCrossFadingStubDispatcher(&RoutingControlObserverStub::ackCrossFading, "");
 545 /**
 546  * acknowledges a volume tick. This can be used to display volumechanges during
 547  *  ramps
 548  */
 549 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 550     RoutingControlObserverStub,
 551     std::tuple<am_Handle_s, am_sourceID_t, am_volume_t>,
 552     std::tuple<>
 553     > ackSourceVolumeTickStubDispatcher(&RoutingControlObserverStub::ackSourceVolumeTick, "");
 554 /**
 555  * acknowledges a volume tick. This can be used to display volumechanges during
 556  *  ramps
 557  */
 558 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 559     RoutingControlObserverStub,
 560     std::tuple<am_Handle_s, am_sinkID_t, am_volume_t>,
 561     std::tuple<>
 562     > ackSinkVolumeTickStubDispatcher(&RoutingControlObserverStub::ackSinkVolumeTick, "");
 563 /**
 564  * This function returns the ID to the given domainName. If already a domain is
 565  *  registered with this name, it will return the corresponding ID, if not it will
 566  *  reserve an ID but not register the domain. The other parameters of the domain
 567  *  will be overwritten when the domain is registered.
 568 (at)return E_OK on
 569  *  success, E_UNKNOWN on error
 570  */
 571 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 572     RoutingControlObserverStub,
 573     std::tuple<std::string>,
 574     std::tuple<am_domainID_t, am_Error_e>
 575     > peekDomainStubDispatcher(&RoutingControlObserverStub::peekDomain, "qi");
 576 /**
 577  * registers a domain
 578 (at)return E_OK on succes, E_ALREADY_EXISTENT if already
 579  *  registered E_UNKOWN on error
 580  */
 581 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 582     RoutingControlObserverStub,
 583     std::tuple<am_Domain_s, std::string, std::string>,
 584     std::tuple<am_domainID_t, am_Error_e>
 585     > registerDomainStubDispatcher(&RoutingControlObserverStub::registerDomain, "qi");
 586 /**
 587  * deregisters a domain. All sources, sinks, gateways and crossfaders from that
 588  *  domain will be removed as well.
 589 (at)return E_OK on succes, E_NON_EXISTENT if
 590  *  not found E_UNKOWN on error
 591  */
 592 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 593     RoutingControlObserverStub,
 594     std::tuple<am_domainID_t>,
 595     std::tuple<am_Error_e>
 596     > deregisterDomainStubDispatcher(&RoutingControlObserverStub::deregisterDomain, "i");
 597 /**
 598  * registers a gateway. (at)return E_OK on succes, E_ALREADY_EXISTENT if already
 599  *  registered E_UNKOWN on error
 600  */
 601 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 602     RoutingControlObserverStub,
 603     std::tuple<am_Gateway_s>,
 604     std::tuple<am_gatewayID_t, am_Error_e>
 605     > registerGatewayStubDispatcher(&RoutingControlObserverStub::registerGateway, "qi");
 606 /**
 607  * deregisters a gateway. Also removes all sinks and sources of the controlling
 608  *  domain.
 609 (at)return E_OK on succes, E_NON_EXISTENT if not found E_UNKOWN on
 610  *  error
 611  */
 612 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 613     RoutingControlObserverStub,
 614     std::tuple<am_gatewayID_t>,
 615     std::tuple<am_Error_e>
 616     > deregisterGatewayStubDispatcher(&RoutingControlObserverStub::deregisterGateway, "i");
 617 /**
 618  * This function returns the ID to the given sinkName. If already a sink is
 619  *  registered with this name, it will return the corresponding ID, if not it will
 620  *  reserve an ID but not register the sink. The other parameters of the sink will
 621  *  be overwritten when the sink is registered.
 622 (at)return E_OK on success,
 623  *  E_UNKNOWN on error
 624  */
 625 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 626     RoutingControlObserverStub,
 627     std::tuple<std::string>,
 628     std::tuple<am_sinkID_t, am_Error_e>
 629     > peekSinkStubDispatcher(&RoutingControlObserverStub::peekSink, "qi");
 630 /**
 631  * Registers a sink. If the sink is part of a gateway, the listconnectionFormats
 632  *  is copied to the gatewayInformation
 633 (at)return E_OK on succes,
 634  *  E_ALREADY_EXISTENT if already registered E_UNKOWN on error
 635  */
 636 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 637     RoutingControlObserverStub,
 638     std::tuple<am_Sink_s>,
 639     std::tuple<am_sinkID_t, am_Error_e>
 640     > registerSinkStubDispatcher(&RoutingControlObserverStub::registerSink, "qi");
 641 /**
 642  * deregisters a sink.
 643 (at)return E_OK on succes, E_NON_EXISTENT if not found
 644  *  E_UNKOWN on error
 645  */
 646 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 647     RoutingControlObserverStub,
 648     std::tuple<am_sinkID_t>,
 649     std::tuple<am_Error_e>
 650     > deregisterSinkStubDispatcher(&RoutingControlObserverStub::deregisterSink, "i");
 651 /**
 652  * This function returns the ID to the given sourceName. If already a source is
 653  *  registered with this name, it will return the corresponding ID, if not it will
 654  *  reserve an ID but not register the source. The other parameters of the source
 655  *  will be overwritten when the source is registered.
 656 (at)return E_OK on
 657  *  success, E_UNKNOWN on error
 658  */
 659 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 660     RoutingControlObserverStub,
 661     std::tuple<std::string>,
 662     std::tuple<am_sourceID_t, am_Error_e>
 663     > peekSourceStubDispatcher(&RoutingControlObserverStub::peekSource, "qi");
 664 /**
 665  * registers a source.  If the source is part of a gateway, the
 666  *  listconnectionFormats is copied to the gatewayInformation
 667 (at)return E_OK on
 668  *  success, E_UNKNOWN on error, E_ALREADY_EXIST if either name or sourceID
 669  *  already exists
 670  */
 671 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 672     RoutingControlObserverStub,
 673     std::tuple<am_Source_s>,
 674     std::tuple<am_sourceID_t, am_Error_e>
 675     > registerSourceStubDispatcher(&RoutingControlObserverStub::registerSource, "qi");
 676 /**
 677  * deregisters a source
 678 (at)return E_OK on succes, E_NON_EXISTENT if not found
 679  *  E_UNKOWN on error
 680  */
 681 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 682     RoutingControlObserverStub,
 683     std::tuple<am_sourceID_t>,
 684     std::tuple<am_Error_e>
 685     > deregisterSourceStubDispatcher(&RoutingControlObserverStub::deregisterSource, "i");
 686 /**
 687  * this function registers a crossfader.
 688 (at)return E_OK on succes,
 689  *  E_ALREADY_EXISTENT if already registered E_UNKOWN on error
 690  */
 691 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 692     RoutingControlObserverStub,
 693     std::tuple<am_Crossfader_s>,
 694     std::tuple<am_crossfaderID_t, am_Error_e>
 695     > registerCrossfaderStubDispatcher(&RoutingControlObserverStub::registerCrossfader, "qi");
 696 /**
 697  * this function deregisters a crossfader. removes all sources and sinks assiated
 698  *  as well.
 699 (at)return E_OK on succes, E_NON_EXISTENT if not found E_UNKOWN on
 700  *  error
 701  */
 702 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 703     RoutingControlObserverStub,
 704     std::tuple<am_crossfaderID_t>,
 705     std::tuple<am_Error_e>
 706     > deregisterCrossfaderStubDispatcher(&RoutingControlObserverStub::deregisterCrossfader, "i");
 707 /**
 708  * this function peeks a sourceclassID. It is used by the RoutingPlugins to
 709  *  determine the SinkClassIDs of a sinkClass.
 710 (at)return E_OK on succes,
 711  *  E_DATABASE_ERROR on error
 712  */
 713 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 714     RoutingControlObserverStub,
 715     std::tuple<std::string>,
 716     std::tuple<am_sourceClass_t, am_Error_e>
 717     > peekSourceClassIDStubDispatcher(&RoutingControlObserverStub::peekSourceClassID, "qi");
 718 /**
 719  * this function peeks a sourceclassID. It is used by the RoutingPlugins to
 720  *  determine the SinkClassIDs of a sinkClass.
 721 (at)return E_OK on succes,
 722  *  E_DATABASE_ERROR on error
 723  */
 724 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 725     RoutingControlObserverStub,
 726     std::tuple<std::string>,
 727     std::tuple<am_sinkClass_t, am_Error_e>
 728     > peekSinkClassIDStubDispatcher(&RoutingControlObserverStub::peekSinkClassID, "qi");
 729 /**
 730  * is called when a low level interrupt changes it status.
 731  */
 732 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 733     RoutingControlObserverStub,
 734     std::tuple<am_sourceID_t, am_InterruptState_e>,
 735     std::tuple<>
 736     > hookInterruptStatusChangeStubDispatcher(&RoutingControlObserverStub::hookInterruptStatusChange, "");
 737 /**
 738  * This hook is called when all elements from a domain are registered.
 739 Is used by
 740  *  the Controller to know when all expected domains are finally registered
 741  */
 742 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 743     RoutingControlObserverStub,
 744     std::tuple<am_domainID_t>,
 745     std::tuple<>
 746     > hookDomainRegistrationCompleteStubDispatcher(&RoutingControlObserverStub::hookDomainRegistrationComplete, "");
 747 /**
 748  * is called when a sink changes its availability
 749  */
 750 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 751     RoutingControlObserverStub,
 752     std::tuple<am_sinkID_t, am_Availability_s>,
 753     std::tuple<>
 754     > hookSinkAvailablityStatusChangeStubDispatcher(&RoutingControlObserverStub::hookSinkAvailablityStatusChange, "");
 755 /**
 756  * is called when a source changes its availability
 757  */
 758 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 759     RoutingControlObserverStub,
 760     std::tuple<am_sourceID_t, am_Availability_s>,
 761     std::tuple<>
 762     > hookSourceAvailablityStatusChangeStubDispatcher(&RoutingControlObserverStub::hookSourceAvailablityStatusChange, "");
 763 /**
 764  * is called when a domain changes its status. This used for early domains only
 765  */
 766 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 767     RoutingControlObserverStub,
 768     std::tuple<am_domainID_t, am_DomainState_e>,
 769     std::tuple<>
 770     > hookDomainStateChangeStubDispatcher(&RoutingControlObserverStub::hookDomainStateChange, "");
 771 /**
 772  * is called when the timinginformation (delay) changed for a connection.
 773  */
 774 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 775     RoutingControlObserverStub,
 776     std::tuple<am_connectionID_t, am_timeSync_t>,
 777     std::tuple<>
 778     > hookTimingInformationChangedStubDispatcher(&RoutingControlObserverStub::hookTimingInformationChanged, "");
 779 /**
 780  * this function is used to send out all data that has been changed in an early
 781  *  state.
 782 (at)return E_OK on success, E_UNKNOWN on error
 783  */
 784 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 785     RoutingControlObserverStub,
 786     std::tuple<am_EarlyData_L>,
 787     std::tuple<>
 788     > sendChangedDataStubDispatcher(&RoutingControlObserverStub::sendChangedData, "");
 789 /**
 790  * updates data of an gateway. (at)return E_OK on success, E_NON_EXISTENT if the
 791  *  gatewayID is not valid.
 792  */
 793 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 794     RoutingControlObserverStub,
 795     std::tuple<am_gatewayID_t, am_ConnectionFormat_L, am_ConnectionFormat_L, am_Convertion_L>,
 796     std::tuple<am_Error_e>
 797     > updateGatewayStubDispatcher(&RoutingControlObserverStub::updateGateway, "i");
 798 /**
 799  * updates data of an gateway. (at)return E_OK on success, E_NON_EXISTENT if the
 800  *  sinkID is not valid.
 801  */
 802 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 803     RoutingControlObserverStub,
 804     std::tuple<am_sinkID_t, am_sinkClass_t, am_SoundProperty_L, am_ConnectionFormat_L, am_MainSoundProperty_L>,
 805     std::tuple<am_Error_e>
 806     > updateSinkStubDispatcher(&RoutingControlObserverStub::updateSink, "i");
 807 /**
 808  * updates data of an source. (at)return E_OK on success, E_NON_EXISTENT if the
 809  *  sourceID in the struct is not valid.
 810 Please note that only the following
 811  *  data out of am_Source_s have effect when they are
 812  *  changed:
 813 sourceClassID,
 814 listSoundProperties,
 815 listConnectionFormats,
 816  *
 817 listMainSoundProperties
 818  */
 819 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 820     RoutingControlObserverStub,
 821     std::tuple<am_sourceID_t, am_sourceClass_t, am_SoundProperty_L, am_ConnectionFormat_L, am_MainSoundProperty_L>,
 822     std::tuple<am_Error_e>
 823     > updateSourceStubDispatcher(&RoutingControlObserverStub::updateSource, "i");
 824 /**
 825  * acknowledges a asyncSetSinkVolumes
 826  */
 827 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 828     RoutingControlObserverStub,
 829     std::tuple<am_Handle_s, am_Volumes_L, am_Error_e>,
 830     std::tuple<>
 831     > ackSetVolumesStubDispatcher(&RoutingControlObserverStub::ackSetVolumes, "");
 832 /**
 833  * The acknowledge of the SinkNotificationConfiguration
 834  */
 835 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 836     RoutingControlObserverStub,
 837     std::tuple<am_Handle_s, am_Error_e>,
 838     std::tuple<>
 839     > ackSinkNotificationConfigurationStubDispatcher(&RoutingControlObserverStub::ackSinkNotificationConfiguration, "");
 840 /**
 841  * The acknowledge of the SourceNotificationConfiguration
 842  */
 843 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 844     RoutingControlObserverStub,
 845     std::tuple<am_Handle_s, am_Error_e>,
 846     std::tuple<>
 847     > ackSourceNotificationConfigurationStubDispatcher(&RoutingControlObserverStub::ackSourceNotificationConfiguration, "");
 848 /**
 849  * is called whenever a notified value needs to be send
 850  */
 851 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 852     RoutingControlObserverStub,
 853     std::tuple<am_sinkID_t, am_NotificationPayload_s>,
 854     std::tuple<>
 855     > hookSinkNotificationDataChangeStubDispatcher(&RoutingControlObserverStub::hookSinkNotificationDataChange, "");
 856 /**
 857  * is called whenever a notified value needs to be send
 858  */
 859 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 860     RoutingControlObserverStub,
 861     std::tuple<am_sourceID_t, am_NotificationPayload_s>,
 862     std::tuple<>
 863     > hookSourceNotificationDataChangeStubDispatcher(&RoutingControlObserverStub::hookSourceNotificationDataChange, "");
 864 static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
 865     RoutingControlObserverStub,
 866     std::tuple<std::string>,
 867     std::tuple<>
 868     > confirmRoutingRundownStubDispatcher(&RoutingControlObserverStub::confirmRoutingRundown, "");
 869
 870 /**
 871  * This attribute signals to the clients the current routing state.
 872 A client
 873  *  should notify himself to this attribute in order to know the current state and
 874  *  act accordingly.
 875  */
 876 void RoutingControlObserverDBusStubAdapterInternal::fireRoutingReadyAttributeChanged(const am_RoutingReady_e& value) {
 877     CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_RoutingReady_e>>
 878         ::sendSignal(
 879             *this,
 880             "onRoutingReadyAttributeChanged",
 881             "i",
 882             value
 883     );
 884 }
 885
 886
 887 const RoutingControlObserverDBusStubAdapterHelper::StubDispatcherTable& RoutingControlObserverDBusStubAdapterInternal::getStubDispatcherTable() {
 888     return stubDispatcherTable_;
 889 }
 890
 891
 892 RoutingControlObserverDBusStubAdapterInternal::RoutingControlObserverDBusStubAdapterInternal(
 893         const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
 894         const std::string& commonApiAddress,
 895         const std::string& dbusInterfaceName,
 896         const std::string& dbusBusName,
 897         const std::string& dbusObjectPath,
 898         const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection,
 899         const std::shared_ptr<CommonAPI::StubBase>& stub):
 900         CommonAPI::DBus::DBusStubAdapter(
 901                 factory,
 902                 commonApiAddress,
 903                 dbusInterfaceName,
 904                 dbusBusName,
 905                 dbusObjectPath,
 906                 dbusConnection,
 907                 false),
 908         RoutingControlObserverDBusStubAdapterHelper(
 909             factory,
 910             commonApiAddress,
 911             dbusInterfaceName,
 912             dbusBusName,
 913             dbusObjectPath,
 914             dbusConnection,
 915             std::dynamic_pointer_cast<RoutingControlObserverStub>(stub),
 916             false),
 917         stubDispatcherTable_({
 918             /**
 919              * This attribute signals to the clients the current routing state.
 920             A client
 921              *  should notify himself to this attribute in order to know the current state and
 922              *  act accordingly.
 923              */
 924             { { "getRoutingReadyAttribute", "" }, &org::genivi::am::getRoutingReadyAttributeStubDispatcher }
 925             ,
 926             /**
 927              * acknowledges a asyncConnect
 928              */
 929             { { "ackConnect", "(iq)qi" }, &org::genivi::am::ackConnectStubDispatcher },
 930             /**
 931              * acknowledges a asyncDisconnect
 932              */
 933             { { "ackDisconnect", "(iq)qi" }, &org::genivi::am::ackDisconnectStubDispatcher },
 934             /**
 935              * acknowledges a asyncsetSinkVolume
 936              */
 937             { { "ackSetSinkVolumeChange", "(iq)ni" }, &org::genivi::am::ackSetSinkVolumeChangeStubDispatcher },
 938             /**
 939              * acknowledges a asyncsetSourceVolume
 940              */
 941             { { "ackSetSourceVolumeChange", "(iq)ni" }, &org::genivi::am::ackSetSourceVolumeChangeStubDispatcher },
 942             /**
 943              * acknowlegde for asyncSetSourceState
 944              */
 945             { { "ackSetSourceState", "(iq)i" }, &org::genivi::am::ackSetSourceStateStubDispatcher },
 946             /**
 947              * acknowledges asyncSetSinkSoundProperties
 948              */
 949             { { "ackSetSinkSoundProperties", "(iq)i" }, &org::genivi::am::ackSetSinkSoundPropertiesStubDispatcher },
 950             /**
 951              * acknowledges asyncSetSinkSoundProperty
 952              */
 953             { { "ackSetSinkSoundProperty", "(iq)i" }, &org::genivi::am::ackSetSinkSoundPropertyStubDispatcher },
 954             /**
 955              * acknowledges asyncSetSourceSoundProperties
 956              */
 957             { { "ackSetSourceSoundProperties", "(iq)i" }, &org::genivi::am::ackSetSourceSoundPropertiesStubDispatcher },
 958             /**
 959              * acknowledges asyncSetSourceSoundProperty
 960              */
 961             { { "ackSetSourceSoundProperty", "(iq)i" }, &org::genivi::am::ackSetSourceSoundPropertyStubDispatcher },
 962             /**
 963              * acknowledges asyncCrossFade
 964              */
 965             { { "ackCrossFading", "(iq)ii" }, &org::genivi::am::ackCrossFadingStubDispatcher },
 966             /**
 967              * acknowledges a volume tick. This can be used to display volumechanges during
 968              *  ramps
 969              */
 970             { { "ackSourceVolumeTick", "(iq)qn" }, &org::genivi::am::ackSourceVolumeTickStubDispatcher },
 971             /**
 972              * acknowledges a volume tick. This can be used to display volumechanges during
 973              *  ramps
 974              */
 975             { { "ackSinkVolumeTick", "(iq)qn" }, &org::genivi::am::ackSinkVolumeTickStubDispatcher },
 976             /**
 977              * This function returns the ID to the given domainName. If already a domain is
 978              *  registered with this name, it will return the corresponding ID, if not it will
 979              *  reserve an ID but not register the domain. The other parameters of the domain
 980              *  will be overwritten when the domain is registered.
 981             (at)return E_OK on
 982              *  success, E_UNKNOWN on error
 983              */
 984             { { "peekDomain", "s" }, &org::genivi::am::peekDomainStubDispatcher },
 985             /**
 986              * registers a domain
 987             (at)return E_OK on succes, E_ALREADY_EXISTENT if already
 988              *  registered E_UNKOWN on error
 989              */
 990             { { "registerDomain", "(qsssbbi)ss" }, &org::genivi::am::registerDomainStubDispatcher },
 991             /**
 992              * deregisters a domain. All sources, sinks, gateways and crossfaders from that
 993              *  domain will be removed as well.
 994             (at)return E_OK on succes, E_NON_EXISTENT if
 995              *  not found E_UNKOWN on error
 996              */
 997             { { "deregisterDomain", "q" }, &org::genivi::am::deregisterDomainStubDispatcher },
 998             /**
 999              * registers a gateway. (at)return E_OK on succes, E_ALREADY_EXISTENT if already
1000              *  registered E_UNKOWN on error
1001              */
1002             { { "registerGateway", "(qsqqqqqaqaqab)" }, &org::genivi::am::registerGatewayStubDispatcher },
1003             /**
1004              * deregisters a gateway. Also removes all sinks and sources of the controlling
1005              *  domain.
1006             (at)return E_OK on succes, E_NON_EXISTENT if not found E_UNKOWN on
1007              *  error
1008              */
1009             { { "deregisterGateway", "q" }, &org::genivi::am::deregisterGatewayStubDispatcher },
1010             /**
1011              * This function returns the ID to the given sinkName. If already a sink is
1012              *  registered with this name, it will return the corresponding ID, if not it will
1013              *  reserve an ID but not register the sink. The other parameters of the sink will
1014              *  be overwritten when the sink is registered.
1015             (at)return E_OK on success,
1016              *  E_UNKNOWN on error
1017              */
1018             { { "peekSink", "s" }, &org::genivi::am::peekSinkStubDispatcher },
1019             /**
1020              * Registers a sink. If the sink is part of a gateway, the listconnectionFormats
1021              *  is copied to the gatewayInformation
1022             (at)return E_OK on succes,
1023              *  E_ALREADY_EXISTENT if already registered E_UNKOWN on error
1024              */
1025             { { "registerSink", "(qsqqnb(iq)ina(qn)aqa(qn)a(qin)a(qin))" }, &org::genivi::am::registerSinkStubDispatcher },
1026             /**
1027              * deregisters a sink.
1028             (at)return E_OK on succes, E_NON_EXISTENT if not found
1029              *  E_UNKOWN on error
1030              */
1031             { { "deregisterSink", "q" }, &org::genivi::am::deregisterSinkStubDispatcher },
1032             /**
1033              * This function returns the ID to the given sourceName. If already a source is
1034              *  registered with this name, it will return the corresponding ID, if not it will
1035              *  reserve an ID but not register the source. The other parameters of the source
1036              *  will be overwritten when the source is registered.
1037             (at)return E_OK on
1038              *  success, E_UNKNOWN on error
1039              */
1040             { { "peekSource", "s" }, &org::genivi::am::peekSourceStubDispatcher },
1041             /**
1042              * registers a source.  If the source is part of a gateway, the
1043              *  listconnectionFormats is copied to the gatewayInformation
1044             (at)return E_OK on
1045              *  success, E_UNKNOWN on error, E_ALREADY_EXIST if either name or sourceID
1046              *  already exists
1047              */
1048             { { "registerSource", "(qqsqinb(iq)ia(qn)aqa(qn)a(qin)a(qin))" }, &org::genivi::am::registerSourceStubDispatcher },
1049             /**
1050              * deregisters a source
1051             (at)return E_OK on succes, E_NON_EXISTENT if not found
1052              *  E_UNKOWN on error
1053              */
1054             { { "deregisterSource", "q" }, &org::genivi::am::deregisterSourceStubDispatcher },
1055             /**
1056              * this function registers a crossfader.
1057             (at)return E_OK on succes,
1058              *  E_ALREADY_EXISTENT if already registered E_UNKOWN on error
1059              */
1060             { { "registerCrossfader", "(qsqqqi)" }, &org::genivi::am::registerCrossfaderStubDispatcher },
1061             /**
1062              * this function deregisters a crossfader. removes all sources and sinks assiated
1063              *  as well.
1064             (at)return E_OK on succes, E_NON_EXISTENT if not found E_UNKOWN on
1065              *  error
1066              */
1067             { { "deregisterCrossfader", "q" }, &org::genivi::am::deregisterCrossfaderStubDispatcher },
1068             /**
1069              * this function peeks a sourceclassID. It is used by the RoutingPlugins to
1070              *  determine the SinkClassIDs of a sinkClass.
1071             (at)return E_OK on succes,
1072              *  E_DATABASE_ERROR on error
1073              */
1074             { { "peekSourceClassID", "s" }, &org::genivi::am::peekSourceClassIDStubDispatcher },
1075             /**
1076              * this function peeks a sourceclassID. It is used by the RoutingPlugins to
1077              *  determine the SinkClassIDs of a sinkClass.
1078             (at)return E_OK on succes,
1079              *  E_DATABASE_ERROR on error
1080              */
1081             { { "peekSinkClassID", "s" }, &org::genivi::am::peekSinkClassIDStubDispatcher },
1082             /**
1083              * is called when a low level interrupt changes it status.
1084              */
1085             { { "hookInterruptStatusChange", "qi" }, &org::genivi::am::hookInterruptStatusChangeStubDispatcher },
1086             /**
1087              * This hook is called when all elements from a domain are registered.
1088             Is used by
1089              *  the Controller to know when all expected domains are finally registered
1090              */
1091             { { "hookDomainRegistrationComplete", "q" }, &org::genivi::am::hookDomainRegistrationCompleteStubDispatcher },
1092             /**
1093              * is called when a sink changes its availability
1094              */
1095             { { "hookSinkAvailablityStatusChange", "q(iq)" }, &org::genivi::am::hookSinkAvailablityStatusChangeStubDispatcher },
1096             /**
1097              * is called when a source changes its availability
1098              */
1099             { { "hookSourceAvailablityStatusChange", "q(iq)" }, &org::genivi::am::hookSourceAvailablityStatusChangeStubDispatcher },
1100             /**
1101              * is called when a domain changes its status. This used for early domains only
1102              */
1103             { { "hookDomainStateChange", "qi" }, &org::genivi::am::hookDomainStateChangeStubDispatcher },
1104             /**
1105              * is called when the timinginformation (delay) changed for a connection.
1106              */
1107             { { "hookTimingInformationChanged", "qn" }, &org::genivi::am::hookTimingInformationChangedStubDispatcher },
1108             /**
1109              * this function is used to send out all data that has been changed in an early
1110              *  state.
1111             (at)return E_OK on success, E_UNKNOWN on error
1112              */
1113             { { "sendChangedData", "a(i(yv)(yv))" }, &org::genivi::am::sendChangedDataStubDispatcher },
1114             /**
1115              * updates data of an gateway. (at)return E_OK on success, E_NON_EXISTENT if the
1116              *  gatewayID is not valid.
1117              */
1118             { { "updateGateway", "qaqaqab" }, &org::genivi::am::updateGatewayStubDispatcher },
1119             /**
1120              * updates data of an gateway. (at)return E_OK on success, E_NON_EXISTENT if the
1121              *  sinkID is not valid.
1122              */
1123             { { "updateSink", "qqa(qn)aqa(qn)" }, &org::genivi::am::updateSinkStubDispatcher },
1124             /**
1125              * updates data of an source. (at)return E_OK on success, E_NON_EXISTENT if the
1126              *  sourceID in the struct is not valid.
1127             Please note that only the following
1128              *  data out of am_Source_s have effect when they are
1129              *  changed:
1130             sourceClassID,
1131             listSoundProperties,
1132             listConnectionFormats,
1133              *
1134             listMainSoundProperties
1135              */
1136             { { "updateSource", "qqa(qn)aqa(qn)" }, &org::genivi::am::updateSourceStubDispatcher },
1137             /**
1138              * acknowledges a asyncSetSinkVolumes
1139              */
1140             { { "ackSetVolumes", "(iq)a(i(yv)nqn)i" }, &org::genivi::am::ackSetVolumesStubDispatcher },
1141             /**
1142              * The acknowledge of the SinkNotificationConfiguration
1143              */
1144             { { "ackSinkNotificationConfiguration", "(iq)i" }, &org::genivi::am::ackSinkNotificationConfigurationStubDispatcher },
1145             /**
1146              * The acknowledge of the SourceNotificationConfiguration
1147              */
1148             { { "ackSourceNotificationConfiguration", "(iq)i" }, &org::genivi::am::ackSourceNotificationConfigurationStubDispatcher },
1149             /**
1150              * is called whenever a notified value needs to be send
1151              */
1152             { { "hookSinkNotificationDataChange", "q(qn)" }, &org::genivi::am::hookSinkNotificationDataChangeStubDispatcher },
1153             /**
1154              * is called whenever a notified value needs to be send
1155              */
1156             { { "hookSourceNotificationDataChange", "q(qn)" }, &org::genivi::am::hookSourceNotificationDataChangeStubDispatcher },
1157             { { "confirmRoutingRundown", "s" }, &org::genivi::am::confirmRoutingRundownStubDispatcher }
1158             }) {
1159
1160     stubDispatcherTable_.insert({ { "getInterfaceVersion", "" }, &org::genivi::am::getRoutingControlObserverInterfaceVersionStubDispatcher });
1161 }
1162
1163 } // namespace am
1164 } // namespace genivi
1165 } // namespace org