PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlObserverDBusProxy.h

   1 /*
   2 * This file was generated by the CommonAPI Generators.
   3 * Used org.genivi.commonapi.core 2.1.5.201312121915.
   4 * Used org.franca.core 0.8.11.201401091023.
   5 *
   6 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
   7 * If a copy of the MPL was not distributed with this file, You can obtain one at
   8 * http://mozilla.org/MPL/2.0/.
   9 */
  10 /**
  11  * Routing Receive sendInterface description.
  12  * @author Christian Mueller
  13  */
  14 #ifndef ORG_GENIVI_AM_Routing_Control_Observer_DBUS_PROXY_H_
  15 #define ORG_GENIVI_AM_Routing_Control_Observer_DBUS_PROXY_H_
  16
  17 #include <org/genivi/am/RoutingControlObserverProxyBase.h>
  18
  19 #if !defined (COMMONAPI_INTERNAL_COMPILATION)
  20 #define COMMONAPI_INTERNAL_COMPILATION
  21 #endif
  22
  23 #include <CommonAPI/DBus/DBusFactory.h>
  24 #include <CommonAPI/DBus/DBusProxy.h>
  25 #include <CommonAPI/DBus/DBusAttribute.h>
  26
  27 #undef COMMONAPI_INTERNAL_COMPILATION
  28
  29 #include <string>
  30
  31 namespace org {
  32 namespace genivi {
  33 namespace am {
  34
  35 class RoutingControlObserverDBusProxy: virtual public RoutingControlObserverProxyBase, virtual public CommonAPI::DBus::DBusProxy {
  36  public:
  37     RoutingControlObserverDBusProxy(
  38                     const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
  39                     const std::string& commonApiAddress,
  40                     const std::string& interfaceName,
  41                     const std::string& busName,
  42                     const std::string& objectPath,
  43                     const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyconnection);
  44
  45     virtual ~RoutingControlObserverDBusProxy() { }
  46
  47     virtual RoutingReadyAttribute& getRoutingReadyAttribute();
  48
  49
  50     /**
  51      * acknowledges a asyncConnect
  52      */
  53     virtual void ackConnect(const am_Handle_s& handle, const am_connectionID_t& connectionID, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
  54     virtual std::future<CommonAPI::CallStatus> ackConnectAsync(const am_Handle_s& handle, const am_connectionID_t& connectionID, const am_Error_e& error, AckConnectAsyncCallback callback);
  55     /**
  56      * acknowledges a asyncDisconnect
  57      */
  58     virtual void ackDisconnect(const am_Handle_s& handle, const am_connectionID_t& connectionID, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
  59     virtual std::future<CommonAPI::CallStatus> ackDisconnectAsync(const am_Handle_s& handle, const am_connectionID_t& connectionID, const am_Error_e& error, AckDisconnectAsyncCallback callback);
  60     /**
  61      * acknowledges a asyncsetSinkVolume
  62      */
  63     virtual void ackSetSinkVolumeChange(const am_Handle_s& handle, const am_volume_t& volume, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
  64     virtual std::future<CommonAPI::CallStatus> ackSetSinkVolumeChangeAsync(const am_Handle_s& handle, const am_volume_t& volume, const am_Error_e& error, AckSetSinkVolumeChangeAsyncCallback callback);
  65     /**
  66      * acknowledges a asyncsetSourceVolume
  67      */
  68     virtual void ackSetSourceVolumeChange(const am_Handle_s& handle, const am_volume_t& volume, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
  69     virtual std::future<CommonAPI::CallStatus> ackSetSourceVolumeChangeAsync(const am_Handle_s& handle, const am_volume_t& volume, const am_Error_e& error, AckSetSourceVolumeChangeAsyncCallback callback);
  70     /**
  71      * acknowlegde for asyncSetSourceState
  72      */
  73     virtual void ackSetSourceState(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
  74     virtual std::future<CommonAPI::CallStatus> ackSetSourceStateAsync(const am_Handle_s& handle, const am_Error_e& error, AckSetSourceStateAsyncCallback callback);
  75     /**
  76      * acknowledges asyncSetSinkSoundProperties
  77      */
  78     virtual void ackSetSinkSoundProperties(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
  79     virtual std::future<CommonAPI::CallStatus> ackSetSinkSoundPropertiesAsync(const am_Handle_s& handle, const am_Error_e& error, AckSetSinkSoundPropertiesAsyncCallback callback);
  80     /**
  81      * acknowledges asyncSetSinkSoundProperty
  82      */
  83     virtual void ackSetSinkSoundProperty(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
  84     virtual std::future<CommonAPI::CallStatus> ackSetSinkSoundPropertyAsync(const am_Handle_s& handle, const am_Error_e& error, AckSetSinkSoundPropertyAsyncCallback callback);
  85     /**
  86      * acknowledges asyncSetSourceSoundProperties
  87      */
  88     virtual void ackSetSourceSoundProperties(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
  89     virtual std::future<CommonAPI::CallStatus> ackSetSourceSoundPropertiesAsync(const am_Handle_s& handle, const am_Error_e& error, AckSetSourceSoundPropertiesAsyncCallback callback);
  90     /**
  91      * acknowledges asyncSetSourceSoundProperty
  92      */
  93     virtual void ackSetSourceSoundProperty(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
  94     virtual std::future<CommonAPI::CallStatus> ackSetSourceSoundPropertyAsync(const am_Handle_s& handle, const am_Error_e& error, AckSetSourceSoundPropertyAsyncCallback callback);
  95     /**
  96      * acknowledges asyncCrossFade
  97      */
  98     virtual void ackCrossFading(const am_Handle_s& handle, const am_HotSink_e& hotSink, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
  99     virtual std::future<CommonAPI::CallStatus> ackCrossFadingAsync(const am_Handle_s& handle, const am_HotSink_e& hotSink, const am_Error_e& error, AckCrossFadingAsyncCallback callback);
 100     /**
 101      * acknowledges a volume tick. This can be used to display volumechanges during
 102      *  ramps
 103      */
 104     virtual void ackSourceVolumeTick(const am_Handle_s& handle, const am_sourceID_t& sourceID, const am_volume_t& volume, CommonAPI::CallStatus& callStatus);
 105     virtual std::future<CommonAPI::CallStatus> ackSourceVolumeTickAsync(const am_Handle_s& handle, const am_sourceID_t& sourceID, const am_volume_t& volume, AckSourceVolumeTickAsyncCallback callback);
 106     /**
 107      * acknowledges a volume tick. This can be used to display volumechanges during
 108      *  ramps
 109      */
 110     virtual void ackSinkVolumeTick(const am_Handle_s& handle, const am_sinkID_t& sinkID, const am_volume_t& volume, CommonAPI::CallStatus& callStatus);
 111     virtual std::future<CommonAPI::CallStatus> ackSinkVolumeTickAsync(const am_Handle_s& handle, const am_sinkID_t& sinkID, const am_volume_t& volume, AckSinkVolumeTickAsyncCallback callback);
 112     /**
 113      * This function returns the ID to the given domainName. If already a domain is
 114      *  registered with this name, it will return the corresponding ID, if not it will
 115      *  reserve an ID but not register the domain. The other parameters of the domain
 116      *  will be overwritten when the domain is registered.
 117     (at)return E_OK on
 118      *  success, E_UNKNOWN on error
 119      */
 120     virtual void peekDomain(const std::string& name, CommonAPI::CallStatus& callStatus, am_domainID_t& domainID, am_Error_e& error);
 121     virtual std::future<CommonAPI::CallStatus> peekDomainAsync(const std::string& name, PeekDomainAsyncCallback callback);
 122     /**
 123      * registers a domain
 124     (at)return E_OK on succes, E_ALREADY_EXISTENT if already
 125      *  registered E_UNKOWN on error
 126      */
 127     virtual void 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);
 128     virtual std::future<CommonAPI::CallStatus> registerDomainAsync(const am_Domain_s& domainData, const std::string& returnBusname, const std::string& returnInterface, RegisterDomainAsyncCallback callback);
 129     /**
 130      * deregisters a domain. All sources, sinks, gateways and crossfaders from that
 131      *  domain will be removed as well.
 132     (at)return E_OK on succes, E_NON_EXISTENT if
 133      *  not found E_UNKOWN on error
 134      */
 135     virtual void deregisterDomain(const am_domainID_t& domainID, CommonAPI::CallStatus& callStatus, am_Error_e& error);
 136     virtual std::future<CommonAPI::CallStatus> deregisterDomainAsync(const am_domainID_t& domainID, DeregisterDomainAsyncCallback callback);
 137     /**
 138      * registers a gateway. (at)return E_OK on succes, E_ALREADY_EXISTENT if already
 139      *  registered E_UNKOWN on error
 140      */
 141     virtual void registerGateway(const am_Gateway_s& gatewayData, CommonAPI::CallStatus& callStatus, am_gatewayID_t& gatewayID, am_Error_e& error);
 142     virtual std::future<CommonAPI::CallStatus> registerGatewayAsync(const am_Gateway_s& gatewayData, RegisterGatewayAsyncCallback callback);
 143     /**
 144      * deregisters a gateway. Also removes all sinks and sources of the controlling
 145      *  domain.
 146     (at)return E_OK on succes, E_NON_EXISTENT if not found E_UNKOWN on
 147      *  error
 148      */
 149     virtual void deregisterGateway(const am_gatewayID_t& gatewayID, CommonAPI::CallStatus& callStatus, am_Error_e& error);
 150     virtual std::future<CommonAPI::CallStatus> deregisterGatewayAsync(const am_gatewayID_t& gatewayID, DeregisterGatewayAsyncCallback callback);
 151     /**
 152      * This function returns the ID to the given sinkName. If already a sink is
 153      *  registered with this name, it will return the corresponding ID, if not it will
 154      *  reserve an ID but not register the sink. The other parameters of the sink will
 155      *  be overwritten when the sink is registered.
 156     (at)return E_OK on success,
 157      *  E_UNKNOWN on error
 158      */
 159     virtual void peekSink(const std::string& name, CommonAPI::CallStatus& callStatus, am_sinkID_t& sinkID, am_Error_e& error);
 160     virtual std::future<CommonAPI::CallStatus> peekSinkAsync(const std::string& name, PeekSinkAsyncCallback callback);
 161     /**
 162      * Registers a sink. If the sink is part of a gateway, the listconnectionFormats
 163      *  is copied to the gatewayInformation
 164     (at)return E_OK on succes,
 165      *  E_ALREADY_EXISTENT if already registered E_UNKOWN on error
 166      */
 167     virtual void registerSink(const am_Sink_s& sinkData, CommonAPI::CallStatus& callStatus, am_sinkID_t& sinkID, am_Error_e& error);
 168     virtual std::future<CommonAPI::CallStatus> registerSinkAsync(const am_Sink_s& sinkData, RegisterSinkAsyncCallback callback);
 169     /**
 170      * deregisters a sink.
 171     (at)return E_OK on succes, E_NON_EXISTENT if not found
 172      *  E_UNKOWN on error
 173      */
 174     virtual void deregisterSink(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_Error_e& error);
 175     virtual std::future<CommonAPI::CallStatus> deregisterSinkAsync(const am_sinkID_t& sinkID, DeregisterSinkAsyncCallback callback);
 176     /**
 177      * This function returns the ID to the given sourceName. If already a source is
 178      *  registered with this name, it will return the corresponding ID, if not it will
 179      *  reserve an ID but not register the source. The other parameters of the source
 180      *  will be overwritten when the source is registered.
 181     (at)return E_OK on
 182      *  success, E_UNKNOWN on error
 183      */
 184     virtual void peekSource(const std::string& name, CommonAPI::CallStatus& callStatus, am_sourceID_t& sourceID, am_Error_e& error);
 185     virtual std::future<CommonAPI::CallStatus> peekSourceAsync(const std::string& name, PeekSourceAsyncCallback callback);
 186     /**
 187      * registers a source.  If the source is part of a gateway, the
 188      *  listconnectionFormats is copied to the gatewayInformation
 189     (at)return E_OK on
 190      *  success, E_UNKNOWN on error, E_ALREADY_EXIST if either name or sourceID
 191      *  already exists
 192      */
 193     virtual void registerSource(const am_Source_s& sourceData, CommonAPI::CallStatus& callStatus, am_sourceID_t& sourceID, am_Error_e& error);
 194     virtual std::future<CommonAPI::CallStatus> registerSourceAsync(const am_Source_s& sourceData, RegisterSourceAsyncCallback callback);
 195     /**
 196      * deregisters a source
 197     (at)return E_OK on succes, E_NON_EXISTENT if not found
 198      *  E_UNKOWN on error
 199      */
 200     virtual void deregisterSource(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_Error_e& error);
 201     virtual std::future<CommonAPI::CallStatus> deregisterSourceAsync(const am_sourceID_t& sourceID, DeregisterSourceAsyncCallback callback);
 202     /**
 203      * this function registers a crossfader.
 204     (at)return E_OK on succes,
 205      *  E_ALREADY_EXISTENT if already registered E_UNKOWN on error
 206      */
 207     virtual void registerCrossfader(const am_Crossfader_s& crossfaderData, CommonAPI::CallStatus& callStatus, am_crossfaderID_t& crossfaderID, am_Error_e& error);
 208     virtual std::future<CommonAPI::CallStatus> registerCrossfaderAsync(const am_Crossfader_s& crossfaderData, RegisterCrossfaderAsyncCallback callback);
 209     /**
 210      * this function deregisters a crossfader. removes all sources and sinks assiated
 211      *  as well.
 212     (at)return E_OK on succes, E_NON_EXISTENT if not found E_UNKOWN on
 213      *  error
 214      */
 215     virtual void deregisterCrossfader(const am_crossfaderID_t& crossfaderID, CommonAPI::CallStatus& callStatus, am_Error_e& error);
 216     virtual std::future<CommonAPI::CallStatus> deregisterCrossfaderAsync(const am_crossfaderID_t& crossfaderID, DeregisterCrossfaderAsyncCallback callback);
 217     /**
 218      * this function peeks a sourceclassID. It is used by the RoutingPlugins to
 219      *  determine the SinkClassIDs of a sinkClass.
 220     (at)return E_OK on succes,
 221      *  E_DATABASE_ERROR on error
 222      */
 223     virtual void peekSourceClassID(const std::string& name, CommonAPI::CallStatus& callStatus, am_sourceClass_t& sourceClassID, am_Error_e& error);
 224     virtual std::future<CommonAPI::CallStatus> peekSourceClassIDAsync(const std::string& name, PeekSourceClassIDAsyncCallback callback);
 225     /**
 226      * this function peeks a sourceclassID. It is used by the RoutingPlugins to
 227      *  determine the SinkClassIDs of a sinkClass.
 228     (at)return E_OK on succes,
 229      *  E_DATABASE_ERROR on error
 230      */
 231     virtual void peekSinkClassID(const std::string& name, CommonAPI::CallStatus& callStatus, am_sinkClass_t& sinkClassID, am_Error_e& error);
 232     virtual std::future<CommonAPI::CallStatus> peekSinkClassIDAsync(const std::string& name, PeekSinkClassIDAsyncCallback callback);
 233     /**
 234      * is called when a low level interrupt changes it status.
 235      */
 236     virtual void hookInterruptStatusChange(const am_sourceID_t& sourceID, const am_InterruptState_e& interruptState, CommonAPI::CallStatus& callStatus);
 237     virtual std::future<CommonAPI::CallStatus> hookInterruptStatusChangeAsync(const am_sourceID_t& sourceID, const am_InterruptState_e& interruptState, HookInterruptStatusChangeAsyncCallback callback);
 238     /**
 239      * This hook is called when all elements from a domain are registered.
 240     Is used by
 241      *  the Controller to know when all expected domains are finally registered
 242      */
 243     virtual void hookDomainRegistrationComplete(const am_domainID_t& domainID, CommonAPI::CallStatus& callStatus);
 244     virtual std::future<CommonAPI::CallStatus> hookDomainRegistrationCompleteAsync(const am_domainID_t& domainID, HookDomainRegistrationCompleteAsyncCallback callback);
 245     /**
 246      * is called when a sink changes its availability
 247      */
 248     virtual void hookSinkAvailablityStatusChange(const am_sinkID_t& sinkID, const am_Availability_s& availability, CommonAPI::CallStatus& callStatus);
 249     virtual std::future<CommonAPI::CallStatus> hookSinkAvailablityStatusChangeAsync(const am_sinkID_t& sinkID, const am_Availability_s& availability, HookSinkAvailablityStatusChangeAsyncCallback callback);
 250     /**
 251      * is called when a source changes its availability
 252      */
 253     virtual void hookSourceAvailablityStatusChange(const am_sourceID_t& sourceID, const am_Availability_s& availability, CommonAPI::CallStatus& callStatus);
 254     virtual std::future<CommonAPI::CallStatus> hookSourceAvailablityStatusChangeAsync(const am_sourceID_t& sourceID, const am_Availability_s& availability, HookSourceAvailablityStatusChangeAsyncCallback callback);
 255     /**
 256      * is called when a domain changes its status. This used for early domains only
 257      */
 258     virtual void hookDomainStateChange(const am_domainID_t& domainID, const am_DomainState_e& domainState, CommonAPI::CallStatus& callStatus);
 259     virtual std::future<CommonAPI::CallStatus> hookDomainStateChangeAsync(const am_domainID_t& domainID, const am_DomainState_e& domainState, HookDomainStateChangeAsyncCallback callback);
 260     /**
 261      * is called when the timinginformation (delay) changed for a connection.
 262      */
 263     virtual void hookTimingInformationChanged(const am_connectionID_t& connectionID, const am_timeSync_t& delay, CommonAPI::CallStatus& callStatus);
 264     virtual std::future<CommonAPI::CallStatus> hookTimingInformationChangedAsync(const am_connectionID_t& connectionID, const am_timeSync_t& delay, HookTimingInformationChangedAsyncCallback callback);
 265     /**
 266      * this function is used to send out all data that has been changed in an early
 267      *  state.
 268     (at)return E_OK on success, E_UNKNOWN on error
 269      */
 270     virtual void sendChangedData(const am_EarlyData_L& earlyData, CommonAPI::CallStatus& callStatus);
 271     virtual std::future<CommonAPI::CallStatus> sendChangedDataAsync(const am_EarlyData_L& earlyData, SendChangedDataAsyncCallback callback);
 272     /**
 273      * updates data of an gateway. (at)return E_OK on success, E_NON_EXISTENT if the
 274      *  gatewayID is not valid.
 275      */
 276     virtual void 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);
 277     virtual std::future<CommonAPI::CallStatus> updateGatewayAsync(const am_gatewayID_t& gatewayID, const am_ConnectionFormat_L& listSourceFormats, const am_ConnectionFormat_L& listSinkFormats, const am_Convertion_L& convertionMatrix, UpdateGatewayAsyncCallback callback);
 278     /**
 279      * updates data of an gateway. (at)return E_OK on success, E_NON_EXISTENT if the
 280      *  sinkID is not valid.
 281      */
 282     virtual void 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);
 283     virtual std::future<CommonAPI::CallStatus> 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);
 284     /**
 285      * updates data of an source. (at)return E_OK on success, E_NON_EXISTENT if the
 286      *  sourceID in the struct is not valid.
 287     Please note that only the following
 288      *  data out of am_Source_s have effect when they are
 289      *  changed:
 290     sourceClassID,
 291     listSoundProperties,
 292     listConnectionFormats,
 293      *
 294     listMainSoundProperties
 295      */
 296     virtual void 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);
 297     virtual std::future<CommonAPI::CallStatus> 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);
 298     /**
 299      * acknowledges a asyncSetSinkVolumes
 300      */
 301     virtual void ackSetVolumes(const am_Handle_s& handle, const am_Volumes_L& listvolumes, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
 302     virtual std::future<CommonAPI::CallStatus> ackSetVolumesAsync(const am_Handle_s& handle, const am_Volumes_L& listvolumes, const am_Error_e& error, AckSetVolumesAsyncCallback callback);
 303     /**
 304      * The acknowledge of the SinkNotificationConfiguration
 305      */
 306     virtual void ackSinkNotificationConfiguration(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
 307     virtual std::future<CommonAPI::CallStatus> ackSinkNotificationConfigurationAsync(const am_Handle_s& handle, const am_Error_e& error, AckSinkNotificationConfigurationAsyncCallback callback);
 308     /**
 309      * The acknowledge of the SourceNotificationConfiguration
 310      */
 311     virtual void ackSourceNotificationConfiguration(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
 312     virtual std::future<CommonAPI::CallStatus> ackSourceNotificationConfigurationAsync(const am_Handle_s& handle, const am_Error_e& error, AckSourceNotificationConfigurationAsyncCallback callback);
 313     /**
 314      * is called whenever a notified value needs to be send
 315      */
 316     virtual void hookSinkNotificationDataChange(const am_sinkID_t& sinkID, const am_NotificationPayload_s& payload, CommonAPI::CallStatus& callStatus);
 317     virtual std::future<CommonAPI::CallStatus> hookSinkNotificationDataChangeAsync(const am_sinkID_t& sinkID, const am_NotificationPayload_s& payload, HookSinkNotificationDataChangeAsyncCallback callback);
 318     /**
 319      * is called whenever a notified value needs to be send
 320      */
 321     virtual void hookSourceNotificationDataChange(const am_sourceID_t& sourceID, const am_NotificationPayload_s& payload, CommonAPI::CallStatus& callStatus);
 322     virtual std::future<CommonAPI::CallStatus> hookSourceNotificationDataChangeAsync(const am_sourceID_t& sourceID, const am_NotificationPayload_s& payload, HookSourceNotificationDataChangeAsyncCallback callback);
 323     virtual void confirmRoutingRundown(const std::string& domainName, CommonAPI::CallStatus& callStatus);
 324     virtual std::future<CommonAPI::CallStatus> confirmRoutingRundownAsync(const std::string& domainName, ConfirmRoutingRundownAsyncCallback callback);
 325
 326
 327     virtual void getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const;
 328
 329  private:
 330    CommonAPI::DBus::DBusObservableAttribute<CommonAPI::DBus::DBusReadonlyAttribute<RoutingReadyAttribute>> routingReady_;
 331
 332
 333 };
 334
 335
 336
 337 } // namespace am
 338 } // namespace genivi
 339 } // namespace org
 340
 341 #endif // ORG_GENIVI_AM_Routing_Control_Observer_DBUS_PROXY_H_