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