PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusProxy.cpp

   1 /*
   2 * This file was generated by the CommonAPI Generators.
   3 *
   4 * This file was generated by the CommonAPI Generators.
   5 *
   6 * This file was generated by the CommonAPI Generators.
   7 *
   8 * Copyright (C) 2012, BMW AG
   9 *
  10 * This file is part of GENIVI Project AudioManager.
  11 *
  12 * Contributions are licensed to the GENIVI Alliance under one or more
  13 * Contribution License Agreements.
  14 *
  15 * \copyright
  16 * This Source Code Form is subject to the terms of the
  17 * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
  18 * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
  19 *
  20 *
  21 * \author Aleksandar Donchev, aleksander.donchev@partner.bmw.de BMW 2013
  22 * \author Christian Linke christian.linke@bmw.de BMW 2013
  23 *
  24 * For further information see http://www.genivi.org/.
  25 */
  26 #include "CommandControlDBusProxy.h"
  27
  28 namespace org {
  29 namespace genivi {
  30 namespace am {
  31
  32 std::shared_ptr<CommonAPI::DBus::DBusProxy> createCommandControlDBusProxy(
  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<CommandControlDBusProxy>(commonApiAddress, interfaceName, busName, objectPath, dbusProxyConnection);
  39 }
  40
  41 __attribute__((constructor)) void registerCommandControlDBusProxy(void) {
  42     CommonAPI::DBus::DBusFactory::registerProxyFactoryMethod(CommandControl::getInterfaceId(),
  43        &createCommandControlDBusProxy);
  44 }
  45
  46 CommandControlDBusProxy::CommandControlDBusProxy(
  47                     const std::string& commonApiAddress,
  48                     const std::string& interfaceName,
  49                     const std::string& busName,
  50                     const std::string& objectPath,
  51                     const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyconnection):
  52         CommonAPI::DBus::DBusProxy(commonApiAddress, interfaceName, busName, objectPath, dbusProxyconnection)
  53 ,        newMainConnection_(*this, "newMainConnection", "(qqqni)"),
  54                         removedMainConnection_(*this, "removedMainConnection", "q"),
  55                         newSink_(*this, "newSink", "(qs(iq)niq)"),
  56                         removedSink_(*this, "removedSink", "q"),
  57                         newSource_(*this, "newSource", "(qs(iq)q)"),
  58                         removedSource_(*this, "removedSource", "q"),
  59                         numberOfSinkClassesChanged_(*this, "numberOfSinkClassesChanged", ""),
  60                         numberOfSourceClassesChanged_(*this, "numberOfSourceClassesChanged", ""),
  61                         mainConnectionStateChanged_(*this, "mainConnectionStateChanged", "qi"),
  62                         mainSinkSoundPropertyChanged_(*this, "mainSinkSoundPropertyChanged", "q(qn)"),
  63                         mainSourceSoundPropertyChanged_(*this, "mainSourceSoundPropertyChanged", "q(qn)"),
  64                         sinkAvailabilityChanged_(*this, "sinkAvailabilityChanged", "q(iq)"),
  65                         sourceAvailabilityChanged_(*this, "sourceAvailabilityChanged", "q(iq)"),
  66                         volumeChanged_(*this, "volumeChanged", "qn"),
  67                         sinkMuteStateChanged_(*this, "sinkMuteStateChanged", "qi"),
  68                         systemPropertyChanged_(*this, "systemPropertyChanged", "(qn)"),
  69                         timingInformationChanged_(*this, "timingInformationChanged", "qn"),
  70                         sinkUpdated_(*this, "sinkUpdated", "qqa(qn)"),
  71                         sourceUpdated_(*this, "sourceUpdated", "qqa(qn)"),
  72                         sinkNotification_(*this, "sinkNotification", "q(qn)"),
  73                         sourceNotification_(*this, "sourceNotification", "q(qn)"),
  74                         mainSinkNotificationConfigurationChanged_(*this, "mainSinkNotificationConfigurationChanged", "q(qin)"),
  75                         mainSourceNotificationConfigurationChanged_(*this, "mainSourceNotificationConfigurationChanged", "q(qin)")
  76                  {
  77 }
  78
  79
  80 CommandControlDBusProxy::NewMainConnectionEvent& CommandControlDBusProxy::getNewMainConnectionEvent() {
  81     return newMainConnection_;
  82 }
  83 CommandControlDBusProxy::RemovedMainConnectionEvent& CommandControlDBusProxy::getRemovedMainConnectionEvent() {
  84     return removedMainConnection_;
  85 }
  86 CommandControlDBusProxy::NewSinkEvent& CommandControlDBusProxy::getNewSinkEvent() {
  87     return newSink_;
  88 }
  89 CommandControlDBusProxy::RemovedSinkEvent& CommandControlDBusProxy::getRemovedSinkEvent() {
  90     return removedSink_;
  91 }
  92 CommandControlDBusProxy::NewSourceEvent& CommandControlDBusProxy::getNewSourceEvent() {
  93     return newSource_;
  94 }
  95 CommandControlDBusProxy::RemovedSourceEvent& CommandControlDBusProxy::getRemovedSourceEvent() {
  96     return removedSource_;
  97 }
  98 CommandControlDBusProxy::NumberOfSinkClassesChangedEvent& CommandControlDBusProxy::getNumberOfSinkClassesChangedEvent() {
  99     return numberOfSinkClassesChanged_;
 100 }
 101 CommandControlDBusProxy::NumberOfSourceClassesChangedEvent& CommandControlDBusProxy::getNumberOfSourceClassesChangedEvent() {
 102     return numberOfSourceClassesChanged_;
 103 }
 104 CommandControlDBusProxy::MainConnectionStateChangedEvent& CommandControlDBusProxy::getMainConnectionStateChangedEvent() {
 105     return mainConnectionStateChanged_;
 106 }
 107 CommandControlDBusProxy::MainSinkSoundPropertyChangedEvent& CommandControlDBusProxy::getMainSinkSoundPropertyChangedEvent() {
 108     return mainSinkSoundPropertyChanged_;
 109 }
 110 CommandControlDBusProxy::MainSourceSoundPropertyChangedEvent& CommandControlDBusProxy::getMainSourceSoundPropertyChangedEvent() {
 111     return mainSourceSoundPropertyChanged_;
 112 }
 113 CommandControlDBusProxy::SinkAvailabilityChangedEvent& CommandControlDBusProxy::getSinkAvailabilityChangedEvent() {
 114     return sinkAvailabilityChanged_;
 115 }
 116 CommandControlDBusProxy::SourceAvailabilityChangedEvent& CommandControlDBusProxy::getSourceAvailabilityChangedEvent() {
 117     return sourceAvailabilityChanged_;
 118 }
 119 CommandControlDBusProxy::VolumeChangedEvent& CommandControlDBusProxy::getVolumeChangedEvent() {
 120     return volumeChanged_;
 121 }
 122 CommandControlDBusProxy::SinkMuteStateChangedEvent& CommandControlDBusProxy::getSinkMuteStateChangedEvent() {
 123     return sinkMuteStateChanged_;
 124 }
 125 CommandControlDBusProxy::SystemPropertyChangedEvent& CommandControlDBusProxy::getSystemPropertyChangedEvent() {
 126     return systemPropertyChanged_;
 127 }
 128 CommandControlDBusProxy::TimingInformationChangedEvent& CommandControlDBusProxy::getTimingInformationChangedEvent() {
 129     return timingInformationChanged_;
 130 }
 131 CommandControlDBusProxy::SinkUpdatedEvent& CommandControlDBusProxy::getSinkUpdatedEvent() {
 132     return sinkUpdated_;
 133 }
 134 CommandControlDBusProxy::SourceUpdatedEvent& CommandControlDBusProxy::getSourceUpdatedEvent() {
 135     return sourceUpdated_;
 136 }
 137 CommandControlDBusProxy::SinkNotificationEvent& CommandControlDBusProxy::getSinkNotificationEvent() {
 138     return sinkNotification_;
 139 }
 140 CommandControlDBusProxy::SourceNotificationEvent& CommandControlDBusProxy::getSourceNotificationEvent() {
 141     return sourceNotification_;
 142 }
 143 CommandControlDBusProxy::MainSinkNotificationConfigurationChangedEvent& CommandControlDBusProxy::getMainSinkNotificationConfigurationChangedEvent() {
 144     return mainSinkNotificationConfigurationChanged_;
 145 }
 146 CommandControlDBusProxy::MainSourceNotificationConfigurationChangedEvent& CommandControlDBusProxy::getMainSourceNotificationConfigurationChangedEvent() {
 147     return mainSourceNotificationConfigurationChanged_;
 148 }
 149
 150 void CommandControlDBusProxy::connect(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_mainConnectionID_t& mainConnectionID, am_Error_e& error) {
 151     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_sinkID_t>,
 152                                      CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t, am_Error_e> >::callMethodWithReply(
 153         *this,
 154         "connect",
 155         "qq",
 156         sourceID, sinkID,
 157         callStatus
 158         , mainConnectionID, error);
 159 }
 160 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::connectAsync(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, ConnectAsyncCallback callback) {
 161     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_sinkID_t>,
 162                                      CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t, am_Error_e> >::callMethodAsync(
 163         *this,
 164         "connect",
 165         "qq",
 166         sourceID, sinkID,
 167         std::move(callback));
 168 }
 169 void CommandControlDBusProxy::disconnect(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
 170     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t>,
 171                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
 172         *this,
 173         "disconnect",
 174         "q",
 175         mainConnectionID,
 176         callStatus
 177         , error);
 178 }
 179 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::disconnectAsync(const am_mainConnectionID_t& mainConnectionID, DisconnectAsyncCallback callback) {
 180     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t>,
 181                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
 182         *this,
 183         "disconnect",
 184         "q",
 185         mainConnectionID,
 186         std::move(callback));
 187 }
 188 void CommandControlDBusProxy::setVolume(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
 189     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_mainVolume_t>,
 190                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
 191         *this,
 192         "setVolume",
 193         "qn",
 194         sinkID, volume,
 195         callStatus
 196         , error);
 197 }
 198 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setVolumeAsync(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, SetVolumeAsyncCallback callback) {
 199     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_mainVolume_t>,
 200                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
 201         *this,
 202         "setVolume",
 203         "qn",
 204         sinkID, volume,
 205         std::move(callback));
 206 }
 207 void CommandControlDBusProxy::volumeStep(const am_sinkID_t& sinkID, const int16_t& volumeStep, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
 208     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, int16_t>,
 209                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
 210         *this,
 211         "volumeStep",
 212         "qn",
 213         sinkID, volumeStep,
 214         callStatus
 215         , error);
 216 }
 217 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::volumeStepAsync(const am_sinkID_t& sinkID, const int16_t& volumeStep, VolumeStepAsyncCallback callback) {
 218     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, int16_t>,
 219                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
 220         *this,
 221         "volumeStep",
 222         "qn",
 223         sinkID, volumeStep,
 224         std::move(callback));
 225 }
 226 void CommandControlDBusProxy::setSinkMuteState(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
 227     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MuteState_e>,
 228                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
 229         *this,
 230         "setSinkMuteState",
 231         "qi",
 232         sinkID, muteState,
 233         callStatus
 234         , error);
 235 }
 236 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setSinkMuteStateAsync(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, SetSinkMuteStateAsyncCallback callback) {
 237     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MuteState_e>,
 238                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
 239         *this,
 240         "setSinkMuteState",
 241         "qi",
 242         sinkID, muteState,
 243         std::move(callback));
 244 }
 245 void CommandControlDBusProxy::setMainSinkSoundProperty(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
 246     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MainSoundProperty_s>,
 247                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
 248         *this,
 249         "setMainSinkSoundProperty",
 250         "q(qn)",
 251         sinkID, soundProperty,
 252         callStatus
 253         , error);
 254 }
 255 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setMainSinkSoundPropertyAsync(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, SetMainSinkSoundPropertyAsyncCallback callback) {
 256     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MainSoundProperty_s>,
 257                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
 258         *this,
 259         "setMainSinkSoundProperty",
 260         "q(qn)",
 261         sinkID, soundProperty,
 262         std::move(callback));
 263 }
 264 void CommandControlDBusProxy::setMainSourceSoundProperty(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
 265     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_MainSoundProperty_s>,
 266                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
 267         *this,
 268         "setMainSourceSoundProperty",
 269         "q(qn)",
 270         sourceID, soundProperty,
 271         callStatus
 272         , error);
 273 }
 274 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setMainSourceSoundPropertyAsync(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, SetMainSourceSoundPropertyAsyncCallback callback) {
 275     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_MainSoundProperty_s>,
 276                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
 277         *this,
 278         "setMainSourceSoundProperty",
 279         "q(qn)",
 280         sourceID, soundProperty,
 281         std::move(callback));
 282 }
 283 void CommandControlDBusProxy::setSystemProperty(const am_SystemProperty_s& property, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
 284     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_SystemProperty_s>,
 285                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
 286         *this,
 287         "setSystemProperty",
 288         "(qn)",
 289         property,
 290         callStatus
 291         , error);
 292 }
 293 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setSystemPropertyAsync(const am_SystemProperty_s& property, SetSystemPropertyAsyncCallback callback) {
 294     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_SystemProperty_s>,
 295                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
 296         *this,
 297         "setSystemProperty",
 298         "(qn)",
 299         property,
 300         std::move(callback));
 301 }
 302 void CommandControlDBusProxy::getListMainConnections(CommonAPI::CallStatus& callStatus, am_MainConnection_L& listConnections, am_Error_e& error) {
 303     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
 304                                      CommonAPI::DBus::DBusSerializableArguments<am_MainConnection_L, am_Error_e> >::callMethodWithReply(
 305         *this,
 306         "getListMainConnections",
 307         "",
 308         callStatus
 309         , listConnections, error);
 310 }
 311 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainConnectionsAsync(GetListMainConnectionsAsyncCallback callback) {
 312     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
 313                                      CommonAPI::DBus::DBusSerializableArguments<am_MainConnection_L, am_Error_e> >::callMethodAsync(
 314         *this,
 315         "getListMainConnections",
 316         "",
 317         std::move(callback));
 318 }
 319 void CommandControlDBusProxy::getListMainSinks(CommonAPI::CallStatus& callStatus, am_SinkType_L& listMainSinks, am_Error_e& error) {
 320     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
 321                                      CommonAPI::DBus::DBusSerializableArguments<am_SinkType_L, am_Error_e> >::callMethodWithReply(
 322         *this,
 323         "getListMainSinks",
 324         "",
 325         callStatus
 326         , listMainSinks, error);
 327 }
 328 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSinksAsync(GetListMainSinksAsyncCallback callback) {
 329     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
 330                                      CommonAPI::DBus::DBusSerializableArguments<am_SinkType_L, am_Error_e> >::callMethodAsync(
 331         *this,
 332         "getListMainSinks",
 333         "",
 334         std::move(callback));
 335 }
 336 void CommandControlDBusProxy::getListMainSources(CommonAPI::CallStatus& callStatus, am_SourceType_L& listMainSources, am_Error_e& error) {
 337     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
 338                                      CommonAPI::DBus::DBusSerializableArguments<am_SourceType_L, am_Error_e> >::callMethodWithReply(
 339         *this,
 340         "getListMainSources",
 341         "",
 342         callStatus
 343         , listMainSources, error);
 344 }
 345 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSourcesAsync(GetListMainSourcesAsyncCallback callback) {
 346     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
 347                                      CommonAPI::DBus::DBusSerializableArguments<am_SourceType_L, am_Error_e> >::callMethodAsync(
 348         *this,
 349         "getListMainSources",
 350         "",
 351         std::move(callback));
 352 }
 353 void CommandControlDBusProxy::getListMainSinkSoundProperties(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error) {
 354     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t>,
 355                                      CommonAPI::DBus::DBusSerializableArguments<am_MainSoundProperty_L, am_Error_e> >::callMethodWithReply(
 356         *this,
 357         "getListMainSinkSoundProperties",
 358         "q",
 359         sinkID,
 360         callStatus
 361         , listSoundProperties, error);
 362 }
 363 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSinkSoundPropertiesAsync(const am_sinkID_t& sinkID, GetListMainSinkSoundPropertiesAsyncCallback callback) {
 364     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t>,
 365                                      CommonAPI::DBus::DBusSerializableArguments<am_MainSoundProperty_L, am_Error_e> >::callMethodAsync(
 366         *this,
 367         "getListMainSinkSoundProperties",
 368         "q",
 369         sinkID,
 370         std::move(callback));
 371 }
 372 void CommandControlDBusProxy::getListMainSourceSoundProperties(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error) {
 373     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t>,
 374                                      CommonAPI::DBus::DBusSerializableArguments<am_MainSoundProperty_L, am_Error_e> >::callMethodWithReply(
 375         *this,
 376         "getListMainSourceSoundProperties",
 377         "q",
 378         sourceID,
 379         callStatus
 380         , listSourceProperties, error);
 381 }
 382 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSourceSoundPropertiesAsync(const am_sourceID_t& sourceID, GetListMainSourceSoundPropertiesAsyncCallback callback) {
 383     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t>,
 384                                      CommonAPI::DBus::DBusSerializableArguments<am_MainSoundProperty_L, am_Error_e> >::callMethodAsync(
 385         *this,
 386         "getListMainSourceSoundProperties",
 387         "q",
 388         sourceID,
 389         std::move(callback));
 390 }
 391 void CommandControlDBusProxy::getListSourceClasses(CommonAPI::CallStatus& callStatus, am_SourceClass_L& listSourceClasses, am_Error_e& error) {
 392     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
 393                                      CommonAPI::DBus::DBusSerializableArguments<am_SourceClass_L, am_Error_e> >::callMethodWithReply(
 394         *this,
 395         "getListSourceClasses",
 396         "",
 397         callStatus
 398         , listSourceClasses, error);
 399 }
 400 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListSourceClassesAsync(GetListSourceClassesAsyncCallback callback) {
 401     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
 402                                      CommonAPI::DBus::DBusSerializableArguments<am_SourceClass_L, am_Error_e> >::callMethodAsync(
 403         *this,
 404         "getListSourceClasses",
 405         "",
 406         std::move(callback));
 407 }
 408 void CommandControlDBusProxy::getListSinkClasses(CommonAPI::CallStatus& callStatus, am_SinkClass_L& listSinkClasses, am_Error_e& error) {
 409     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
 410                                      CommonAPI::DBus::DBusSerializableArguments<am_SinkClass_L, am_Error_e> >::callMethodWithReply(
 411         *this,
 412         "getListSinkClasses",
 413         "",
 414         callStatus
 415         , listSinkClasses, error);
 416 }
 417 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListSinkClassesAsync(GetListSinkClassesAsyncCallback callback) {
 418     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
 419                                      CommonAPI::DBus::DBusSerializableArguments<am_SinkClass_L, am_Error_e> >::callMethodAsync(
 420         *this,
 421         "getListSinkClasses",
 422         "",
 423         std::move(callback));
 424 }
 425 void CommandControlDBusProxy::getListSystemProperties(CommonAPI::CallStatus& callStatus, am_SystemProperty_L& listSystemProperties, am_Error_e& error) {
 426     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
 427                                      CommonAPI::DBus::DBusSerializableArguments<am_SystemProperty_L, am_Error_e> >::callMethodWithReply(
 428         *this,
 429         "getListSystemProperties",
 430         "",
 431         callStatus
 432         , listSystemProperties, error);
 433 }
 434 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListSystemPropertiesAsync(GetListSystemPropertiesAsyncCallback callback) {
 435     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
 436                                      CommonAPI::DBus::DBusSerializableArguments<am_SystemProperty_L, am_Error_e> >::callMethodAsync(
 437         *this,
 438         "getListSystemProperties",
 439         "",
 440         std::move(callback));
 441 }
 442 void CommandControlDBusProxy::getTimingInformation(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_timeSync_t& delay, am_Error_e& error) {
 443     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t>,
 444                                      CommonAPI::DBus::DBusSerializableArguments<am_timeSync_t, am_Error_e> >::callMethodWithReply(
 445         *this,
 446         "getTimingInformation",
 447         "q",
 448         mainConnectionID,
 449         callStatus
 450         , delay, error);
 451 }
 452 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getTimingInformationAsync(const am_mainConnectionID_t& mainConnectionID, GetTimingInformationAsyncCallback callback) {
 453     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t>,
 454                                      CommonAPI::DBus::DBusSerializableArguments<am_timeSync_t, am_Error_e> >::callMethodAsync(
 455         *this,
 456         "getTimingInformation",
 457         "q",
 458         mainConnectionID,
 459         std::move(callback));
 460 }
 461 void CommandControlDBusProxy::getListMainSinkNotificationConfigurations(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) {
 462     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t>,
 463                                      CommonAPI::DBus::DBusSerializableArguments<am_NotificationConfiguration_L, am_Error_e> >::callMethodWithReply(
 464         *this,
 465         "getListMainSinkNotificationConfigurations",
 466         "q",
 467         sinkID,
 468         callStatus
 469         , listMainNotificationConfigurations, error);
 470 }
 471 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSinkNotificationConfigurationsAsync(const am_sinkID_t& sinkID, GetListMainSinkNotificationConfigurationsAsyncCallback callback) {
 472     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t>,
 473                                      CommonAPI::DBus::DBusSerializableArguments<am_NotificationConfiguration_L, am_Error_e> >::callMethodAsync(
 474         *this,
 475         "getListMainSinkNotificationConfigurations",
 476         "q",
 477         sinkID,
 478         std::move(callback));
 479 }
 480 void CommandControlDBusProxy::getListMainSourceNotificationConfigurations(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) {
 481     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t>,
 482                                      CommonAPI::DBus::DBusSerializableArguments<am_NotificationConfiguration_L, am_Error_e> >::callMethodWithReply(
 483         *this,
 484         "getListMainSourceNotificationConfigurations",
 485         "q",
 486         sourceID,
 487         callStatus
 488         , listMainNotificationConfigurations, error);
 489 }
 490 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSourceNotificationConfigurationsAsync(const am_sourceID_t& sourceID, GetListMainSourceNotificationConfigurationsAsyncCallback callback) {
 491     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t>,
 492                                      CommonAPI::DBus::DBusSerializableArguments<am_NotificationConfiguration_L, am_Error_e> >::callMethodAsync(
 493         *this,
 494         "getListMainSourceNotificationConfigurations",
 495         "q",
 496         sourceID,
 497         std::move(callback));
 498 }
 499 void CommandControlDBusProxy::setMainSinkNotificationConfiguration(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
 500     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_NotificationConfiguration_s>,
 501                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
 502         *this,
 503         "setMainSinkNotificationConfiguration",
 504         "q(qin)",
 505         sinkID, mainNotificationConfiguration,
 506         callStatus
 507         , error);
 508 }
 509 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setMainSinkNotificationConfigurationAsync(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSinkNotificationConfigurationAsyncCallback callback) {
 510     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_NotificationConfiguration_s>,
 511                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
 512         *this,
 513         "setMainSinkNotificationConfiguration",
 514         "q(qin)",
 515         sinkID, mainNotificationConfiguration,
 516         std::move(callback));
 517 }
 518 void CommandControlDBusProxy::setMainSourceNotificationConfiguration(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
 519     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_NotificationConfiguration_s>,
 520                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
 521         *this,
 522         "setMainSourceNotificationConfiguration",
 523         "q(qin)",
 524         sourceID, mainNotificationConfiguration,
 525         callStatus
 526         , error);
 527 }
 528 std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setMainSourceNotificationConfigurationAsync(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSourceNotificationConfigurationAsyncCallback callback) {
 529     return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_NotificationConfiguration_s>,
 530                                      CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
 531         *this,
 532         "setMainSourceNotificationConfiguration",
 533         "q(qin)",
 534         sourceID, mainNotificationConfiguration,
 535         std::move(callback));
 536 }
 537
 538 void CommandControlDBusProxy::getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const {
 539     ownVersionMajor = 1;
 540     ownVersionMinor = 0;
 541 }
 542
 543 } // namespace am
 544 } // namespace genivi
 545 } // namespace org