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