aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorAndrei Gherzan <andrei.gherzan@windriver.com>2015-05-13 16:43:19 +0200
committerAndrei Gherzan <andrei.gherzan@windriver.com>2015-05-13 16:43:19 +0200
commitd3d2238f5abb38f54613b5f1007f8cb0ff06b338 (patch)
tree419c43dbe95dc29b0e379e6ab096945ffc5d208c
parentf777a897df7b60759cec881ed4223f7be831079f (diff)
downloadmeta-ivi-d3d2238f5abb38f54613b5f1007f8cb0ff06b338.tar.gz
meta-ivi-d3d2238f5abb38f54613b5f1007f8cb0ff06b338.tar.bz2
meta-ivi-d3d2238f5abb38f54613b5f1007f8cb0ff06b338.zip
audiomanager: Update to 6.2
Signed-off-by: Andrei Gherzan <andrei.gherzan@windriver.com>
-rw-r--r--meta-ivi/recipes-multimedia/audiomanager/audiomanager/0001-Add-CommonAPI-sources-generated-with-CommonAPI-2.1.6.patch25986
-rw-r--r--meta-ivi/recipes-multimedia/audiomanager/audiomanager/0001-src-gen-update-to-CommonAPI-version-2.1.6.patch9227
-rw-r--r--meta-ivi/recipes-multimedia/audiomanager/audiomanager_6.2.bb (renamed from meta-ivi/recipes-multimedia/audiomanager/audiomanager_6.1.bb)36
3 files changed, 26007 insertions, 9242 deletions
diff --git a/meta-ivi/recipes-multimedia/audiomanager/audiomanager/0001-Add-CommonAPI-sources-generated-with-CommonAPI-2.1.6.patch b/meta-ivi/recipes-multimedia/audiomanager/audiomanager/0001-Add-CommonAPI-sources-generated-with-CommonAPI-2.1.6.patch
new file mode 100644
index 0000000..a1e51bb
--- /dev/null
+++ b/meta-ivi/recipes-multimedia/audiomanager/audiomanager/0001-Add-CommonAPI-sources-generated-with-CommonAPI-2.1.6.patch
@@ -0,0 +1,25986 @@
+From 712d7d611de7357c1324cce4a19f5f6d6ec48cb7 Mon Sep 17 00:00:00 2001
+From: Andrei Gherzan <andrei.gherzan@windriver.com>
+Date: Wed, 13 May 2015 16:06:11 +0200
+Subject: [PATCH] Add CommonAPI sources generated with CommonAPI 2.1.6 generator
+
+Signed-off-by: Andrei Gherzan <andrei.gherzan@windriver.com>
+---
+ .../src-gen/org/genivi/NodeStateManager/Consumer.h | 62 +
+ .../genivi/NodeStateManager/ConsumerDBusProxy.cpp | 284 +++
+ .../genivi/NodeStateManager/ConsumerDBusProxy.h | 98 +
+ .../NodeStateManager/ConsumerDBusStubAdapter.cpp | 305 +++
+ .../NodeStateManager/ConsumerDBusStubAdapter.h | 182 ++
+ .../org/genivi/NodeStateManager/ConsumerProxy.h | 627 +++++
+ .../genivi/NodeStateManager/ConsumerProxyBase.h | 95 +
+ .../org/genivi/NodeStateManager/ConsumerStub.h | 152 ++
+ .../NodeStateManager/ConsumerStubDefault.cpp | 239 ++
+ .../genivi/NodeStateManager/ConsumerStubDefault.h | 128 +
+ .../genivi/NodeStateManager/LifeCycleConsumer.h | 62 +
+ .../LifeCycleConsumerDBusProxy.cpp | 74 +
+ .../NodeStateManager/LifeCycleConsumerDBusProxy.h | 62 +
+ .../LifeCycleConsumerDBusStubAdapter.cpp | 121 +
+ .../LifeCycleConsumerDBusStubAdapter.h | 113 +
+ .../NodeStateManager/LifeCycleConsumerProxy.h | 185 ++
+ .../NodeStateManager/LifeCycleConsumerProxyBase.h | 49 +
+ .../NodeStateManager/LifeCycleConsumerStub.h | 98 +
+ .../LifeCycleConsumerStubDefault.cpp | 46 +
+ .../LifeCycleConsumerStubDefault.h | 67 +
+ .../src-gen/org/genivi/am.cpp | 1043 ++++++++
+ PluginCommandInterfaceCAPI/src-gen/org/genivi/am.h | 2551 ++++++++++++++++++++
+ .../src-gen/org/genivi/am/CommandControl.h | 67 +
+ .../org/genivi/am/CommandControlDBusProxy.cpp | 651 +++++
+ .../org/genivi/am/CommandControlDBusProxy.h | 266 ++
+ .../genivi/am/CommandControlDBusStubAdapter.cpp | 1096 +++++++++
+ .../org/genivi/am/CommandControlDBusStubAdapter.h | 422 ++++
+ .../src-gen/org/genivi/am/CommandControlProxy.h | 1194 +++++++++
+ .../org/genivi/am/CommandControlProxyBase.h | 348 +++
+ .../src-gen/org/genivi/am/CommandControlStub.h | 492 ++++
+ .../org/genivi/am/CommandControlStubDefault.cpp | 456 ++++
+ .../org/genivi/am/CommandControlStubDefault.h | 336 +++
+ .../src-gen/org/genivi/am.cpp | 1043 ++++++++
+ PluginRoutingInterfaceCAPI/src-gen/org/genivi/am.h | 2551 ++++++++++++++++++++
+ .../src-gen/org/genivi/am/RoutingControl.h | 63 +
+ .../org/genivi/am/RoutingControlDBusProxy.cpp | 407 ++++
+ .../org/genivi/am/RoutingControlDBusProxy.h | 157 ++
+ .../genivi/am/RoutingControlDBusStubAdapter.cpp | 477 ++++
+ .../org/genivi/am/RoutingControlDBusStubAdapter.h | 250 ++
+ .../src-gen/org/genivi/am/RoutingControlObserver.h | 63 +
+ .../genivi/am/RoutingControlObserverDBusProxy.cpp | 1135 +++++++++
+ .../genivi/am/RoutingControlObserverDBusProxy.h | 357 +++
+ .../am/RoutingControlObserverDBusStubAdapter.cpp | 1244 ++++++++++
+ .../am/RoutingControlObserverDBusStubAdapter.h | 557 +++++
+ .../org/genivi/am/RoutingControlObserverProxy.h | 1921 +++++++++++++++
+ .../genivi/am/RoutingControlObserverProxyBase.h | 401 +++
+ .../org/genivi/am/RoutingControlObserverStub.h | 407 ++++
+ .../am/RoutingControlObserverStubDefault.cpp | 636 +++++
+ .../genivi/am/RoutingControlObserverStubDefault.h | 429 ++++
+ .../src-gen/org/genivi/am/RoutingControlProxy.h | 712 ++++++
+ .../org/genivi/am/RoutingControlProxyBase.h | 163 ++
+ .../src-gen/org/genivi/am/RoutingControlStub.h | 198 ++
+ .../org/genivi/am/RoutingControlStubDefault.cpp | 224 ++
+ .../org/genivi/am/RoutingControlStubDefault.h | 176 ++
+ 54 files changed, 25542 insertions(+)
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/Consumer.h
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusProxy.cpp
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusProxy.h
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusStubAdapter.cpp
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusStubAdapter.h
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerProxy.h
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerProxyBase.h
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerStub.h
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerStubDefault.cpp
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerStubDefault.h
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumer.h
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusProxy.cpp
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusProxy.h
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusStubAdapter.cpp
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusStubAdapter.h
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerProxy.h
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerProxyBase.h
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerStub.h
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerStubDefault.cpp
+ create mode 100644 AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerStubDefault.h
+ create mode 100644 PluginCommandInterfaceCAPI/src-gen/org/genivi/am.cpp
+ create mode 100644 PluginCommandInterfaceCAPI/src-gen/org/genivi/am.h
+ create mode 100644 PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControl.h
+ create mode 100644 PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusProxy.cpp
+ create mode 100644 PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusProxy.h
+ create mode 100644 PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusStubAdapter.cpp
+ create mode 100644 PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusStubAdapter.h
+ create mode 100644 PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlProxy.h
+ create mode 100644 PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlProxyBase.h
+ create mode 100644 PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStub.h
+ create mode 100644 PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStubDefault.cpp
+ create mode 100644 PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStubDefault.h
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am.cpp
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am.h
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControl.h
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlDBusProxy.cpp
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlDBusProxy.h
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlDBusStubAdapter.cpp
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlDBusStubAdapter.h
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlObserver.h
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlObserverDBusProxy.cpp
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlObserverDBusProxy.h
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlObserverDBusStubAdapter.cpp
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlObserverDBusStubAdapter.h
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlObserverProxy.h
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlObserverProxyBase.h
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlObserverStub.h
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlObserverStubDefault.cpp
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlObserverStubDefault.h
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlProxy.h
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlProxyBase.h
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlStub.h
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlStubDefault.cpp
+ create mode 100644 PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlStubDefault.h
+
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/Consumer.h b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/Consumer.h
+new file mode 100644
+index 0000000..62c8f39
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/Consumer.h
+@@ -0,0 +1,62 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_NODESTATEMANAGER_Consumer_H_
++#define ORG_GENIVI_NODESTATEMANAGER_Consumer_H_
++
++
++
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <CommonAPI/types.h>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++class Consumer {
++ public:
++ virtual ~Consumer() { }
++
++ static inline const char* getInterfaceId();
++ static inline CommonAPI::Version getInterfaceVersion();
++};
++
++const char* Consumer::getInterfaceId() {
++ static const char* interfaceId = "org.genivi.NodeStateManager.Consumer";
++ return interfaceId;
++}
++
++CommonAPI::Version Consumer::getInterfaceVersion() {
++ return CommonAPI::Version(1, 0);
++}
++
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
++
++namespace CommonAPI {
++
++}
++
++
++namespace std {
++ //hashes for types
++
++ //hashes for error types
++}
++
++#endif // ORG_GENIVI_NODESTATEMANAGER_Consumer_H_
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusProxy.cpp b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusProxy.cpp
+new file mode 100644
+index 0000000..6f4139e
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusProxy.cpp
+@@ -0,0 +1,284 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#include "ConsumerDBusProxy.h"
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++std::shared_ptr<CommonAPI::DBus::DBusProxy> createConsumerDBusProxy(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& interfaceName,
++ const std::string& busName,
++ const std::string& objectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyConnection) {
++ return std::make_shared<ConsumerDBusProxy>(factory, commonApiAddress, interfaceName, busName, objectPath, dbusProxyConnection);
++}
++
++INITIALIZER(registerConsumerDBusProxy) {
++ CommonAPI::DBus::DBusFactory::registerProxyFactoryMethod(Consumer::getInterfaceId(),
++ &createConsumerDBusProxy);
++}
++
++ConsumerDBusProxy::ConsumerDBusProxy(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& interfaceName,
++ const std::string& busName,
++ const std::string& objectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyconnection):
++ CommonAPI::DBus::DBusProxy(factory, commonApiAddress, interfaceName, busName, objectPath, dbusProxyconnection)
++,bootMode_(*this, "i", "getBootModeAttribute"),
++restartReason_(*this, "i", "getRestartReasonAttribute"),
++shutdownReason_(*this, "i", "getShutdownReasonAttribute"),
++wakeUpReason_(*this, "i", "getWakeUpReasonAttribute")
++, nodeApplicationMode_(*this, "NodeApplicationMode", "i"),
++ sessionStateChanged_(*this, "SessionStateChanged", "sii"),
++ nodeState_(*this, "NodeState", "i")
++ {
++ }
++
++ConsumerDBusProxy::BootModeAttribute& ConsumerDBusProxy::getBootModeAttribute() {
++ return bootMode_;
++}
++ConsumerDBusProxy::RestartReasonAttribute& ConsumerDBusProxy::getRestartReasonAttribute() {
++ return restartReason_;
++}
++ConsumerDBusProxy::ShutdownReasonAttribute& ConsumerDBusProxy::getShutdownReasonAttribute() {
++ return shutdownReason_;
++}
++ConsumerDBusProxy::WakeUpReasonAttribute& ConsumerDBusProxy::getWakeUpReasonAttribute() {
++ return wakeUpReason_;
++}
++
++ConsumerDBusProxy::NodeApplicationModeEvent& ConsumerDBusProxy::getNodeApplicationModeEvent() {
++ return nodeApplicationMode_;
++}
++ConsumerDBusProxy::SessionStateChangedEvent& ConsumerDBusProxy::getSessionStateChangedEvent() {
++ return sessionStateChanged_;
++}
++ConsumerDBusProxy::NodeStateEvent& ConsumerDBusProxy::getNodeStateEvent() {
++ return nodeState_;
++}
++
++void ConsumerDBusProxy::GetAppHealthCount(CommonAPI::CallStatus& callStatus, uint32_t& Count) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<uint32_t> >::callMethodWithReply(
++ *this,
++ "GetAppHealthCount",
++ "",
++ callStatus
++ , Count);
++}
++std::future<CommonAPI::CallStatus> ConsumerDBusProxy::GetAppHealthCountAsync(GetAppHealthCountAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<uint32_t> >::callMethodAsync(
++ *this,
++ "GetAppHealthCount",
++ "",
++ std::move(callback));
++}
++void ConsumerDBusProxy::LifecycleRequestComplete(const uint32_t& RequestId, const int32_t& Status, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t, int32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t> >::callMethodWithReply(
++ *this,
++ "LifecycleRequestComplete",
++ "ui",
++ RequestId, Status,
++ callStatus
++ , ErrorCode);
++}
++std::future<CommonAPI::CallStatus> ConsumerDBusProxy::LifecycleRequestCompleteAsync(const uint32_t& RequestId, const int32_t& Status, LifecycleRequestCompleteAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t, int32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t> >::callMethodAsync(
++ *this,
++ "LifecycleRequestComplete",
++ "ui",
++ RequestId, Status,
++ std::move(callback));
++}
++void ConsumerDBusProxy::GetInterfaceVersion(CommonAPI::CallStatus& callStatus, uint32_t& Version) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<uint32_t> >::callMethodWithReply(
++ *this,
++ "GetInterfaceVersion",
++ "",
++ callStatus
++ , Version);
++}
++std::future<CommonAPI::CallStatus> ConsumerDBusProxy::GetInterfaceVersionAsync(GetInterfaceVersionAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<uint32_t> >::callMethodAsync(
++ *this,
++ "GetInterfaceVersion",
++ "",
++ std::move(callback));
++}
++void ConsumerDBusProxy::GetApplicationMode(CommonAPI::CallStatus& callStatus, int32_t& ErrorCode, int32_t& ApplicationModeId) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t, int32_t> >::callMethodWithReply(
++ *this,
++ "GetApplicationMode",
++ "",
++ callStatus
++ , ErrorCode, ApplicationModeId);
++}
++std::future<CommonAPI::CallStatus> ConsumerDBusProxy::GetApplicationModeAsync(GetApplicationModeAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t, int32_t> >::callMethodAsync(
++ *this,
++ "GetApplicationMode",
++ "",
++ std::move(callback));
++}
++void ConsumerDBusProxy::UnRegisterSession(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<std::string, std::string, int32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t> >::callMethodWithReply(
++ *this,
++ "UnRegisterSession",
++ "ssi",
++ SessionName, SessionOwner, SeatID,
++ callStatus
++ , ErrorCode);
++}
++std::future<CommonAPI::CallStatus> ConsumerDBusProxy::UnRegisterSessionAsync(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, UnRegisterSessionAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<std::string, std::string, int32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t> >::callMethodAsync(
++ *this,
++ "UnRegisterSession",
++ "ssi",
++ SessionName, SessionOwner, SeatID,
++ std::move(callback));
++}
++void ConsumerDBusProxy::RegisterSession(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, const int32_t& SessionState, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<std::string, std::string, int32_t, int32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t> >::callMethodWithReply(
++ *this,
++ "RegisterSession",
++ "ssii",
++ SessionName, SessionOwner, SeatID, SessionState,
++ callStatus
++ , ErrorCode);
++}
++std::future<CommonAPI::CallStatus> ConsumerDBusProxy::RegisterSessionAsync(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, const int32_t& SessionState, RegisterSessionAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<std::string, std::string, int32_t, int32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t> >::callMethodAsync(
++ *this,
++ "RegisterSession",
++ "ssii",
++ SessionName, SessionOwner, SeatID, SessionState,
++ std::move(callback));
++}
++void ConsumerDBusProxy::UnRegisterShutdownClient(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<std::string, std::string, uint32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t> >::callMethodWithReply(
++ *this,
++ "UnRegisterShutdownClient",
++ "ssu",
++ BusName, ObjName, ShutdownMode,
++ callStatus
++ , ErrorCode);
++}
++std::future<CommonAPI::CallStatus> ConsumerDBusProxy::UnRegisterShutdownClientAsync(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, UnRegisterShutdownClientAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<std::string, std::string, uint32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t> >::callMethodAsync(
++ *this,
++ "UnRegisterShutdownClient",
++ "ssu",
++ BusName, ObjName, ShutdownMode,
++ std::move(callback));
++}
++void ConsumerDBusProxy::RegisterShutdownClient(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, const uint32_t& TimeoutMs, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<std::string, std::string, uint32_t, uint32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t> >::callMethodWithReply(
++ *this,
++ "RegisterShutdownClient",
++ "ssuu",
++ BusName, ObjName, ShutdownMode, TimeoutMs,
++ callStatus
++ , ErrorCode);
++}
++std::future<CommonAPI::CallStatus> ConsumerDBusProxy::RegisterShutdownClientAsync(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, const uint32_t& TimeoutMs, RegisterShutdownClientAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<std::string, std::string, uint32_t, uint32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t> >::callMethodAsync(
++ *this,
++ "RegisterShutdownClient",
++ "ssuu",
++ BusName, ObjName, ShutdownMode, TimeoutMs,
++ std::move(callback));
++}
++void ConsumerDBusProxy::GetNodeState(CommonAPI::CallStatus& callStatus, int32_t& ErrorCode, int32_t& NodeStateId) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t, int32_t> >::callMethodWithReply(
++ *this,
++ "GetNodeState",
++ "",
++ callStatus
++ , ErrorCode, NodeStateId);
++}
++std::future<CommonAPI::CallStatus> ConsumerDBusProxy::GetNodeStateAsync(GetNodeStateAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t, int32_t> >::callMethodAsync(
++ *this,
++ "GetNodeState",
++ "",
++ std::move(callback));
++}
++void ConsumerDBusProxy::GetSessionState(const std::string& SessionName, const int32_t& SeatID, CommonAPI::CallStatus& callStatus, int32_t& SessionState, int32_t& ErrorCode) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<std::string, int32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t, int32_t> >::callMethodWithReply(
++ *this,
++ "GetSessionState",
++ "si",
++ SessionName, SeatID,
++ callStatus
++ , SessionState, ErrorCode);
++}
++std::future<CommonAPI::CallStatus> ConsumerDBusProxy::GetSessionStateAsync(const std::string& SessionName, const int32_t& SeatID, GetSessionStateAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<std::string, int32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t, int32_t> >::callMethodAsync(
++ *this,
++ "GetSessionState",
++ "si",
++ SessionName, SeatID,
++ std::move(callback));
++}
++void ConsumerDBusProxy::SetSessionState(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SessionState, const int32_t& SeatID, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<std::string, std::string, int32_t, int32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t> >::callMethodWithReply(
++ *this,
++ "SetSessionState",
++ "ssii",
++ SessionName, SessionOwner, SessionState, SeatID,
++ callStatus
++ , ErrorCode);
++}
++std::future<CommonAPI::CallStatus> ConsumerDBusProxy::SetSessionStateAsync(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SessionState, const int32_t& SeatID, SetSessionStateAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<std::string, std::string, int32_t, int32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t> >::callMethodAsync(
++ *this,
++ "SetSessionState",
++ "ssii",
++ SessionName, SessionOwner, SessionState, SeatID,
++ std::move(callback));
++}
++
++
++
++void ConsumerDBusProxy::getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const {
++ ownVersionMajor = 1;
++ ownVersionMinor = 0;
++}
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusProxy.h b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusProxy.h
+new file mode 100644
+index 0000000..139dd7e
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusProxy.h
+@@ -0,0 +1,98 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_NODESTATEMANAGER_Consumer_DBUS_PROXY_H_
++#define ORG_GENIVI_NODESTATEMANAGER_Consumer_DBUS_PROXY_H_
++
++#include <org/genivi/NodeStateManager/ConsumerProxyBase.h>
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <CommonAPI/DBus/DBusFactory.h>
++#include <CommonAPI/DBus/DBusProxy.h>
++#include <CommonAPI/DBus/DBusAttribute.h>
++#include <CommonAPI/DBus/DBusEvent.h>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++#include <string>
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++class ConsumerDBusProxy: virtual public ConsumerProxyBase, virtual public CommonAPI::DBus::DBusProxy {
++ public:
++ ConsumerDBusProxy(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& interfaceName,
++ const std::string& busName,
++ const std::string& objectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyconnection);
++
++ virtual ~ConsumerDBusProxy() { }
++
++ virtual BootModeAttribute& getBootModeAttribute();
++ virtual RestartReasonAttribute& getRestartReasonAttribute();
++ virtual ShutdownReasonAttribute& getShutdownReasonAttribute();
++ virtual WakeUpReasonAttribute& getWakeUpReasonAttribute();
++
++ virtual NodeApplicationModeEvent& getNodeApplicationModeEvent();
++ virtual SessionStateChangedEvent& getSessionStateChangedEvent();
++ virtual NodeStateEvent& getNodeStateEvent();
++
++ virtual void GetAppHealthCount(CommonAPI::CallStatus& callStatus, uint32_t& Count);
++ virtual std::future<CommonAPI::CallStatus> GetAppHealthCountAsync(GetAppHealthCountAsyncCallback callback);
++ virtual void LifecycleRequestComplete(const uint32_t& RequestId, const int32_t& Status, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode);
++ virtual std::future<CommonAPI::CallStatus> LifecycleRequestCompleteAsync(const uint32_t& RequestId, const int32_t& Status, LifecycleRequestCompleteAsyncCallback callback);
++ virtual void GetInterfaceVersion(CommonAPI::CallStatus& callStatus, uint32_t& Version);
++ virtual std::future<CommonAPI::CallStatus> GetInterfaceVersionAsync(GetInterfaceVersionAsyncCallback callback);
++ virtual void GetApplicationMode(CommonAPI::CallStatus& callStatus, int32_t& ErrorCode, int32_t& ApplicationModeId);
++ virtual std::future<CommonAPI::CallStatus> GetApplicationModeAsync(GetApplicationModeAsyncCallback callback);
++ virtual void UnRegisterSession(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode);
++ virtual std::future<CommonAPI::CallStatus> UnRegisterSessionAsync(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, UnRegisterSessionAsyncCallback callback);
++ virtual void RegisterSession(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, const int32_t& SessionState, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode);
++ virtual std::future<CommonAPI::CallStatus> RegisterSessionAsync(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, const int32_t& SessionState, RegisterSessionAsyncCallback callback);
++ virtual void UnRegisterShutdownClient(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode);
++ virtual std::future<CommonAPI::CallStatus> UnRegisterShutdownClientAsync(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, UnRegisterShutdownClientAsyncCallback callback);
++ virtual void RegisterShutdownClient(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, const uint32_t& TimeoutMs, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode);
++ virtual std::future<CommonAPI::CallStatus> RegisterShutdownClientAsync(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, const uint32_t& TimeoutMs, RegisterShutdownClientAsyncCallback callback);
++ virtual void GetNodeState(CommonAPI::CallStatus& callStatus, int32_t& ErrorCode, int32_t& NodeStateId);
++ virtual std::future<CommonAPI::CallStatus> GetNodeStateAsync(GetNodeStateAsyncCallback callback);
++ virtual void GetSessionState(const std::string& SessionName, const int32_t& SeatID, CommonAPI::CallStatus& callStatus, int32_t& SessionState, int32_t& ErrorCode);
++ virtual std::future<CommonAPI::CallStatus> GetSessionStateAsync(const std::string& SessionName, const int32_t& SeatID, GetSessionStateAsyncCallback callback);
++ virtual void SetSessionState(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SessionState, const int32_t& SeatID, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode);
++ virtual std::future<CommonAPI::CallStatus> SetSessionStateAsync(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SessionState, const int32_t& SeatID, SetSessionStateAsyncCallback callback);
++
++
++ virtual void getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const;
++
++ private:
++ CommonAPI::DBus::DBusReadonlyAttribute<BootModeAttribute> bootMode_;
++ CommonAPI::DBus::DBusReadonlyAttribute<RestartReasonAttribute> restartReason_;
++ CommonAPI::DBus::DBusReadonlyAttribute<ShutdownReasonAttribute> shutdownReason_;
++ CommonAPI::DBus::DBusReadonlyAttribute<WakeUpReasonAttribute> wakeUpReason_;
++
++ CommonAPI::DBus::DBusEvent<NodeApplicationModeEvent> nodeApplicationMode_;
++ CommonAPI::DBus::DBusEvent<SessionStateChangedEvent> sessionStateChanged_;
++ CommonAPI::DBus::DBusEvent<NodeStateEvent> nodeState_;
++
++};
++
++
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
++
++#endif // ORG_GENIVI_NODESTATEMANAGER_Consumer_DBUS_PROXY_H_
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusStubAdapter.cpp b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusStubAdapter.cpp
+new file mode 100644
+index 0000000..1d59a34
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusStubAdapter.cpp
+@@ -0,0 +1,305 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++#include "ConsumerDBusStubAdapter.h"
++#include <org/genivi/NodeStateManager/Consumer.h>
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++std::shared_ptr<CommonAPI::DBus::DBusStubAdapter> createConsumerDBusStubAdapter(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& interfaceName,
++ const std::string& busName,
++ const std::string& objectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyConnection,
++ const std::shared_ptr<CommonAPI::StubBase>& stubBase) {
++ return std::make_shared<ConsumerDBusStubAdapter>(factory, commonApiAddress, interfaceName, busName, objectPath, dbusProxyConnection, stubBase);
++}
++
++INITIALIZER(registerConsumerDBusStubAdapter) {
++ CommonAPI::DBus::DBusFactory::registerAdapterFactoryMethod(Consumer::getInterfaceId(),
++ &createConsumerDBusStubAdapter);
++}
++
++
++
++ConsumerDBusStubAdapterInternal::~ConsumerDBusStubAdapterInternal() {
++ deactivateManagedInstances();
++ ConsumerDBusStubAdapterHelper::deinit();
++}
++
++void ConsumerDBusStubAdapterInternal::deactivateManagedInstances() {
++
++}
++
++const char* ConsumerDBusStubAdapterInternal::getMethodsDBusIntrospectionXmlData() const {
++ static const std::string introspectionData =
++ "<method name=\"getInterfaceVersion\">\n"
++ "<arg name=\"value\" type=\"uu\" direction=\"out\" />"
++ "</method>\n"
++ "<method name=\"getBootModeAttribute\">\n"
++ "<arg name=\"value\" type=\"i\" direction=\"out\" />"
++ "</method>\n"
++ "<method name=\"getRestartReasonAttribute\">\n"
++ "<arg name=\"value\" type=\"i\" direction=\"out\" />"
++ "</method>\n"
++ "<method name=\"getShutdownReasonAttribute\">\n"
++ "<arg name=\"value\" type=\"i\" direction=\"out\" />"
++ "</method>\n"
++ "<method name=\"getWakeUpReasonAttribute\">\n"
++ "<arg name=\"value\" type=\"i\" direction=\"out\" />"
++ "</method>\n"
++ "<signal name=\"NodeApplicationMode\">\n"
++ "<arg name=\"ApplicationModeId\" type=\"i\" />\n"
++ "</signal>\n"
++ "<signal name=\"SessionStateChanged\">\n"
++ "<arg name=\"SessionStateName\" type=\"s\" />\n"
++ "<arg name=\"SeatID\" type=\"i\" />\n"
++ "<arg name=\"SessionState\" type=\"i\" />\n"
++ "</signal>\n"
++ "<signal name=\"NodeState\">\n"
++ "<arg name=\"NodeState\" type=\"i\" />\n"
++ "</signal>\n"
++ "<method name=\"GetAppHealthCount\">\n"
++ "<arg name=\"Count\" type=\"u\" direction=\"out\" />\n"
++ "</method>\n"
++ "<method name=\"LifecycleRequestComplete\">\n"
++ "<arg name=\"RequestId\" type=\"u\" direction=\"in\" />\n"
++ "<arg name=\"Status\" type=\"i\" direction=\"in\" />\n"
++ "<arg name=\"ErrorCode\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ "<method name=\"GetInterfaceVersion\">\n"
++ "<arg name=\"Version\" type=\"u\" direction=\"out\" />\n"
++ "</method>\n"
++ "<method name=\"GetApplicationMode\">\n"
++ "<arg name=\"ErrorCode\" type=\"i\" direction=\"out\" />\n"
++ "<arg name=\"ApplicationModeId\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ "<method name=\"UnRegisterSession\">\n"
++ "<arg name=\"SessionName\" type=\"s\" direction=\"in\" />\n"
++ "<arg name=\"SessionOwner\" type=\"s\" direction=\"in\" />\n"
++ "<arg name=\"SeatID\" type=\"i\" direction=\"in\" />\n"
++ "<arg name=\"ErrorCode\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ "<method name=\"RegisterSession\">\n"
++ "<arg name=\"SessionName\" type=\"s\" direction=\"in\" />\n"
++ "<arg name=\"SessionOwner\" type=\"s\" direction=\"in\" />\n"
++ "<arg name=\"SeatID\" type=\"i\" direction=\"in\" />\n"
++ "<arg name=\"SessionState\" type=\"i\" direction=\"in\" />\n"
++ "<arg name=\"ErrorCode\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ "<method name=\"UnRegisterShutdownClient\">\n"
++ "<arg name=\"BusName\" type=\"s\" direction=\"in\" />\n"
++ "<arg name=\"ObjName\" type=\"s\" direction=\"in\" />\n"
++ "<arg name=\"ShutdownMode\" type=\"u\" direction=\"in\" />\n"
++ "<arg name=\"ErrorCode\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ "<method name=\"RegisterShutdownClient\">\n"
++ "<arg name=\"BusName\" type=\"s\" direction=\"in\" />\n"
++ "<arg name=\"ObjName\" type=\"s\" direction=\"in\" />\n"
++ "<arg name=\"ShutdownMode\" type=\"u\" direction=\"in\" />\n"
++ "<arg name=\"TimeoutMs\" type=\"u\" direction=\"in\" />\n"
++ "<arg name=\"ErrorCode\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ "<method name=\"GetNodeState\">\n"
++ "<arg name=\"ErrorCode\" type=\"i\" direction=\"out\" />\n"
++ "<arg name=\"NodeStateId\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ "<method name=\"GetSessionState\">\n"
++ "<arg name=\"SessionName\" type=\"s\" direction=\"in\" />\n"
++ "<arg name=\"SeatID\" type=\"i\" direction=\"in\" />\n"
++ "<arg name=\"SessionState\" type=\"i\" direction=\"out\" />\n"
++ "<arg name=\"ErrorCode\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ "<method name=\"SetSessionState\">\n"
++ "<arg name=\"SessionName\" type=\"s\" direction=\"in\" />\n"
++ "<arg name=\"SessionOwner\" type=\"s\" direction=\"in\" />\n"
++ "<arg name=\"SessionState\" type=\"i\" direction=\"in\" />\n"
++ "<arg name=\"SeatID\" type=\"i\" direction=\"in\" />\n"
++ "<arg name=\"ErrorCode\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++
++ ;
++ return introspectionData.c_str();
++}
++
++CommonAPI::DBus::DBusGetAttributeStubDispatcher<
++ ConsumerStub,
++ CommonAPI::Version
++ > ConsumerDBusStubAdapterInternal::getConsumerInterfaceVersionStubDispatcher(&ConsumerStub::getInterfaceVersion, "uu");
++
++CommonAPI::DBus::DBusGetAttributeStubDispatcher<
++ ConsumerStub,
++ int32_t
++ > ConsumerDBusStubAdapterInternal::getBootModeAttributeStubDispatcher(&ConsumerStub::getBootModeAttribute, "i");
++CommonAPI::DBus::DBusGetAttributeStubDispatcher<
++ ConsumerStub,
++ int32_t
++ > ConsumerDBusStubAdapterInternal::getRestartReasonAttributeStubDispatcher(&ConsumerStub::getRestartReasonAttribute, "i");
++CommonAPI::DBus::DBusGetAttributeStubDispatcher<
++ ConsumerStub,
++ int32_t
++ > ConsumerDBusStubAdapterInternal::getShutdownReasonAttributeStubDispatcher(&ConsumerStub::getShutdownReasonAttribute, "i");
++CommonAPI::DBus::DBusGetAttributeStubDispatcher<
++ ConsumerStub,
++ int32_t
++ > ConsumerDBusStubAdapterInternal::getWakeUpReasonAttributeStubDispatcher(&ConsumerStub::getWakeUpReasonAttribute, "i");
++
++
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<>,
++ std::tuple<uint32_t>
++ > ConsumerDBusStubAdapterInternal::getAppHealthCountStubDispatcher(&ConsumerStub::GetAppHealthCount, "u");
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<uint32_t, int32_t>,
++ std::tuple<int32_t>
++ > ConsumerDBusStubAdapterInternal::lifecycleRequestCompleteStubDispatcher(&ConsumerStub::LifecycleRequestComplete, "i");
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<>,
++ std::tuple<uint32_t>
++ > ConsumerDBusStubAdapterInternal::getInterfaceVersionStubDispatcher(&ConsumerStub::GetInterfaceVersion, "u");
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<>,
++ std::tuple<int32_t, int32_t>
++ > ConsumerDBusStubAdapterInternal::getApplicationModeStubDispatcher(&ConsumerStub::GetApplicationMode, "ii");
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<std::string, std::string, int32_t>,
++ std::tuple<int32_t>
++ > ConsumerDBusStubAdapterInternal::unRegisterSessionStubDispatcher(&ConsumerStub::UnRegisterSession, "i");
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<std::string, std::string, int32_t, int32_t>,
++ std::tuple<int32_t>
++ > ConsumerDBusStubAdapterInternal::registerSessionStubDispatcher(&ConsumerStub::RegisterSession, "i");
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<std::string, std::string, uint32_t>,
++ std::tuple<int32_t>
++ > ConsumerDBusStubAdapterInternal::unRegisterShutdownClientStubDispatcher(&ConsumerStub::UnRegisterShutdownClient, "i");
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<std::string, std::string, uint32_t, uint32_t>,
++ std::tuple<int32_t>
++ > ConsumerDBusStubAdapterInternal::registerShutdownClientStubDispatcher(&ConsumerStub::RegisterShutdownClient, "i");
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<>,
++ std::tuple<int32_t, int32_t>
++ > ConsumerDBusStubAdapterInternal::getNodeStateStubDispatcher(&ConsumerStub::GetNodeState, "ii");
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<std::string, int32_t>,
++ std::tuple<int32_t, int32_t>
++ > ConsumerDBusStubAdapterInternal::getSessionStateStubDispatcher(&ConsumerStub::GetSessionState, "ii");
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<std::string, std::string, int32_t, int32_t>,
++ std::tuple<int32_t>
++ > ConsumerDBusStubAdapterInternal::setSessionStateStubDispatcher(&ConsumerStub::SetSessionState, "i");
++
++
++
++void ConsumerDBusStubAdapterInternal::fireNodeApplicationModeEvent(const int32_t& ApplicationModeId) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<int32_t>>
++ ::sendSignal(
++ *this,
++ "NodeApplicationMode",
++ "i",
++ ApplicationModeId
++ );
++}
++void ConsumerDBusStubAdapterInternal::fireSessionStateChangedEvent(const std::string& SessionStateName, const int32_t& SeatID, const int32_t& SessionState) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<std::string, int32_t, int32_t>>
++ ::sendSignal(
++ *this,
++ "SessionStateChanged",
++ "sii",
++ SessionStateName, SeatID, SessionState
++ );
++}
++void ConsumerDBusStubAdapterInternal::fireNodeStateEvent(const int32_t& NodeState) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<int32_t>>
++ ::sendSignal(
++ *this,
++ "NodeState",
++ "i",
++ NodeState
++ );
++}
++
++
++const ConsumerDBusStubAdapterHelper::StubDispatcherTable& ConsumerDBusStubAdapterInternal::getStubDispatcherTable() {
++ return stubDispatcherTable_;
++}
++
++const CommonAPI::DBus::StubAttributeTable& ConsumerDBusStubAdapterInternal::getStubAttributeTable() {
++ return stubAttributeTable_;
++}
++
++ConsumerDBusStubAdapterInternal::ConsumerDBusStubAdapterInternal(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& dbusInterfaceName,
++ const std::string& dbusBusName,
++ const std::string& dbusObjectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection,
++ const std::shared_ptr<CommonAPI::StubBase>& stub):
++ CommonAPI::DBus::DBusStubAdapter(
++ factory,
++ commonApiAddress,
++ dbusInterfaceName,
++ dbusBusName,
++ dbusObjectPath,
++ dbusConnection,
++ false),
++ ConsumerDBusStubAdapterHelper(
++ factory,
++ commonApiAddress,
++ dbusInterfaceName,
++ dbusBusName,
++ dbusObjectPath,
++ dbusConnection,
++ std::dynamic_pointer_cast<ConsumerStub>(stub),
++ false),
++ stubDispatcherTable_({
++ { { "getBootModeAttribute", "" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::getBootModeAttributeStubDispatcher },
++ { { "getRestartReasonAttribute", "" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::getRestartReasonAttributeStubDispatcher },
++ { { "getShutdownReasonAttribute", "" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::getShutdownReasonAttributeStubDispatcher },
++ { { "getWakeUpReasonAttribute", "" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::getWakeUpReasonAttributeStubDispatcher }
++ ,
++ { { "GetAppHealthCount", "" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::getAppHealthCountStubDispatcher },
++ { { "LifecycleRequestComplete", "ui" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::lifecycleRequestCompleteStubDispatcher },
++ { { "GetInterfaceVersion", "" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::getInterfaceVersionStubDispatcher },
++ { { "GetApplicationMode", "" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::getApplicationModeStubDispatcher },
++ { { "UnRegisterSession", "ssi" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::unRegisterSessionStubDispatcher },
++ { { "RegisterSession", "ssii" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::registerSessionStubDispatcher },
++ { { "UnRegisterShutdownClient", "ssu" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::unRegisterShutdownClientStubDispatcher },
++ { { "RegisterShutdownClient", "ssuu" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::registerShutdownClientStubDispatcher },
++ { { "GetNodeState", "" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::getNodeStateStubDispatcher },
++ { { "GetSessionState", "si" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::getSessionStateStubDispatcher },
++ { { "SetSessionState", "ssii" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::setSessionStateStubDispatcher }
++ }),
++ stubAttributeTable_() {
++
++ stubDispatcherTable_.insert({ { "getInterfaceVersion", "" }, &org::genivi::NodeStateManager::ConsumerDBusStubAdapterInternal::getConsumerInterfaceVersionStubDispatcher });
++}
++
++const bool ConsumerDBusStubAdapterInternal::hasFreedesktopProperties() {
++ return false;
++}
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusStubAdapter.h b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusStubAdapter.h
+new file mode 100644
+index 0000000..aacecd0
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerDBusStubAdapter.h
+@@ -0,0 +1,182 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_NODESTATEMANAGER_Consumer_DBUS_STUB_ADAPTER_H_
++#define ORG_GENIVI_NODESTATEMANAGER_Consumer_DBUS_STUB_ADAPTER_H_
++
++#include <org/genivi/NodeStateManager/ConsumerStub.h>
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <CommonAPI/DBus/DBusStubAdapterHelper.h>
++#include <CommonAPI/DBus/DBusStubAdapter.h>
++#include <CommonAPI/DBus/DBusFactory.h>
++#include <CommonAPI/DBus/DBusServicePublisher.h>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++typedef CommonAPI::DBus::DBusStubAdapterHelper<ConsumerStub> ConsumerDBusStubAdapterHelper;
++
++class ConsumerDBusStubAdapterInternal: public virtual ConsumerStubAdapter, public ConsumerDBusStubAdapterHelper {
++ public:
++ ConsumerDBusStubAdapterInternal(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& dbusInterfaceName,
++ const std::string& dbusBusName,
++ const std::string& dbusObjectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection,
++ const std::shared_ptr<CommonAPI::StubBase>& stub);
++
++ ~ConsumerDBusStubAdapterInternal();
++
++ virtual const bool hasFreedesktopProperties();
++
++
++ void fireNodeApplicationModeEvent(const int32_t& ApplicationModeId);
++ void fireSessionStateChangedEvent(const std::string& SessionStateName, const int32_t& SeatID, const int32_t& SessionState);
++ void fireNodeStateEvent(const int32_t& NodeState);
++
++
++ const ConsumerDBusStubAdapterHelper::StubDispatcherTable& getStubDispatcherTable();
++ const CommonAPI::DBus::StubAttributeTable& getStubAttributeTable();
++
++ void deactivateManagedInstances();
++
++
++static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
++ ConsumerStub,
++ CommonAPI::Version
++ > getConsumerInterfaceVersionStubDispatcher;
++
++static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
++ ConsumerStub,
++ int32_t
++ > getBootModeAttributeStubDispatcher;
++static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
++ ConsumerStub,
++ int32_t
++ > getRestartReasonAttributeStubDispatcher;
++static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
++ ConsumerStub,
++ int32_t
++ > getShutdownReasonAttributeStubDispatcher;
++static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
++ ConsumerStub,
++ int32_t
++ > getWakeUpReasonAttributeStubDispatcher;
++
++
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<>,
++ std::tuple<uint32_t>
++ > getAppHealthCountStubDispatcher;
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<uint32_t, int32_t>,
++ std::tuple<int32_t>
++ > lifecycleRequestCompleteStubDispatcher;
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<>,
++ std::tuple<uint32_t>
++ > getInterfaceVersionStubDispatcher;
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<>,
++ std::tuple<int32_t, int32_t>
++ > getApplicationModeStubDispatcher;
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<std::string, std::string, int32_t>,
++ std::tuple<int32_t>
++ > unRegisterSessionStubDispatcher;
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<std::string, std::string, int32_t, int32_t>,
++ std::tuple<int32_t>
++ > registerSessionStubDispatcher;
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<std::string, std::string, uint32_t>,
++ std::tuple<int32_t>
++ > unRegisterShutdownClientStubDispatcher;
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<std::string, std::string, uint32_t, uint32_t>,
++ std::tuple<int32_t>
++ > registerShutdownClientStubDispatcher;
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<>,
++ std::tuple<int32_t, int32_t>
++ > getNodeStateStubDispatcher;
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<std::string, int32_t>,
++ std::tuple<int32_t, int32_t>
++ > getSessionStateStubDispatcher;
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ ConsumerStub,
++ std::tuple<std::string, std::string, int32_t, int32_t>,
++ std::tuple<int32_t>
++ > setSessionStateStubDispatcher;
++
++
++
++
++ protected:
++ virtual const char* getMethodsDBusIntrospectionXmlData() const;
++
++ private:
++ ConsumerDBusStubAdapterHelper::StubDispatcherTable stubDispatcherTable_;
++ CommonAPI::DBus::StubAttributeTable stubAttributeTable_;
++};
++
++class ConsumerDBusStubAdapter: public ConsumerDBusStubAdapterInternal, public std::enable_shared_from_this<ConsumerDBusStubAdapter> {
++public:
++ ConsumerDBusStubAdapter(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& dbusInterfaceName,
++ const std::string& dbusBusName,
++ const std::string& dbusObjectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection,
++ const std::shared_ptr<CommonAPI::StubBase>& stub) :
++ CommonAPI::DBus::DBusStubAdapter(
++ factory,
++ commonApiAddress,
++ dbusInterfaceName,
++ dbusBusName,
++ dbusObjectPath,
++ dbusConnection,
++ false),
++ ConsumerDBusStubAdapterInternal(
++ factory,
++ commonApiAddress,
++ dbusInterfaceName,
++ dbusBusName,
++ dbusObjectPath,
++ dbusConnection,
++ stub) { }
++};
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
++
++#endif // ORG_GENIVI_NODESTATEMANAGER_Consumer_DBUS_STUB_ADAPTER_H_
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerProxy.h b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerProxy.h
+new file mode 100644
+index 0000000..5b7c14a
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerProxy.h
+@@ -0,0 +1,627 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_NODESTATEMANAGER_Consumer_PROXY_H_
++#define ORG_GENIVI_NODESTATEMANAGER_Consumer_PROXY_H_
++
++#include "ConsumerProxyBase.h"
++
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <CommonAPI/AttributeExtension.h>
++#include <CommonAPI/Factory.h>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++template <typename ... _AttributeExtensions>
++class ConsumerProxy: virtual public Consumer, virtual public ConsumerProxyBase
++, public _AttributeExtensions... {
++public:
++ ConsumerProxy(std::shared_ptr<CommonAPI::Proxy> delegate);
++ ~ConsumerProxy();
++
++ typedef Consumer InterfaceType;
++
++
++ /**
++ * Returns the wrapper class that provides access to the attribute BootMode.
++ */
++ virtual BootModeAttribute& getBootModeAttribute() {
++ return delegate_->getBootModeAttribute();
++ }
++ /**
++ * Returns the wrapper class that provides access to the attribute RestartReason.
++ */
++ virtual RestartReasonAttribute& getRestartReasonAttribute() {
++ return delegate_->getRestartReasonAttribute();
++ }
++ /**
++ * Returns the wrapper class that provides access to the attribute ShutdownReason.
++ */
++ virtual ShutdownReasonAttribute& getShutdownReasonAttribute() {
++ return delegate_->getShutdownReasonAttribute();
++ }
++ /**
++ * Returns the wrapper class that provides access to the attribute WakeUpReason.
++ */
++ virtual WakeUpReasonAttribute& getWakeUpReasonAttribute() {
++ return delegate_->getWakeUpReasonAttribute();
++ }
++
++ /**
++ * Returns the wrapper class that provides access to the broadcast NodeApplicationMode.
++ */
++ virtual NodeApplicationModeEvent& getNodeApplicationModeEvent() {
++ return delegate_->getNodeApplicationModeEvent();
++ }
++ /**
++ * Returns the wrapper class that provides access to the broadcast SessionStateChanged.
++ */
++ virtual SessionStateChangedEvent& getSessionStateChangedEvent() {
++ return delegate_->getSessionStateChangedEvent();
++ }
++ /**
++ * Returns the wrapper class that provides access to the broadcast NodeState.
++ */
++ virtual NodeStateEvent& getNodeStateEvent() {
++ return delegate_->getNodeStateEvent();
++ }
++
++ /**
++ * Calls GetAppHealthCount with synchronous semantics.
++ *
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void GetAppHealthCount(CommonAPI::CallStatus& callStatus, uint32_t& Count);
++ /**
++ * Calls GetAppHealthCount with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> GetAppHealthCountAsync(GetAppHealthCountAsyncCallback callback);
++ /**
++ * Calls LifecycleRequestComplete with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void LifecycleRequestComplete(const uint32_t& RequestId, const int32_t& Status, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode);
++ /**
++ * Calls LifecycleRequestComplete with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> LifecycleRequestCompleteAsync(const uint32_t& RequestId, const int32_t& Status, LifecycleRequestCompleteAsyncCallback callback);
++ /**
++ * Calls GetInterfaceVersion with synchronous semantics.
++ *
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void GetInterfaceVersion(CommonAPI::CallStatus& callStatus, uint32_t& Version);
++ /**
++ * Calls GetInterfaceVersion with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> GetInterfaceVersionAsync(GetInterfaceVersionAsyncCallback callback);
++ /**
++ * Calls GetApplicationMode with synchronous semantics.
++ *
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void GetApplicationMode(CommonAPI::CallStatus& callStatus, int32_t& ErrorCode, int32_t& ApplicationModeId);
++ /**
++ * Calls GetApplicationMode with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> GetApplicationModeAsync(GetApplicationModeAsyncCallback callback);
++ /**
++ * Calls UnRegisterSession with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void UnRegisterSession(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode);
++ /**
++ * Calls UnRegisterSession with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> UnRegisterSessionAsync(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, UnRegisterSessionAsyncCallback callback);
++ /**
++ * Calls RegisterSession with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void RegisterSession(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, const int32_t& SessionState, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode);
++ /**
++ * Calls RegisterSession with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> RegisterSessionAsync(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, const int32_t& SessionState, RegisterSessionAsyncCallback callback);
++ /**
++ * Calls UnRegisterShutdownClient with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void UnRegisterShutdownClient(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode);
++ /**
++ * Calls UnRegisterShutdownClient with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> UnRegisterShutdownClientAsync(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, UnRegisterShutdownClientAsyncCallback callback);
++ /**
++ * Calls RegisterShutdownClient with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void RegisterShutdownClient(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, const uint32_t& TimeoutMs, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode);
++ /**
++ * Calls RegisterShutdownClient with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> RegisterShutdownClientAsync(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, const uint32_t& TimeoutMs, RegisterShutdownClientAsyncCallback callback);
++ /**
++ * Calls GetNodeState with synchronous semantics.
++ *
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void GetNodeState(CommonAPI::CallStatus& callStatus, int32_t& ErrorCode, int32_t& NodeStateId);
++ /**
++ * Calls GetNodeState with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> GetNodeStateAsync(GetNodeStateAsyncCallback callback);
++ /**
++ * Calls GetSessionState with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void GetSessionState(const std::string& SessionName, const int32_t& SeatID, CommonAPI::CallStatus& callStatus, int32_t& SessionState, int32_t& ErrorCode);
++ /**
++ * Calls GetSessionState with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> GetSessionStateAsync(const std::string& SessionName, const int32_t& SeatID, GetSessionStateAsyncCallback callback);
++ /**
++ * Calls SetSessionState with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void SetSessionState(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SessionState, const int32_t& SeatID, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode);
++ /**
++ * Calls SetSessionState with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> SetSessionStateAsync(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SessionState, const int32_t& SeatID, SetSessionStateAsyncCallback callback);
++
++
++ /**
++ * Returns the CommonAPI address of the remote partner this proxy communicates with.
++ */
++ virtual std::string getAddress() const;
++
++ /**
++ * Returns the domain of the remote partner this proxy communicates with.
++ */
++ virtual const std::string& getDomain() const;
++
++ /**
++ * Returns the service ID of the remote partner this proxy communicates with.
++ */
++ virtual const std::string& getServiceId() const;
++
++ /**
++ * Returns the instance ID of the remote partner this proxy communicates with.
++ */
++ virtual const std::string& getInstanceId() const;
++
++ /**
++ * Returns true if the remote partner for this proxy is currently known to be available.
++ */
++ virtual bool isAvailable() const;
++
++ /**
++ * Returns true if the remote partner for this proxy is available.
++ */
++ virtual bool isAvailableBlocking() const;
++
++ /**
++ * Returns the wrapper class that is used to (de-)register for notifications about
++ * the availability of the remote partner of this proxy.
++ */
++ virtual CommonAPI::ProxyStatusEvent& getProxyStatusEvent();
++
++ /**
++ * Returns the wrapper class that is used to access version information of the remote
++ * partner of this proxy.
++ */
++ virtual CommonAPI::InterfaceVersionAttribute& getInterfaceVersionAttribute();
++
++ private:
++ std::shared_ptr<ConsumerProxyBase> delegate_;
++};
++
++#ifdef WIN32
++ typedef ConsumerProxy<CommonAPI::WINDummyAttributeExtension<CommonAPI::WINDummyAttribute>> ConsumerProxyDefault;
++#else
++ typedef ConsumerProxy<> ConsumerProxyDefault;
++#endif
++
++namespace ConsumerExtensions {
++ template <template <typename > class _ExtensionType>
++ class BootModeAttributeExtension {
++ public:
++ typedef _ExtensionType<ConsumerProxyBase::BootModeAttribute> extension_type;
++
++ static_assert(std::is_base_of<typename CommonAPI::AttributeExtension<ConsumerProxyBase::BootModeAttribute>, extension_type>::value,
++ "Not CommonAPI Attribute Extension!");
++ #ifdef WIN32
++ BootModeAttributeExtension() {}
++ #endif
++
++ BootModeAttributeExtension(ConsumerProxyBase& proxy): attributeExtension_(proxy.getBootModeAttribute()) {
++ }
++
++ inline extension_type& getBootModeAttributeExtension() {
++ return attributeExtension_;
++ }
++
++ private:
++ extension_type attributeExtension_;
++ };
++
++ template <template <typename > class _ExtensionType>
++ class RestartReasonAttributeExtension {
++ public:
++ typedef _ExtensionType<ConsumerProxyBase::RestartReasonAttribute> extension_type;
++
++ static_assert(std::is_base_of<typename CommonAPI::AttributeExtension<ConsumerProxyBase::RestartReasonAttribute>, extension_type>::value,
++ "Not CommonAPI Attribute Extension!");
++ #ifdef WIN32
++ RestartReasonAttributeExtension() {}
++ #endif
++
++ RestartReasonAttributeExtension(ConsumerProxyBase& proxy): attributeExtension_(proxy.getRestartReasonAttribute()) {
++ }
++
++ inline extension_type& getRestartReasonAttributeExtension() {
++ return attributeExtension_;
++ }
++
++ private:
++ extension_type attributeExtension_;
++ };
++
++ template <template <typename > class _ExtensionType>
++ class ShutdownReasonAttributeExtension {
++ public:
++ typedef _ExtensionType<ConsumerProxyBase::ShutdownReasonAttribute> extension_type;
++
++ static_assert(std::is_base_of<typename CommonAPI::AttributeExtension<ConsumerProxyBase::ShutdownReasonAttribute>, extension_type>::value,
++ "Not CommonAPI Attribute Extension!");
++ #ifdef WIN32
++ ShutdownReasonAttributeExtension() {}
++ #endif
++
++ ShutdownReasonAttributeExtension(ConsumerProxyBase& proxy): attributeExtension_(proxy.getShutdownReasonAttribute()) {
++ }
++
++ inline extension_type& getShutdownReasonAttributeExtension() {
++ return attributeExtension_;
++ }
++
++ private:
++ extension_type attributeExtension_;
++ };
++
++ template <template <typename > class _ExtensionType>
++ class WakeUpReasonAttributeExtension {
++ public:
++ typedef _ExtensionType<ConsumerProxyBase::WakeUpReasonAttribute> extension_type;
++
++ static_assert(std::is_base_of<typename CommonAPI::AttributeExtension<ConsumerProxyBase::WakeUpReasonAttribute>, extension_type>::value,
++ "Not CommonAPI Attribute Extension!");
++ #ifdef WIN32
++ WakeUpReasonAttributeExtension() {}
++ #endif
++
++ WakeUpReasonAttributeExtension(ConsumerProxyBase& proxy): attributeExtension_(proxy.getWakeUpReasonAttribute()) {
++ }
++
++ inline extension_type& getWakeUpReasonAttributeExtension() {
++ return attributeExtension_;
++ }
++
++ private:
++ extension_type attributeExtension_;
++ };
++
++} // namespace ConsumerExtensions
++
++//
++// ConsumerProxy Implementation
++//
++template <typename ... _AttributeExtensions>
++ConsumerProxy<_AttributeExtensions...>::ConsumerProxy(std::shared_ptr<CommonAPI::Proxy> delegate):
++ _AttributeExtensions(*(std::dynamic_pointer_cast<ConsumerProxyBase>(delegate)))...,
++ delegate_(std::dynamic_pointer_cast<ConsumerProxyBase>(delegate)) {
++}
++
++template <typename ... _AttributeExtensions>
++ConsumerProxy<_AttributeExtensions...>::~ConsumerProxy() {
++}
++
++template <typename ... _AttributeExtensions>
++void ConsumerProxy<_AttributeExtensions...>::GetAppHealthCount(CommonAPI::CallStatus& callStatus, uint32_t& Count) {
++ delegate_->GetAppHealthCount(callStatus, Count);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> ConsumerProxy<_AttributeExtensions...>::GetAppHealthCountAsync(GetAppHealthCountAsyncCallback callback) {
++ return delegate_->GetAppHealthCountAsync(callback);
++}
++template <typename ... _AttributeExtensions>
++void ConsumerProxy<_AttributeExtensions...>::LifecycleRequestComplete(const uint32_t& RequestId, const int32_t& Status, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) {
++ delegate_->LifecycleRequestComplete(RequestId, Status, callStatus, ErrorCode);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> ConsumerProxy<_AttributeExtensions...>::LifecycleRequestCompleteAsync(const uint32_t& RequestId, const int32_t& Status, LifecycleRequestCompleteAsyncCallback callback) {
++ return delegate_->LifecycleRequestCompleteAsync(RequestId, Status, callback);
++}
++template <typename ... _AttributeExtensions>
++void ConsumerProxy<_AttributeExtensions...>::GetInterfaceVersion(CommonAPI::CallStatus& callStatus, uint32_t& Version) {
++ delegate_->GetInterfaceVersion(callStatus, Version);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> ConsumerProxy<_AttributeExtensions...>::GetInterfaceVersionAsync(GetInterfaceVersionAsyncCallback callback) {
++ return delegate_->GetInterfaceVersionAsync(callback);
++}
++template <typename ... _AttributeExtensions>
++void ConsumerProxy<_AttributeExtensions...>::GetApplicationMode(CommonAPI::CallStatus& callStatus, int32_t& ErrorCode, int32_t& ApplicationModeId) {
++ delegate_->GetApplicationMode(callStatus, ErrorCode, ApplicationModeId);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> ConsumerProxy<_AttributeExtensions...>::GetApplicationModeAsync(GetApplicationModeAsyncCallback callback) {
++ return delegate_->GetApplicationModeAsync(callback);
++}
++template <typename ... _AttributeExtensions>
++void ConsumerProxy<_AttributeExtensions...>::UnRegisterSession(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) {
++ delegate_->UnRegisterSession(SessionName, SessionOwner, SeatID, callStatus, ErrorCode);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> ConsumerProxy<_AttributeExtensions...>::UnRegisterSessionAsync(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, UnRegisterSessionAsyncCallback callback) {
++ return delegate_->UnRegisterSessionAsync(SessionName, SessionOwner, SeatID, callback);
++}
++template <typename ... _AttributeExtensions>
++void ConsumerProxy<_AttributeExtensions...>::RegisterSession(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, const int32_t& SessionState, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) {
++ delegate_->RegisterSession(SessionName, SessionOwner, SeatID, SessionState, callStatus, ErrorCode);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> ConsumerProxy<_AttributeExtensions...>::RegisterSessionAsync(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, const int32_t& SessionState, RegisterSessionAsyncCallback callback) {
++ return delegate_->RegisterSessionAsync(SessionName, SessionOwner, SeatID, SessionState, callback);
++}
++template <typename ... _AttributeExtensions>
++void ConsumerProxy<_AttributeExtensions...>::UnRegisterShutdownClient(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) {
++ delegate_->UnRegisterShutdownClient(BusName, ObjName, ShutdownMode, callStatus, ErrorCode);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> ConsumerProxy<_AttributeExtensions...>::UnRegisterShutdownClientAsync(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, UnRegisterShutdownClientAsyncCallback callback) {
++ return delegate_->UnRegisterShutdownClientAsync(BusName, ObjName, ShutdownMode, callback);
++}
++template <typename ... _AttributeExtensions>
++void ConsumerProxy<_AttributeExtensions...>::RegisterShutdownClient(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, const uint32_t& TimeoutMs, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) {
++ delegate_->RegisterShutdownClient(BusName, ObjName, ShutdownMode, TimeoutMs, callStatus, ErrorCode);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> ConsumerProxy<_AttributeExtensions...>::RegisterShutdownClientAsync(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, const uint32_t& TimeoutMs, RegisterShutdownClientAsyncCallback callback) {
++ return delegate_->RegisterShutdownClientAsync(BusName, ObjName, ShutdownMode, TimeoutMs, callback);
++}
++template <typename ... _AttributeExtensions>
++void ConsumerProxy<_AttributeExtensions...>::GetNodeState(CommonAPI::CallStatus& callStatus, int32_t& ErrorCode, int32_t& NodeStateId) {
++ delegate_->GetNodeState(callStatus, ErrorCode, NodeStateId);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> ConsumerProxy<_AttributeExtensions...>::GetNodeStateAsync(GetNodeStateAsyncCallback callback) {
++ return delegate_->GetNodeStateAsync(callback);
++}
++template <typename ... _AttributeExtensions>
++void ConsumerProxy<_AttributeExtensions...>::GetSessionState(const std::string& SessionName, const int32_t& SeatID, CommonAPI::CallStatus& callStatus, int32_t& SessionState, int32_t& ErrorCode) {
++ delegate_->GetSessionState(SessionName, SeatID, callStatus, SessionState, ErrorCode);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> ConsumerProxy<_AttributeExtensions...>::GetSessionStateAsync(const std::string& SessionName, const int32_t& SeatID, GetSessionStateAsyncCallback callback) {
++ return delegate_->GetSessionStateAsync(SessionName, SeatID, callback);
++}
++template <typename ... _AttributeExtensions>
++void ConsumerProxy<_AttributeExtensions...>::SetSessionState(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SessionState, const int32_t& SeatID, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) {
++ delegate_->SetSessionState(SessionName, SessionOwner, SessionState, SeatID, callStatus, ErrorCode);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> ConsumerProxy<_AttributeExtensions...>::SetSessionStateAsync(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SessionState, const int32_t& SeatID, SetSessionStateAsyncCallback callback) {
++ return delegate_->SetSessionStateAsync(SessionName, SessionOwner, SessionState, SeatID, callback);
++}
++
++template <typename ... _AttributeExtensions>
++std::string ConsumerProxy<_AttributeExtensions...>::getAddress() const {
++ return delegate_->getAddress();
++}
++
++template <typename ... _AttributeExtensions>
++const std::string& ConsumerProxy<_AttributeExtensions...>::getDomain() const {
++ return delegate_->getDomain();
++}
++
++template <typename ... _AttributeExtensions>
++const std::string& ConsumerProxy<_AttributeExtensions...>::getServiceId() const {
++ return delegate_->getServiceId();
++}
++
++template <typename ... _AttributeExtensions>
++const std::string& ConsumerProxy<_AttributeExtensions...>::getInstanceId() const {
++ return delegate_->getInstanceId();
++}
++
++template <typename ... _AttributeExtensions>
++bool ConsumerProxy<_AttributeExtensions...>::isAvailable() const {
++ return delegate_->isAvailable();
++}
++
++template <typename ... _AttributeExtensions>
++bool ConsumerProxy<_AttributeExtensions...>::isAvailableBlocking() const {
++ return delegate_->isAvailableBlocking();
++}
++
++template <typename ... _AttributeExtensions>
++CommonAPI::ProxyStatusEvent& ConsumerProxy<_AttributeExtensions...>::getProxyStatusEvent() {
++ return delegate_->getProxyStatusEvent();
++}
++
++template <typename ... _AttributeExtensions>
++CommonAPI::InterfaceVersionAttribute& ConsumerProxy<_AttributeExtensions...>::getInterfaceVersionAttribute() {
++ return delegate_->getInterfaceVersionAttribute();
++}
++
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
++
++namespace CommonAPI {
++template<template<typename > class _AttributeExtension>
++struct DefaultAttributeProxyFactoryHelper<org::genivi::NodeStateManager::ConsumerProxy,
++ _AttributeExtension> {
++ typedef typename org::genivi::NodeStateManager::ConsumerProxy<
++ org::genivi::NodeStateManager::ConsumerExtensions::BootModeAttributeExtension<_AttributeExtension>,
++ org::genivi::NodeStateManager::ConsumerExtensions::RestartReasonAttributeExtension<_AttributeExtension>,
++ org::genivi::NodeStateManager::ConsumerExtensions::ShutdownReasonAttributeExtension<_AttributeExtension>,
++ org::genivi::NodeStateManager::ConsumerExtensions::WakeUpReasonAttributeExtension<_AttributeExtension>
++ > class_t;
++};
++}
++
++#endif // ORG_GENIVI_NODESTATEMANAGER_Consumer_PROXY_H_
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerProxyBase.h b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerProxyBase.h
+new file mode 100644
+index 0000000..b0afe99
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerProxyBase.h
+@@ -0,0 +1,95 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_NODESTATEMANAGER_Consumer_PROXY_BASE_H_
++#define ORG_GENIVI_NODESTATEMANAGER_Consumer_PROXY_BASE_H_
++
++#include "Consumer.h"
++
++
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <vector>
++
++#include <CommonAPI/Attribute.h>
++#include <CommonAPI/Event.h>
++#include <CommonAPI/Proxy.h>
++#include <functional>
++#include <future>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++class ConsumerProxyBase: virtual public CommonAPI::Proxy {
++ public:
++ typedef CommonAPI::ReadonlyAttribute<int32_t> BootModeAttribute;
++ typedef CommonAPI::ReadonlyAttribute<int32_t> RestartReasonAttribute;
++ typedef CommonAPI::ReadonlyAttribute<int32_t> ShutdownReasonAttribute;
++ typedef CommonAPI::ReadonlyAttribute<int32_t> WakeUpReasonAttribute;
++ typedef CommonAPI::Event<int32_t> NodeApplicationModeEvent;
++ typedef CommonAPI::Event<std::string, int32_t, int32_t> SessionStateChangedEvent;
++ typedef CommonAPI::Event<int32_t> NodeStateEvent;
++
++ typedef std::function<void(const CommonAPI::CallStatus&, const uint32_t&)> GetAppHealthCountAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const int32_t&)> LifecycleRequestCompleteAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const uint32_t&)> GetInterfaceVersionAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const int32_t&, const int32_t&)> GetApplicationModeAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const int32_t&)> UnRegisterSessionAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const int32_t&)> RegisterSessionAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const int32_t&)> UnRegisterShutdownClientAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const int32_t&)> RegisterShutdownClientAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const int32_t&, const int32_t&)> GetNodeStateAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const int32_t&, const int32_t&)> GetSessionStateAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const int32_t&)> SetSessionStateAsyncCallback;
++
++ virtual BootModeAttribute& getBootModeAttribute() = 0;
++ virtual RestartReasonAttribute& getRestartReasonAttribute() = 0;
++ virtual ShutdownReasonAttribute& getShutdownReasonAttribute() = 0;
++ virtual WakeUpReasonAttribute& getWakeUpReasonAttribute() = 0;
++
++ virtual NodeApplicationModeEvent& getNodeApplicationModeEvent() = 0;
++ virtual SessionStateChangedEvent& getSessionStateChangedEvent() = 0;
++ virtual NodeStateEvent& getNodeStateEvent() = 0;
++
++ virtual void GetAppHealthCount(CommonAPI::CallStatus& callStatus, uint32_t& Count) = 0;
++ virtual std::future<CommonAPI::CallStatus> GetAppHealthCountAsync(GetAppHealthCountAsyncCallback callback) = 0;
++ virtual void LifecycleRequestComplete(const uint32_t& RequestId, const int32_t& Status, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) = 0;
++ virtual std::future<CommonAPI::CallStatus> LifecycleRequestCompleteAsync(const uint32_t& RequestId, const int32_t& Status, LifecycleRequestCompleteAsyncCallback callback) = 0;
++ virtual void GetInterfaceVersion(CommonAPI::CallStatus& callStatus, uint32_t& Version) = 0;
++ virtual std::future<CommonAPI::CallStatus> GetInterfaceVersionAsync(GetInterfaceVersionAsyncCallback callback) = 0;
++ virtual void GetApplicationMode(CommonAPI::CallStatus& callStatus, int32_t& ErrorCode, int32_t& ApplicationModeId) = 0;
++ virtual std::future<CommonAPI::CallStatus> GetApplicationModeAsync(GetApplicationModeAsyncCallback callback) = 0;
++ virtual void UnRegisterSession(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) = 0;
++ virtual std::future<CommonAPI::CallStatus> UnRegisterSessionAsync(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, UnRegisterSessionAsyncCallback callback) = 0;
++ virtual void RegisterSession(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, const int32_t& SessionState, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) = 0;
++ virtual std::future<CommonAPI::CallStatus> RegisterSessionAsync(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SeatID, const int32_t& SessionState, RegisterSessionAsyncCallback callback) = 0;
++ virtual void UnRegisterShutdownClient(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) = 0;
++ virtual std::future<CommonAPI::CallStatus> UnRegisterShutdownClientAsync(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, UnRegisterShutdownClientAsyncCallback callback) = 0;
++ virtual void RegisterShutdownClient(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, const uint32_t& TimeoutMs, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) = 0;
++ virtual std::future<CommonAPI::CallStatus> RegisterShutdownClientAsync(const std::string& BusName, const std::string& ObjName, const uint32_t& ShutdownMode, const uint32_t& TimeoutMs, RegisterShutdownClientAsyncCallback callback) = 0;
++ virtual void GetNodeState(CommonAPI::CallStatus& callStatus, int32_t& ErrorCode, int32_t& NodeStateId) = 0;
++ virtual std::future<CommonAPI::CallStatus> GetNodeStateAsync(GetNodeStateAsyncCallback callback) = 0;
++ virtual void GetSessionState(const std::string& SessionName, const int32_t& SeatID, CommonAPI::CallStatus& callStatus, int32_t& SessionState, int32_t& ErrorCode) = 0;
++ virtual std::future<CommonAPI::CallStatus> GetSessionStateAsync(const std::string& SessionName, const int32_t& SeatID, GetSessionStateAsyncCallback callback) = 0;
++ virtual void SetSessionState(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SessionState, const int32_t& SeatID, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) = 0;
++ virtual std::future<CommonAPI::CallStatus> SetSessionStateAsync(const std::string& SessionName, const std::string& SessionOwner, const int32_t& SessionState, const int32_t& SeatID, SetSessionStateAsyncCallback callback) = 0;
++};
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
++
++#endif // ORG_GENIVI_NODESTATEMANAGER_Consumer_PROXY_BASE_H_
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerStub.h b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerStub.h
+new file mode 100644
+index 0000000..107749e
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerStub.h
+@@ -0,0 +1,152 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_NODESTATEMANAGER_Consumer_STUB_H_
++#define ORG_GENIVI_NODESTATEMANAGER_Consumer_STUB_H_
++
++
++
++
++#include "Consumer.h"
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <unordered_set>
++#include <vector>
++
++#include <CommonAPI/Stub.h>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++/**
++ * Receives messages from remote and handles all dispatching of deserialized calls
++ * to a stub for the service Consumer. Also provides means to send broadcasts
++ * and attribute-changed-notifications of observable attributes as defined by this service.
++ * An application developer should not need to bother with this class.
++ */
++class ConsumerStubAdapter: virtual public CommonAPI::StubAdapter, public Consumer {
++ public:
++
++ /**
++ * Sends a broadcast event for NodeApplicationMode. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireNodeApplicationModeEvent(const int32_t& ApplicationModeId) = 0;
++ /**
++ * Sends a broadcast event for SessionStateChanged. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireSessionStateChangedEvent(const std::string& SessionStateName, const int32_t& SeatID, const int32_t& SessionState) = 0;
++ /**
++ * Sends a broadcast event for NodeState. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireNodeStateEvent(const int32_t& NodeState) = 0;
++
++
++ virtual void deactivateManagedInstances() = 0;
++protected:
++ /**
++ * Defines properties for storing the ClientIds of clients / proxies that have
++ * subscribed to the selective broadcasts
++ */
++};
++
++
++/**
++ * Defines the necessary callbacks to handle remote set events related to the attributes
++ * defined in the IDL description for Consumer.
++ * For each attribute two callbacks are defined:
++ * - a verification callback that allows to verify the requested value and to prevent setting
++ * e.g. an invalid value ("onRemoteSet<AttributeName>").
++ * - an action callback to do local work after the attribute value has been changed
++ * ("onRemote<AttributeName>Changed").
++ *
++ * This class and the one below are the ones an application developer needs to have
++ * a look at if he wants to implement a service.
++ */
++class ConsumerStubRemoteEvent {
++ public:
++ virtual ~ConsumerStubRemoteEvent() { }
++
++
++
++
++
++};
++
++
++/**
++ * Defines the interface that must be implemented by any class that should provide
++ * the service Consumer to remote clients.
++ * This class and the one above are the ones an application developer needs to have
++ * a look at if he wants to implement a service.
++ */
++class ConsumerStub: public virtual CommonAPI::Stub<ConsumerStubAdapter, ConsumerStubRemoteEvent> {
++public:
++ virtual ~ConsumerStub() { }
++ virtual const CommonAPI::Version& getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
++
++ /// Provides getter access to the attribute BootMode
++ virtual const int32_t& getBootModeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
++ /// Provides getter access to the attribute RestartReason
++ virtual const int32_t& getRestartReasonAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
++ /// Provides getter access to the attribute ShutdownReason
++ virtual const int32_t& getShutdownReasonAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
++ /// Provides getter access to the attribute WakeUpReason
++ virtual const int32_t& getWakeUpReasonAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
++
++ /// This is the method that will be called on remote calls on the method GetAppHealthCount.
++ virtual void GetAppHealthCount(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t& Count) = 0;
++ /// This is the method that will be called on remote calls on the method LifecycleRequestComplete.
++ virtual void LifecycleRequestComplete(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t RequestId, int32_t Status, int32_t& ErrorCode) = 0;
++ /// This is the method that will be called on remote calls on the method GetInterfaceVersion.
++ virtual void GetInterfaceVersion(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t& Version) = 0;
++ /// This is the method that will be called on remote calls on the method GetApplicationMode.
++ virtual void GetApplicationMode(const std::shared_ptr<CommonAPI::ClientId> clientId, int32_t& ErrorCode, int32_t& ApplicationModeId) = 0;
++ /// This is the method that will be called on remote calls on the method UnRegisterSession.
++ virtual void UnRegisterSession(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string SessionName, std::string SessionOwner, int32_t SeatID, int32_t& ErrorCode) = 0;
++ /// This is the method that will be called on remote calls on the method RegisterSession.
++ virtual void RegisterSession(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string SessionName, std::string SessionOwner, int32_t SeatID, int32_t SessionState, int32_t& ErrorCode) = 0;
++ /// This is the method that will be called on remote calls on the method UnRegisterShutdownClient.
++ virtual void UnRegisterShutdownClient(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string BusName, std::string ObjName, uint32_t ShutdownMode, int32_t& ErrorCode) = 0;
++ /// This is the method that will be called on remote calls on the method RegisterShutdownClient.
++ virtual void RegisterShutdownClient(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string BusName, std::string ObjName, uint32_t ShutdownMode, uint32_t TimeoutMs, int32_t& ErrorCode) = 0;
++ /// This is the method that will be called on remote calls on the method GetNodeState.
++ virtual void GetNodeState(const std::shared_ptr<CommonAPI::ClientId> clientId, int32_t& ErrorCode, int32_t& NodeStateId) = 0;
++ /// This is the method that will be called on remote calls on the method GetSessionState.
++ virtual void GetSessionState(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string SessionName, int32_t SeatID, int32_t& SessionState, int32_t& ErrorCode) = 0;
++ /// This is the method that will be called on remote calls on the method SetSessionState.
++ virtual void SetSessionState(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string SessionName, std::string SessionOwner, int32_t SessionState, int32_t SeatID, int32_t& ErrorCode) = 0;
++ /// Sends a broadcast event for NodeApplicationMode.
++ virtual void fireNodeApplicationModeEvent(const int32_t& ApplicationModeId) = 0;
++ /// Sends a broadcast event for SessionStateChanged.
++ virtual void fireSessionStateChangedEvent(const std::string& SessionStateName, const int32_t& SeatID, const int32_t& SessionState) = 0;
++ /// Sends a broadcast event for NodeState.
++ virtual void fireNodeStateEvent(const int32_t& NodeState) = 0;
++
++ using CommonAPI::Stub<ConsumerStubAdapter, ConsumerStubRemoteEvent>::initStubAdapter;
++ typedef CommonAPI::Stub<ConsumerStubAdapter, ConsumerStubRemoteEvent>::StubAdapterType StubAdapterType;
++ typedef CommonAPI::Stub<ConsumerStubAdapter, ConsumerStubRemoteEvent>::RemoteEventHandlerType RemoteEventHandlerType;
++ typedef ConsumerStubRemoteEvent RemoteEventType;
++ typedef Consumer StubInterface;
++};
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
++
++#endif // ORG_GENIVI_NODESTATEMANAGER_Consumer_STUB_H_
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerStubDefault.cpp b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerStubDefault.cpp
+new file mode 100644
+index 0000000..18edb79
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerStubDefault.cpp
+@@ -0,0 +1,239 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++#include <org/genivi/NodeStateManager/ConsumerStubDefault.h>
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++ConsumerStubDefault::ConsumerStubDefault():
++ remoteEventHandler_(this),
++ interfaceVersion_(Consumer::getInterfaceVersion()) {
++}
++
++const CommonAPI::Version& ConsumerStubDefault::getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> clientId) {
++ return interfaceVersion_;
++}
++
++ConsumerStubRemoteEvent* ConsumerStubDefault::initStubAdapter(const std::shared_ptr<ConsumerStubAdapter>& stubAdapter) {
++ CommonAPI::Stub<ConsumerStubAdapter, ConsumerStubRemoteEvent>::stubAdapter_ = stubAdapter;
++ return &remoteEventHandler_;
++}
++
++const int32_t& ConsumerStubDefault::getBootModeAttribute() {
++ return bootModeAttributeValue_;
++}
++
++const int32_t& ConsumerStubDefault::getBootModeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) {
++ return getBootModeAttribute();
++}
++
++void ConsumerStubDefault::setBootModeAttribute(int32_t value) {
++ trySetBootModeAttribute(std::move(value));
++}
++
++bool ConsumerStubDefault::trySetBootModeAttribute(int32_t value) {
++ if (!validateBootModeAttributeRequestedValue(value))
++ return false;
++
++ const bool valueChanged = (bootModeAttributeValue_ != value);
++ bootModeAttributeValue_ = std::move(value);
++ return valueChanged;
++}
++
++bool ConsumerStubDefault::validateBootModeAttributeRequestedValue(const int32_t& value) {
++ return true;
++}
++
++
++const int32_t& ConsumerStubDefault::getRestartReasonAttribute() {
++ return restartReasonAttributeValue_;
++}
++
++const int32_t& ConsumerStubDefault::getRestartReasonAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) {
++ return getRestartReasonAttribute();
++}
++
++void ConsumerStubDefault::setRestartReasonAttribute(int32_t value) {
++ trySetRestartReasonAttribute(std::move(value));
++}
++
++bool ConsumerStubDefault::trySetRestartReasonAttribute(int32_t value) {
++ if (!validateRestartReasonAttributeRequestedValue(value))
++ return false;
++
++ const bool valueChanged = (restartReasonAttributeValue_ != value);
++ restartReasonAttributeValue_ = std::move(value);
++ return valueChanged;
++}
++
++bool ConsumerStubDefault::validateRestartReasonAttributeRequestedValue(const int32_t& value) {
++ return true;
++}
++
++
++const int32_t& ConsumerStubDefault::getShutdownReasonAttribute() {
++ return shutdownReasonAttributeValue_;
++}
++
++const int32_t& ConsumerStubDefault::getShutdownReasonAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) {
++ return getShutdownReasonAttribute();
++}
++
++void ConsumerStubDefault::setShutdownReasonAttribute(int32_t value) {
++ trySetShutdownReasonAttribute(std::move(value));
++}
++
++bool ConsumerStubDefault::trySetShutdownReasonAttribute(int32_t value) {
++ if (!validateShutdownReasonAttributeRequestedValue(value))
++ return false;
++
++ const bool valueChanged = (shutdownReasonAttributeValue_ != value);
++ shutdownReasonAttributeValue_ = std::move(value);
++ return valueChanged;
++}
++
++bool ConsumerStubDefault::validateShutdownReasonAttributeRequestedValue(const int32_t& value) {
++ return true;
++}
++
++
++const int32_t& ConsumerStubDefault::getWakeUpReasonAttribute() {
++ return wakeUpReasonAttributeValue_;
++}
++
++const int32_t& ConsumerStubDefault::getWakeUpReasonAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) {
++ return getWakeUpReasonAttribute();
++}
++
++void ConsumerStubDefault::setWakeUpReasonAttribute(int32_t value) {
++ trySetWakeUpReasonAttribute(std::move(value));
++}
++
++bool ConsumerStubDefault::trySetWakeUpReasonAttribute(int32_t value) {
++ if (!validateWakeUpReasonAttributeRequestedValue(value))
++ return false;
++
++ const bool valueChanged = (wakeUpReasonAttributeValue_ != value);
++ wakeUpReasonAttributeValue_ = std::move(value);
++ return valueChanged;
++}
++
++bool ConsumerStubDefault::validateWakeUpReasonAttributeRequestedValue(const int32_t& value) {
++ return true;
++}
++
++
++
++void ConsumerStubDefault::GetAppHealthCount(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t& Count) {
++ // Call old style methods in default
++ GetAppHealthCount(Count);
++}
++void ConsumerStubDefault::GetAppHealthCount(uint32_t& Count) {
++ // No operation in default
++}
++
++void ConsumerStubDefault::LifecycleRequestComplete(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t RequestId, int32_t Status, int32_t& ErrorCode) {
++ // Call old style methods in default
++ LifecycleRequestComplete(RequestId, Status, ErrorCode);
++}
++void ConsumerStubDefault::LifecycleRequestComplete(uint32_t RequestId, int32_t Status, int32_t& ErrorCode) {
++ // No operation in default
++}
++
++void ConsumerStubDefault::GetInterfaceVersion(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t& Version) {
++ // Call old style methods in default
++ GetInterfaceVersion(Version);
++}
++void ConsumerStubDefault::GetInterfaceVersion(uint32_t& Version) {
++ // No operation in default
++}
++
++void ConsumerStubDefault::GetApplicationMode(const std::shared_ptr<CommonAPI::ClientId> clientId, int32_t& ErrorCode, int32_t& ApplicationModeId) {
++ // Call old style methods in default
++ GetApplicationMode(ErrorCode, ApplicationModeId);
++}
++void ConsumerStubDefault::GetApplicationMode(int32_t& ErrorCode, int32_t& ApplicationModeId) {
++ // No operation in default
++}
++
++void ConsumerStubDefault::UnRegisterSession(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string SessionName, std::string SessionOwner, int32_t SeatID, int32_t& ErrorCode) {
++ // Call old style methods in default
++ UnRegisterSession(SessionName, SessionOwner, SeatID, ErrorCode);
++}
++void ConsumerStubDefault::UnRegisterSession(std::string SessionName, std::string SessionOwner, int32_t SeatID, int32_t& ErrorCode) {
++ // No operation in default
++}
++
++void ConsumerStubDefault::RegisterSession(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string SessionName, std::string SessionOwner, int32_t SeatID, int32_t SessionState, int32_t& ErrorCode) {
++ // Call old style methods in default
++ RegisterSession(SessionName, SessionOwner, SeatID, SessionState, ErrorCode);
++}
++void ConsumerStubDefault::RegisterSession(std::string SessionName, std::string SessionOwner, int32_t SeatID, int32_t SessionState, int32_t& ErrorCode) {
++ // No operation in default
++}
++
++void ConsumerStubDefault::UnRegisterShutdownClient(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string BusName, std::string ObjName, uint32_t ShutdownMode, int32_t& ErrorCode) {
++ // Call old style methods in default
++ UnRegisterShutdownClient(BusName, ObjName, ShutdownMode, ErrorCode);
++}
++void ConsumerStubDefault::UnRegisterShutdownClient(std::string BusName, std::string ObjName, uint32_t ShutdownMode, int32_t& ErrorCode) {
++ // No operation in default
++}
++
++void ConsumerStubDefault::RegisterShutdownClient(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string BusName, std::string ObjName, uint32_t ShutdownMode, uint32_t TimeoutMs, int32_t& ErrorCode) {
++ // Call old style methods in default
++ RegisterShutdownClient(BusName, ObjName, ShutdownMode, TimeoutMs, ErrorCode);
++}
++void ConsumerStubDefault::RegisterShutdownClient(std::string BusName, std::string ObjName, uint32_t ShutdownMode, uint32_t TimeoutMs, int32_t& ErrorCode) {
++ // No operation in default
++}
++
++void ConsumerStubDefault::GetNodeState(const std::shared_ptr<CommonAPI::ClientId> clientId, int32_t& ErrorCode, int32_t& NodeStateId) {
++ // Call old style methods in default
++ GetNodeState(ErrorCode, NodeStateId);
++}
++void ConsumerStubDefault::GetNodeState(int32_t& ErrorCode, int32_t& NodeStateId) {
++ // No operation in default
++}
++
++void ConsumerStubDefault::GetSessionState(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string SessionName, int32_t SeatID, int32_t& SessionState, int32_t& ErrorCode) {
++ // Call old style methods in default
++ GetSessionState(SessionName, SeatID, SessionState, ErrorCode);
++}
++void ConsumerStubDefault::GetSessionState(std::string SessionName, int32_t SeatID, int32_t& SessionState, int32_t& ErrorCode) {
++ // No operation in default
++}
++
++void ConsumerStubDefault::SetSessionState(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string SessionName, std::string SessionOwner, int32_t SessionState, int32_t SeatID, int32_t& ErrorCode) {
++ // Call old style methods in default
++ SetSessionState(SessionName, SessionOwner, SessionState, SeatID, ErrorCode);
++}
++void ConsumerStubDefault::SetSessionState(std::string SessionName, std::string SessionOwner, int32_t SessionState, int32_t SeatID, int32_t& ErrorCode) {
++ // No operation in default
++}
++
++
++void ConsumerStubDefault::fireNodeApplicationModeEvent(const int32_t& ApplicationModeId) {
++ stubAdapter_->fireNodeApplicationModeEvent(ApplicationModeId);
++}
++void ConsumerStubDefault::fireSessionStateChangedEvent(const std::string& SessionStateName, const int32_t& SeatID, const int32_t& SessionState) {
++ stubAdapter_->fireSessionStateChangedEvent(SessionStateName, SeatID, SessionState);
++}
++void ConsumerStubDefault::fireNodeStateEvent(const int32_t& NodeState) {
++ stubAdapter_->fireNodeStateEvent(NodeState);
++}
++
++
++ConsumerStubDefault::RemoteEventHandler::RemoteEventHandler(ConsumerStubDefault* defaultStub):
++ defaultStub_(defaultStub) {
++}
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerStubDefault.h b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerStubDefault.h
+new file mode 100644
+index 0000000..b28944c
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/ConsumerStubDefault.h
+@@ -0,0 +1,128 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_NODESTATEMANAGER_Consumer_STUB_DEFAULT_H_
++#define ORG_GENIVI_NODESTATEMANAGER_Consumer_STUB_DEFAULT_H_
++
++
++#include <org/genivi/NodeStateManager/ConsumerStub.h>
++#include <sstream>
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++/**
++ * Provides a default implementation for ConsumerStubRemoteEvent and
++ * ConsumerStub. Method callbacks have an empty implementation,
++ * remote set calls on attributes will always change the value of the attribute
++ * to the one received.
++ *
++ * Override this stub if you only want to provide a subset of the functionality
++ * that would be defined for this service, and/or if you do not need any non-default
++ * behaviour.
++ */
++class ConsumerStubDefault : public virtual ConsumerStub {
++public:
++ ConsumerStubDefault();
++
++ ConsumerStubRemoteEvent* initStubAdapter(const std::shared_ptr<ConsumerStubAdapter>& stubAdapter);
++
++ const CommonAPI::Version& getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> clientId);
++
++ virtual const int32_t& getBootModeAttribute();
++ virtual const int32_t& getBootModeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId);
++ virtual void setBootModeAttribute(int32_t value);
++ virtual const int32_t& getRestartReasonAttribute();
++ virtual const int32_t& getRestartReasonAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId);
++ virtual void setRestartReasonAttribute(int32_t value);
++ virtual const int32_t& getShutdownReasonAttribute();
++ virtual const int32_t& getShutdownReasonAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId);
++ virtual void setShutdownReasonAttribute(int32_t value);
++ virtual const int32_t& getWakeUpReasonAttribute();
++ virtual const int32_t& getWakeUpReasonAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId);
++ virtual void setWakeUpReasonAttribute(int32_t value);
++
++ virtual void GetAppHealthCount(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t& Count);
++ virtual void GetAppHealthCount(uint32_t& Count);
++
++ virtual void LifecycleRequestComplete(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t RequestId, int32_t Status, int32_t& ErrorCode);
++ virtual void LifecycleRequestComplete(uint32_t RequestId, int32_t Status, int32_t& ErrorCode);
++
++ virtual void GetInterfaceVersion(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t& Version);
++ virtual void GetInterfaceVersion(uint32_t& Version);
++
++ virtual void GetApplicationMode(const std::shared_ptr<CommonAPI::ClientId> clientId, int32_t& ErrorCode, int32_t& ApplicationModeId);
++ virtual void GetApplicationMode(int32_t& ErrorCode, int32_t& ApplicationModeId);
++
++ virtual void UnRegisterSession(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string SessionName, std::string SessionOwner, int32_t SeatID, int32_t& ErrorCode);
++ virtual void UnRegisterSession(std::string SessionName, std::string SessionOwner, int32_t SeatID, int32_t& ErrorCode);
++
++ virtual void RegisterSession(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string SessionName, std::string SessionOwner, int32_t SeatID, int32_t SessionState, int32_t& ErrorCode);
++ virtual void RegisterSession(std::string SessionName, std::string SessionOwner, int32_t SeatID, int32_t SessionState, int32_t& ErrorCode);
++
++ virtual void UnRegisterShutdownClient(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string BusName, std::string ObjName, uint32_t ShutdownMode, int32_t& ErrorCode);
++ virtual void UnRegisterShutdownClient(std::string BusName, std::string ObjName, uint32_t ShutdownMode, int32_t& ErrorCode);
++
++ virtual void RegisterShutdownClient(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string BusName, std::string ObjName, uint32_t ShutdownMode, uint32_t TimeoutMs, int32_t& ErrorCode);
++ virtual void RegisterShutdownClient(std::string BusName, std::string ObjName, uint32_t ShutdownMode, uint32_t TimeoutMs, int32_t& ErrorCode);
++
++ virtual void GetNodeState(const std::shared_ptr<CommonAPI::ClientId> clientId, int32_t& ErrorCode, int32_t& NodeStateId);
++ virtual void GetNodeState(int32_t& ErrorCode, int32_t& NodeStateId);
++
++ virtual void GetSessionState(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string SessionName, int32_t SeatID, int32_t& SessionState, int32_t& ErrorCode);
++ virtual void GetSessionState(std::string SessionName, int32_t SeatID, int32_t& SessionState, int32_t& ErrorCode);
++
++ virtual void SetSessionState(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string SessionName, std::string SessionOwner, int32_t SessionState, int32_t SeatID, int32_t& ErrorCode);
++ virtual void SetSessionState(std::string SessionName, std::string SessionOwner, int32_t SessionState, int32_t SeatID, int32_t& ErrorCode);
++
++
++ virtual void fireNodeApplicationModeEvent(const int32_t& ApplicationModeId);
++ virtual void fireSessionStateChangedEvent(const std::string& SessionStateName, const int32_t& SeatID, const int32_t& SessionState);
++ virtual void fireNodeStateEvent(const int32_t& NodeState);
++
++
++protected:
++ virtual bool trySetBootModeAttribute(int32_t value);
++ virtual bool validateBootModeAttributeRequestedValue(const int32_t& value);
++ virtual bool trySetRestartReasonAttribute(int32_t value);
++ virtual bool validateRestartReasonAttributeRequestedValue(const int32_t& value);
++ virtual bool trySetShutdownReasonAttribute(int32_t value);
++ virtual bool validateShutdownReasonAttributeRequestedValue(const int32_t& value);
++ virtual bool trySetWakeUpReasonAttribute(int32_t value);
++ virtual bool validateWakeUpReasonAttributeRequestedValue(const int32_t& value);
++ class RemoteEventHandler: public virtual ConsumerStubRemoteEvent {
++ public:
++ RemoteEventHandler(ConsumerStubDefault* defaultStub);
++
++
++
++
++
++
++ private:
++ ConsumerStubDefault* defaultStub_;
++ };
++private:
++ ConsumerStubDefault::RemoteEventHandler remoteEventHandler_;
++
++ int32_t bootModeAttributeValue_;
++ int32_t restartReasonAttributeValue_;
++ int32_t shutdownReasonAttributeValue_;
++ int32_t wakeUpReasonAttributeValue_;
++
++ CommonAPI::Version interfaceVersion_;
++};
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
++
++#endif // ORG_GENIVI_NODESTATEMANAGER_Consumer_STUB_DEFAULT_H_
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumer.h b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumer.h
+new file mode 100644
+index 0000000..d810ef8
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumer.h
+@@ -0,0 +1,62 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_H_
++#define ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_H_
++
++
++
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <CommonAPI/types.h>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++class LifeCycleConsumer {
++ public:
++ virtual ~LifeCycleConsumer() { }
++
++ static inline const char* getInterfaceId();
++ static inline CommonAPI::Version getInterfaceVersion();
++};
++
++const char* LifeCycleConsumer::getInterfaceId() {
++ static const char* interfaceId = "org.genivi.NodeStateManager.LifeCycleConsumer";
++ return interfaceId;
++}
++
++CommonAPI::Version LifeCycleConsumer::getInterfaceVersion() {
++ return CommonAPI::Version(1, 0);
++}
++
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
++
++namespace CommonAPI {
++
++}
++
++
++namespace std {
++ //hashes for types
++
++ //hashes for error types
++}
++
++#endif // ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_H_
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusProxy.cpp b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusProxy.cpp
+new file mode 100644
+index 0000000..877f3cc
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusProxy.cpp
+@@ -0,0 +1,74 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#include "LifeCycleConsumerDBusProxy.h"
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++std::shared_ptr<CommonAPI::DBus::DBusProxy> createLifeCycleConsumerDBusProxy(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& interfaceName,
++ const std::string& busName,
++ const std::string& objectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyConnection) {
++ return std::make_shared<LifeCycleConsumerDBusProxy>(factory, commonApiAddress, interfaceName, busName, objectPath, dbusProxyConnection);
++}
++
++INITIALIZER(registerLifeCycleConsumerDBusProxy) {
++ CommonAPI::DBus::DBusFactory::registerProxyFactoryMethod(LifeCycleConsumer::getInterfaceId(),
++ &createLifeCycleConsumerDBusProxy);
++}
++
++LifeCycleConsumerDBusProxy::LifeCycleConsumerDBusProxy(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& interfaceName,
++ const std::string& busName,
++ const std::string& objectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyconnection):
++ CommonAPI::DBus::DBusProxy(factory, commonApiAddress, interfaceName, busName, objectPath, dbusProxyconnection)
++ {
++ }
++
++
++
++void LifeCycleConsumerDBusProxy::LifecycleRequest(const uint32_t& Request, const uint32_t& RequestId, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t, uint32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t> >::callMethodWithReply(
++ *this,
++ "LifecycleRequest",
++ "uu",
++ Request, RequestId,
++ callStatus
++ , ErrorCode);
++}
++std::future<CommonAPI::CallStatus> LifeCycleConsumerDBusProxy::LifecycleRequestAsync(const uint32_t& Request, const uint32_t& RequestId, LifecycleRequestAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t, uint32_t>,
++ CommonAPI::DBus::DBusSerializableArguments<int32_t> >::callMethodAsync(
++ *this,
++ "LifecycleRequest",
++ "uu",
++ Request, RequestId,
++ std::move(callback));
++}
++
++
++
++void LifeCycleConsumerDBusProxy::getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const {
++ ownVersionMajor = 1;
++ ownVersionMinor = 0;
++}
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusProxy.h b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusProxy.h
+new file mode 100644
+index 0000000..abaa4d1
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusProxy.h
+@@ -0,0 +1,62 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_DBUS_PROXY_H_
++#define ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_DBUS_PROXY_H_
++
++#include <org/genivi/NodeStateManager/LifeCycleConsumerProxyBase.h>
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <CommonAPI/DBus/DBusFactory.h>
++#include <CommonAPI/DBus/DBusProxy.h>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++#include <string>
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++class LifeCycleConsumerDBusProxy: virtual public LifeCycleConsumerProxyBase, virtual public CommonAPI::DBus::DBusProxy {
++ public:
++ LifeCycleConsumerDBusProxy(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& interfaceName,
++ const std::string& busName,
++ const std::string& objectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyconnection);
++
++ virtual ~LifeCycleConsumerDBusProxy() { }
++
++
++
++ virtual void LifecycleRequest(const uint32_t& Request, const uint32_t& RequestId, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode);
++ virtual std::future<CommonAPI::CallStatus> LifecycleRequestAsync(const uint32_t& Request, const uint32_t& RequestId, LifecycleRequestAsyncCallback callback);
++
++
++ virtual void getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const;
++
++ private:
++
++
++};
++
++
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
++
++#endif // ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_DBUS_PROXY_H_
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusStubAdapter.cpp b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusStubAdapter.cpp
+new file mode 100644
+index 0000000..0a2bb4d
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusStubAdapter.cpp
+@@ -0,0 +1,121 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++#include "LifeCycleConsumerDBusStubAdapter.h"
++#include <org/genivi/NodeStateManager/LifeCycleConsumer.h>
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++std::shared_ptr<CommonAPI::DBus::DBusStubAdapter> createLifeCycleConsumerDBusStubAdapter(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& interfaceName,
++ const std::string& busName,
++ const std::string& objectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyConnection,
++ const std::shared_ptr<CommonAPI::StubBase>& stubBase) {
++ return std::make_shared<LifeCycleConsumerDBusStubAdapter>(factory, commonApiAddress, interfaceName, busName, objectPath, dbusProxyConnection, stubBase);
++}
++
++INITIALIZER(registerLifeCycleConsumerDBusStubAdapter) {
++ CommonAPI::DBus::DBusFactory::registerAdapterFactoryMethod(LifeCycleConsumer::getInterfaceId(),
++ &createLifeCycleConsumerDBusStubAdapter);
++}
++
++
++
++LifeCycleConsumerDBusStubAdapterInternal::~LifeCycleConsumerDBusStubAdapterInternal() {
++ deactivateManagedInstances();
++ LifeCycleConsumerDBusStubAdapterHelper::deinit();
++}
++
++void LifeCycleConsumerDBusStubAdapterInternal::deactivateManagedInstances() {
++
++}
++
++const char* LifeCycleConsumerDBusStubAdapterInternal::getMethodsDBusIntrospectionXmlData() const {
++ static const std::string introspectionData =
++ "<method name=\"getInterfaceVersion\">\n"
++ "<arg name=\"value\" type=\"uu\" direction=\"out\" />"
++ "</method>\n"
++ "<method name=\"LifecycleRequest\">\n"
++ "<arg name=\"Request\" type=\"u\" direction=\"in\" />\n"
++ "<arg name=\"RequestId\" type=\"u\" direction=\"in\" />\n"
++ "<arg name=\"ErrorCode\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++
++ ;
++ return introspectionData.c_str();
++}
++
++CommonAPI::DBus::DBusGetAttributeStubDispatcher<
++ LifeCycleConsumerStub,
++ CommonAPI::Version
++ > LifeCycleConsumerDBusStubAdapterInternal::getLifeCycleConsumerInterfaceVersionStubDispatcher(&LifeCycleConsumerStub::getInterfaceVersion, "uu");
++
++
++
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ LifeCycleConsumerStub,
++ std::tuple<uint32_t, uint32_t>,
++ std::tuple<int32_t>
++ > LifeCycleConsumerDBusStubAdapterInternal::lifecycleRequestStubDispatcher(&LifeCycleConsumerStub::LifecycleRequest, "i");
++
++
++
++
++
++const LifeCycleConsumerDBusStubAdapterHelper::StubDispatcherTable& LifeCycleConsumerDBusStubAdapterInternal::getStubDispatcherTable() {
++ return stubDispatcherTable_;
++}
++
++const CommonAPI::DBus::StubAttributeTable& LifeCycleConsumerDBusStubAdapterInternal::getStubAttributeTable() {
++ return stubAttributeTable_;
++}
++
++LifeCycleConsumerDBusStubAdapterInternal::LifeCycleConsumerDBusStubAdapterInternal(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& dbusInterfaceName,
++ const std::string& dbusBusName,
++ const std::string& dbusObjectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection,
++ const std::shared_ptr<CommonAPI::StubBase>& stub):
++ CommonAPI::DBus::DBusStubAdapter(
++ factory,
++ commonApiAddress,
++ dbusInterfaceName,
++ dbusBusName,
++ dbusObjectPath,
++ dbusConnection,
++ false),
++ LifeCycleConsumerDBusStubAdapterHelper(
++ factory,
++ commonApiAddress,
++ dbusInterfaceName,
++ dbusBusName,
++ dbusObjectPath,
++ dbusConnection,
++ std::dynamic_pointer_cast<LifeCycleConsumerStub>(stub),
++ false),
++ stubDispatcherTable_({
++ { { "LifecycleRequest", "uu" }, &org::genivi::NodeStateManager::LifeCycleConsumerDBusStubAdapterInternal::lifecycleRequestStubDispatcher }
++ }),
++ stubAttributeTable_() {
++
++ stubDispatcherTable_.insert({ { "getInterfaceVersion", "" }, &org::genivi::NodeStateManager::LifeCycleConsumerDBusStubAdapterInternal::getLifeCycleConsumerInterfaceVersionStubDispatcher });
++}
++
++const bool LifeCycleConsumerDBusStubAdapterInternal::hasFreedesktopProperties() {
++ return false;
++}
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusStubAdapter.h b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusStubAdapter.h
+new file mode 100644
+index 0000000..ac3d6ed
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerDBusStubAdapter.h
+@@ -0,0 +1,113 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_DBUS_STUB_ADAPTER_H_
++#define ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_DBUS_STUB_ADAPTER_H_
++
++#include <org/genivi/NodeStateManager/LifeCycleConsumerStub.h>
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <CommonAPI/DBus/DBusStubAdapterHelper.h>
++#include <CommonAPI/DBus/DBusStubAdapter.h>
++#include <CommonAPI/DBus/DBusFactory.h>
++#include <CommonAPI/DBus/DBusServicePublisher.h>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++typedef CommonAPI::DBus::DBusStubAdapterHelper<LifeCycleConsumerStub> LifeCycleConsumerDBusStubAdapterHelper;
++
++class LifeCycleConsumerDBusStubAdapterInternal: public virtual LifeCycleConsumerStubAdapter, public LifeCycleConsumerDBusStubAdapterHelper {
++ public:
++ LifeCycleConsumerDBusStubAdapterInternal(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& dbusInterfaceName,
++ const std::string& dbusBusName,
++ const std::string& dbusObjectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection,
++ const std::shared_ptr<CommonAPI::StubBase>& stub);
++
++ ~LifeCycleConsumerDBusStubAdapterInternal();
++
++ virtual const bool hasFreedesktopProperties();
++
++
++
++
++ const LifeCycleConsumerDBusStubAdapterHelper::StubDispatcherTable& getStubDispatcherTable();
++ const CommonAPI::DBus::StubAttributeTable& getStubAttributeTable();
++
++ void deactivateManagedInstances();
++
++
++static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
++ LifeCycleConsumerStub,
++ CommonAPI::Version
++ > getLifeCycleConsumerInterfaceVersionStubDispatcher;
++
++
++
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ LifeCycleConsumerStub,
++ std::tuple<uint32_t, uint32_t>,
++ std::tuple<int32_t>
++ > lifecycleRequestStubDispatcher;
++
++
++
++
++ protected:
++ virtual const char* getMethodsDBusIntrospectionXmlData() const;
++
++ private:
++ LifeCycleConsumerDBusStubAdapterHelper::StubDispatcherTable stubDispatcherTable_;
++ CommonAPI::DBus::StubAttributeTable stubAttributeTable_;
++};
++
++class LifeCycleConsumerDBusStubAdapter: public LifeCycleConsumerDBusStubAdapterInternal, public std::enable_shared_from_this<LifeCycleConsumerDBusStubAdapter> {
++public:
++ LifeCycleConsumerDBusStubAdapter(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& dbusInterfaceName,
++ const std::string& dbusBusName,
++ const std::string& dbusObjectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection,
++ const std::shared_ptr<CommonAPI::StubBase>& stub) :
++ CommonAPI::DBus::DBusStubAdapter(
++ factory,
++ commonApiAddress,
++ dbusInterfaceName,
++ dbusBusName,
++ dbusObjectPath,
++ dbusConnection,
++ false),
++ LifeCycleConsumerDBusStubAdapterInternal(
++ factory,
++ commonApiAddress,
++ dbusInterfaceName,
++ dbusBusName,
++ dbusObjectPath,
++ dbusConnection,
++ stub) { }
++};
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
++
++#endif // ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_DBUS_STUB_ADAPTER_H_
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerProxy.h b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerProxy.h
+new file mode 100644
+index 0000000..710e1d8
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerProxy.h
+@@ -0,0 +1,185 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_PROXY_H_
++#define ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_PROXY_H_
++
++#include "LifeCycleConsumerProxyBase.h"
++
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++template <typename ... _AttributeExtensions>
++class LifeCycleConsumerProxy: virtual public LifeCycleConsumer, virtual public LifeCycleConsumerProxyBase
++, public _AttributeExtensions... {
++public:
++ LifeCycleConsumerProxy(std::shared_ptr<CommonAPI::Proxy> delegate);
++ ~LifeCycleConsumerProxy();
++
++ typedef LifeCycleConsumer InterfaceType;
++
++
++
++
++ /**
++ * Calls LifecycleRequest with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void LifecycleRequest(const uint32_t& Request, const uint32_t& RequestId, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode);
++ /**
++ * Calls LifecycleRequest with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> LifecycleRequestAsync(const uint32_t& Request, const uint32_t& RequestId, LifecycleRequestAsyncCallback callback);
++
++
++ /**
++ * Returns the CommonAPI address of the remote partner this proxy communicates with.
++ */
++ virtual std::string getAddress() const;
++
++ /**
++ * Returns the domain of the remote partner this proxy communicates with.
++ */
++ virtual const std::string& getDomain() const;
++
++ /**
++ * Returns the service ID of the remote partner this proxy communicates with.
++ */
++ virtual const std::string& getServiceId() const;
++
++ /**
++ * Returns the instance ID of the remote partner this proxy communicates with.
++ */
++ virtual const std::string& getInstanceId() const;
++
++ /**
++ * Returns true if the remote partner for this proxy is currently known to be available.
++ */
++ virtual bool isAvailable() const;
++
++ /**
++ * Returns true if the remote partner for this proxy is available.
++ */
++ virtual bool isAvailableBlocking() const;
++
++ /**
++ * Returns the wrapper class that is used to (de-)register for notifications about
++ * the availability of the remote partner of this proxy.
++ */
++ virtual CommonAPI::ProxyStatusEvent& getProxyStatusEvent();
++
++ /**
++ * Returns the wrapper class that is used to access version information of the remote
++ * partner of this proxy.
++ */
++ virtual CommonAPI::InterfaceVersionAttribute& getInterfaceVersionAttribute();
++
++ private:
++ std::shared_ptr<LifeCycleConsumerProxyBase> delegate_;
++};
++
++#ifdef WIN32
++ typedef LifeCycleConsumerProxy<CommonAPI::WINDummyAttributeExtension<CommonAPI::WINDummyAttribute>> LifeCycleConsumerProxyDefault;
++#else
++ typedef LifeCycleConsumerProxy<> LifeCycleConsumerProxyDefault;
++#endif
++
++
++//
++// LifeCycleConsumerProxy Implementation
++//
++template <typename ... _AttributeExtensions>
++LifeCycleConsumerProxy<_AttributeExtensions...>::LifeCycleConsumerProxy(std::shared_ptr<CommonAPI::Proxy> delegate):
++ _AttributeExtensions(*(std::dynamic_pointer_cast<LifeCycleConsumerProxyBase>(delegate)))...,
++ delegate_(std::dynamic_pointer_cast<LifeCycleConsumerProxyBase>(delegate)) {
++}
++
++template <typename ... _AttributeExtensions>
++LifeCycleConsumerProxy<_AttributeExtensions...>::~LifeCycleConsumerProxy() {
++}
++
++template <typename ... _AttributeExtensions>
++void LifeCycleConsumerProxy<_AttributeExtensions...>::LifecycleRequest(const uint32_t& Request, const uint32_t& RequestId, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) {
++ delegate_->LifecycleRequest(Request, RequestId, callStatus, ErrorCode);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> LifeCycleConsumerProxy<_AttributeExtensions...>::LifecycleRequestAsync(const uint32_t& Request, const uint32_t& RequestId, LifecycleRequestAsyncCallback callback) {
++ return delegate_->LifecycleRequestAsync(Request, RequestId, callback);
++}
++
++template <typename ... _AttributeExtensions>
++std::string LifeCycleConsumerProxy<_AttributeExtensions...>::getAddress() const {
++ return delegate_->getAddress();
++}
++
++template <typename ... _AttributeExtensions>
++const std::string& LifeCycleConsumerProxy<_AttributeExtensions...>::getDomain() const {
++ return delegate_->getDomain();
++}
++
++template <typename ... _AttributeExtensions>
++const std::string& LifeCycleConsumerProxy<_AttributeExtensions...>::getServiceId() const {
++ return delegate_->getServiceId();
++}
++
++template <typename ... _AttributeExtensions>
++const std::string& LifeCycleConsumerProxy<_AttributeExtensions...>::getInstanceId() const {
++ return delegate_->getInstanceId();
++}
++
++template <typename ... _AttributeExtensions>
++bool LifeCycleConsumerProxy<_AttributeExtensions...>::isAvailable() const {
++ return delegate_->isAvailable();
++}
++
++template <typename ... _AttributeExtensions>
++bool LifeCycleConsumerProxy<_AttributeExtensions...>::isAvailableBlocking() const {
++ return delegate_->isAvailableBlocking();
++}
++
++template <typename ... _AttributeExtensions>
++CommonAPI::ProxyStatusEvent& LifeCycleConsumerProxy<_AttributeExtensions...>::getProxyStatusEvent() {
++ return delegate_->getProxyStatusEvent();
++}
++
++template <typename ... _AttributeExtensions>
++CommonAPI::InterfaceVersionAttribute& LifeCycleConsumerProxy<_AttributeExtensions...>::getInterfaceVersionAttribute() {
++ return delegate_->getInterfaceVersionAttribute();
++}
++
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
++
++
++#endif // ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_PROXY_H_
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerProxyBase.h b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerProxyBase.h
+new file mode 100644
+index 0000000..c6b3c4b
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerProxyBase.h
+@@ -0,0 +1,49 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_PROXY_BASE_H_
++#define ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_PROXY_BASE_H_
++
++#include "LifeCycleConsumer.h"
++
++
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <vector>
++
++#include <CommonAPI/Proxy.h>
++#include <functional>
++#include <future>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++class LifeCycleConsumerProxyBase: virtual public CommonAPI::Proxy {
++ public:
++
++ typedef std::function<void(const CommonAPI::CallStatus&, const int32_t&)> LifecycleRequestAsyncCallback;
++
++
++
++ virtual void LifecycleRequest(const uint32_t& Request, const uint32_t& RequestId, CommonAPI::CallStatus& callStatus, int32_t& ErrorCode) = 0;
++ virtual std::future<CommonAPI::CallStatus> LifecycleRequestAsync(const uint32_t& Request, const uint32_t& RequestId, LifecycleRequestAsyncCallback callback) = 0;
++};
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
++
++#endif // ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_PROXY_BASE_H_
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerStub.h b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerStub.h
+new file mode 100644
+index 0000000..b7c8de6
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerStub.h
+@@ -0,0 +1,98 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_STUB_H_
++#define ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_STUB_H_
++
++
++
++
++#include "LifeCycleConsumer.h"
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <vector>
++
++#include <CommonAPI/Stub.h>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++/**
++ * Receives messages from remote and handles all dispatching of deserialized calls
++ * to a stub for the service LifeCycleConsumer. Also provides means to send broadcasts
++ * and attribute-changed-notifications of observable attributes as defined by this service.
++ * An application developer should not need to bother with this class.
++ */
++class LifeCycleConsumerStubAdapter: virtual public CommonAPI::StubAdapter, public LifeCycleConsumer {
++ public:
++
++
++
++ virtual void deactivateManagedInstances() = 0;
++protected:
++ /**
++ * Defines properties for storing the ClientIds of clients / proxies that have
++ * subscribed to the selective broadcasts
++ */
++};
++
++
++/**
++ * Defines the necessary callbacks to handle remote set events related to the attributes
++ * defined in the IDL description for LifeCycleConsumer.
++ * For each attribute two callbacks are defined:
++ * - a verification callback that allows to verify the requested value and to prevent setting
++ * e.g. an invalid value ("onRemoteSet<AttributeName>").
++ * - an action callback to do local work after the attribute value has been changed
++ * ("onRemote<AttributeName>Changed").
++ *
++ * This class and the one below are the ones an application developer needs to have
++ * a look at if he wants to implement a service.
++ */
++class LifeCycleConsumerStubRemoteEvent {
++ public:
++ virtual ~LifeCycleConsumerStubRemoteEvent() { }
++
++};
++
++
++/**
++ * Defines the interface that must be implemented by any class that should provide
++ * the service LifeCycleConsumer to remote clients.
++ * This class and the one above are the ones an application developer needs to have
++ * a look at if he wants to implement a service.
++ */
++class LifeCycleConsumerStub: public virtual CommonAPI::Stub<LifeCycleConsumerStubAdapter, LifeCycleConsumerStubRemoteEvent> {
++public:
++ virtual ~LifeCycleConsumerStub() { }
++ virtual const CommonAPI::Version& getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
++
++
++ /// This is the method that will be called on remote calls on the method LifecycleRequest.
++ virtual void LifecycleRequest(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t Request, uint32_t RequestId, int32_t& ErrorCode) = 0;
++
++ using CommonAPI::Stub<LifeCycleConsumerStubAdapter, LifeCycleConsumerStubRemoteEvent>::initStubAdapter;
++ typedef CommonAPI::Stub<LifeCycleConsumerStubAdapter, LifeCycleConsumerStubRemoteEvent>::StubAdapterType StubAdapterType;
++ typedef CommonAPI::Stub<LifeCycleConsumerStubAdapter, LifeCycleConsumerStubRemoteEvent>::RemoteEventHandlerType RemoteEventHandlerType;
++ typedef LifeCycleConsumerStubRemoteEvent RemoteEventType;
++ typedef LifeCycleConsumer StubInterface;
++};
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
++
++#endif // ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_STUB_H_
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerStubDefault.cpp b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerStubDefault.cpp
+new file mode 100644
+index 0000000..aa86851
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerStubDefault.cpp
+@@ -0,0 +1,46 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++#include <org/genivi/NodeStateManager/LifeCycleConsumerStubDefault.h>
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++LifeCycleConsumerStubDefault::LifeCycleConsumerStubDefault():
++ remoteEventHandler_(this),
++ interfaceVersion_(LifeCycleConsumer::getInterfaceVersion()) {
++}
++
++const CommonAPI::Version& LifeCycleConsumerStubDefault::getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> clientId) {
++ return interfaceVersion_;
++}
++
++LifeCycleConsumerStubRemoteEvent* LifeCycleConsumerStubDefault::initStubAdapter(const std::shared_ptr<LifeCycleConsumerStubAdapter>& stubAdapter) {
++ CommonAPI::Stub<LifeCycleConsumerStubAdapter, LifeCycleConsumerStubRemoteEvent>::stubAdapter_ = stubAdapter;
++ return &remoteEventHandler_;
++}
++
++
++void LifeCycleConsumerStubDefault::LifecycleRequest(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t Request, uint32_t RequestId, int32_t& ErrorCode) {
++ // Call old style methods in default
++ LifecycleRequest(Request, RequestId, ErrorCode);
++}
++void LifeCycleConsumerStubDefault::LifecycleRequest(uint32_t Request, uint32_t RequestId, int32_t& ErrorCode) {
++ // No operation in default
++}
++
++
++
++
++LifeCycleConsumerStubDefault::RemoteEventHandler::RemoteEventHandler(LifeCycleConsumerStubDefault* defaultStub):
++ defaultStub_(defaultStub) {
++}
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
+diff --git a/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerStubDefault.h b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerStubDefault.h
+new file mode 100644
+index 0000000..a474249
+--- /dev/null
++++ b/AudioManagerDaemon/src-gen/org/genivi/NodeStateManager/LifeCycleConsumerStubDefault.h
+@@ -0,0 +1,67 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_STUB_DEFAULT_H_
++#define ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_STUB_DEFAULT_H_
++
++
++#include <org/genivi/NodeStateManager/LifeCycleConsumerStub.h>
++#include <sstream>
++
++namespace org {
++namespace genivi {
++namespace NodeStateManager {
++
++/**
++ * Provides a default implementation for LifeCycleConsumerStubRemoteEvent and
++ * LifeCycleConsumerStub. Method callbacks have an empty implementation,
++ * remote set calls on attributes will always change the value of the attribute
++ * to the one received.
++ *
++ * Override this stub if you only want to provide a subset of the functionality
++ * that would be defined for this service, and/or if you do not need any non-default
++ * behaviour.
++ */
++class LifeCycleConsumerStubDefault : public virtual LifeCycleConsumerStub {
++public:
++ LifeCycleConsumerStubDefault();
++
++ LifeCycleConsumerStubRemoteEvent* initStubAdapter(const std::shared_ptr<LifeCycleConsumerStubAdapter>& stubAdapter);
++
++ const CommonAPI::Version& getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> clientId);
++
++
++ virtual void LifecycleRequest(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t Request, uint32_t RequestId, int32_t& ErrorCode);
++ virtual void LifecycleRequest(uint32_t Request, uint32_t RequestId, int32_t& ErrorCode);
++
++
++
++
++protected:
++ class RemoteEventHandler: public virtual LifeCycleConsumerStubRemoteEvent {
++ public:
++ RemoteEventHandler(LifeCycleConsumerStubDefault* defaultStub);
++
++
++ private:
++ LifeCycleConsumerStubDefault* defaultStub_;
++ };
++private:
++ LifeCycleConsumerStubDefault::RemoteEventHandler remoteEventHandler_;
++
++
++ CommonAPI::Version interfaceVersion_;
++};
++
++} // namespace NodeStateManager
++} // namespace genivi
++} // namespace org
++
++#endif // ORG_GENIVI_NODESTATEMANAGER_Life_Cycle_Consumer_STUB_DEFAULT_H_
+diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am.cpp b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am.cpp
+new file mode 100644
+index 0000000..8092420
+--- /dev/null
++++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am.cpp
+@@ -0,0 +1,1043 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#include "am.h"
++
++
++namespace org {
++namespace genivi {
++namespace am {
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++am_Route_s::am_Route_s(const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_RoutingElement_L& routeValue):
++ sourceID(sourceIDValue),
++ sinkID(sinkIDValue),
++ route(routeValue)
++{
++}
++
++
++bool operator==(const am_Route_s& lhs, const am_Route_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sourceID == rhs.sourceID &&
++ lhs.sinkID == rhs.sinkID &&
++ lhs.route == rhs.route
++ ;
++}
++
++void am_Route_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sourceID;
++ inputStream >> sinkID;
++ inputStream >> route;
++}
++
++void am_Route_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sourceID;
++ outputStream << sinkID;
++ outputStream << route;
++}
++
++am_Availability_s::am_Availability_s(const am_Availability_e& availabilityValue, const am_CustomAvailabilityReason_t& availabilityReasonValue):
++ availability(availabilityValue),
++ availabilityReason(availabilityReasonValue)
++{
++}
++
++
++bool operator==(const am_Availability_s& lhs, const am_Availability_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.availability == rhs.availability &&
++ lhs.availabilityReason == rhs.availabilityReason
++ ;
++}
++
++void am_Availability_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> availability;
++ inputStream >> availabilityReason;
++}
++
++void am_Availability_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << availability;
++ outputStream << availabilityReason;
++}
++
++am_ClassProperty_s::am_ClassProperty_s(const am_CustomClassProperty_t& classPropertyValue, const int16_t& valueValue):
++ classProperty(classPropertyValue),
++ value(valueValue)
++{
++}
++
++
++bool operator==(const am_ClassProperty_s& lhs, const am_ClassProperty_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.classProperty == rhs.classProperty &&
++ lhs.value == rhs.value
++ ;
++}
++
++void am_ClassProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> classProperty;
++ inputStream >> value;
++}
++
++void am_ClassProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << classProperty;
++ outputStream << value;
++}
++
++am_Crossfader_s::am_Crossfader_s(const am_crossfaderID_t& crossfaderIDValue, const std::string& nameValue, const am_sinkID_t& sinkID_AValue, const am_sinkID_t& sinkID_BValue, const am_sourceID_t& sourceIDValue, const am_HotSink_e& hotSinkValue):
++ crossfaderID(crossfaderIDValue),
++ name(nameValue),
++ sinkID_A(sinkID_AValue),
++ sinkID_B(sinkID_BValue),
++ sourceID(sourceIDValue),
++ hotSink(hotSinkValue)
++{
++}
++
++
++bool operator==(const am_Crossfader_s& lhs, const am_Crossfader_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.crossfaderID == rhs.crossfaderID &&
++ lhs.name == rhs.name &&
++ lhs.sinkID_A == rhs.sinkID_A &&
++ lhs.sinkID_B == rhs.sinkID_B &&
++ lhs.sourceID == rhs.sourceID &&
++ lhs.hotSink == rhs.hotSink
++ ;
++}
++
++void am_Crossfader_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> crossfaderID;
++ inputStream >> name;
++ inputStream >> sinkID_A;
++ inputStream >> sinkID_B;
++ inputStream >> sourceID;
++ inputStream >> hotSink;
++}
++
++void am_Crossfader_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << crossfaderID;
++ outputStream << name;
++ outputStream << sinkID_A;
++ outputStream << sinkID_B;
++ outputStream << sourceID;
++ outputStream << hotSink;
++}
++
++am_Gateway_s::am_Gateway_s(const am_gatewayID_t& gatewayIDValue, const std::string& nameValue, const am_sinkID_t& sinkIDValue, const am_sourceID_t& sourceIDValue, const am_domainID_t& domainSinkIDValue, const am_domainID_t& domainSourceIDValue, const am_domainID_t& controlDomainIDValue, const am_ConnectionFormat_L& listSourceFormatsValue, const am_ConnectionFormat_L& listSinkFormatsValue, const am_Convertion_L& convertionMatrixValue):
++ gatewayID(gatewayIDValue),
++ name(nameValue),
++ sinkID(sinkIDValue),
++ sourceID(sourceIDValue),
++ domainSinkID(domainSinkIDValue),
++ domainSourceID(domainSourceIDValue),
++ controlDomainID(controlDomainIDValue),
++ listSourceFormats(listSourceFormatsValue),
++ listSinkFormats(listSinkFormatsValue),
++ convertionMatrix(convertionMatrixValue)
++{
++}
++
++
++bool operator==(const am_Gateway_s& lhs, const am_Gateway_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.gatewayID == rhs.gatewayID &&
++ lhs.name == rhs.name &&
++ lhs.sinkID == rhs.sinkID &&
++ lhs.sourceID == rhs.sourceID &&
++ lhs.domainSinkID == rhs.domainSinkID &&
++ lhs.domainSourceID == rhs.domainSourceID &&
++ lhs.controlDomainID == rhs.controlDomainID &&
++ lhs.listSourceFormats == rhs.listSourceFormats &&
++ lhs.listSinkFormats == rhs.listSinkFormats &&
++ lhs.convertionMatrix == rhs.convertionMatrix
++ ;
++}
++
++void am_Gateway_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> gatewayID;
++ inputStream >> name;
++ inputStream >> sinkID;
++ inputStream >> sourceID;
++ inputStream >> domainSinkID;
++ inputStream >> domainSourceID;
++ inputStream >> controlDomainID;
++ inputStream >> listSourceFormats;
++ inputStream >> listSinkFormats;
++ inputStream >> convertionMatrix;
++}
++
++void am_Gateway_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << gatewayID;
++ outputStream << name;
++ outputStream << sinkID;
++ outputStream << sourceID;
++ outputStream << domainSinkID;
++ outputStream << domainSourceID;
++ outputStream << controlDomainID;
++ outputStream << listSourceFormats;
++ outputStream << listSinkFormats;
++ outputStream << convertionMatrix;
++}
++
++am_Converter_s::am_Converter_s(const am_converterID_t& converterIDValue, const std::string& nameValue, const am_sinkID_t& sinkIDValue, const am_sourceID_t& sourceIDValue, const am_domainID_t& domainIDValue, const am_ConnectionFormat_L& listSourceFormatsValue, const am_ConnectionFormat_L& listSinkFormatsValue, const am_Convertion_L& convertionMatrixValue):
++ converterID(converterIDValue),
++ name(nameValue),
++ sinkID(sinkIDValue),
++ sourceID(sourceIDValue),
++ domainID(domainIDValue),
++ listSourceFormats(listSourceFormatsValue),
++ listSinkFormats(listSinkFormatsValue),
++ convertionMatrix(convertionMatrixValue)
++{
++}
++
++
++bool operator==(const am_Converter_s& lhs, const am_Converter_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.converterID == rhs.converterID &&
++ lhs.name == rhs.name &&
++ lhs.sinkID == rhs.sinkID &&
++ lhs.sourceID == rhs.sourceID &&
++ lhs.domainID == rhs.domainID &&
++ lhs.listSourceFormats == rhs.listSourceFormats &&
++ lhs.listSinkFormats == rhs.listSinkFormats &&
++ lhs.convertionMatrix == rhs.convertionMatrix
++ ;
++}
++
++void am_Converter_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> converterID;
++ inputStream >> name;
++ inputStream >> sinkID;
++ inputStream >> sourceID;
++ inputStream >> domainID;
++ inputStream >> listSourceFormats;
++ inputStream >> listSinkFormats;
++ inputStream >> convertionMatrix;
++}
++
++void am_Converter_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << converterID;
++ outputStream << name;
++ outputStream << sinkID;
++ outputStream << sourceID;
++ outputStream << domainID;
++ outputStream << listSourceFormats;
++ outputStream << listSinkFormats;
++ outputStream << convertionMatrix;
++}
++
++am_RoutingElement_s::am_RoutingElement_s(const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_domainID_t& domainIDValue, const am_CustomConnectionFormat_t& connectionFormatValue):
++ sourceID(sourceIDValue),
++ sinkID(sinkIDValue),
++ domainID(domainIDValue),
++ connectionFormat(connectionFormatValue)
++{
++}
++
++
++bool operator==(const am_RoutingElement_s& lhs, const am_RoutingElement_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sourceID == rhs.sourceID &&
++ lhs.sinkID == rhs.sinkID &&
++ lhs.domainID == rhs.domainID &&
++ lhs.connectionFormat == rhs.connectionFormat
++ ;
++}
++
++void am_RoutingElement_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sourceID;
++ inputStream >> sinkID;
++ inputStream >> domainID;
++ inputStream >> connectionFormat;
++}
++
++void am_RoutingElement_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sourceID;
++ outputStream << sinkID;
++ outputStream << domainID;
++ outputStream << connectionFormat;
++}
++
++am_SoundProperty_s::am_SoundProperty_s(const am_CustomSoundPropertyType_t& typeValue, const int16_t& valueValue):
++ type(typeValue),
++ value(valueValue)
++{
++}
++
++
++bool operator==(const am_SoundProperty_s& lhs, const am_SoundProperty_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.type == rhs.type &&
++ lhs.value == rhs.value
++ ;
++}
++
++void am_SoundProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> type;
++ inputStream >> value;
++}
++
++void am_SoundProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << type;
++ outputStream << value;
++}
++
++am_SystemProperty_s::am_SystemProperty_s(const am_CustomSystemPropertyType_t& typeValue, const int16_t& valueValue):
++ type(typeValue),
++ value(valueValue)
++{
++}
++
++
++bool operator==(const am_SystemProperty_s& lhs, const am_SystemProperty_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.type == rhs.type &&
++ lhs.value == rhs.value
++ ;
++}
++
++void am_SystemProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> type;
++ inputStream >> value;
++}
++
++void am_SystemProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << type;
++ outputStream << value;
++}
++
++am_SinkClass_s::am_SinkClass_s(const am_sinkClass_t& sinkClassIDValue, const std::string& nameValue, const am_ClassProperty_L& listClassPropertiesValue):
++ sinkClassID(sinkClassIDValue),
++ name(nameValue),
++ listClassProperties(listClassPropertiesValue)
++{
++}
++
++
++bool operator==(const am_SinkClass_s& lhs, const am_SinkClass_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sinkClassID == rhs.sinkClassID &&
++ lhs.name == rhs.name &&
++ lhs.listClassProperties == rhs.listClassProperties
++ ;
++}
++
++void am_SinkClass_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sinkClassID;
++ inputStream >> name;
++ inputStream >> listClassProperties;
++}
++
++void am_SinkClass_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sinkClassID;
++ outputStream << name;
++ outputStream << listClassProperties;
++}
++
++am_SourceClass_s::am_SourceClass_s(const am_sourceClass_t& sourceClassIDValue, const std::string& nameValue, const am_ClassProperty_L& listClassPropertiesValue):
++ sourceClassID(sourceClassIDValue),
++ name(nameValue),
++ listClassProperties(listClassPropertiesValue)
++{
++}
++
++
++bool operator==(const am_SourceClass_s& lhs, const am_SourceClass_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sourceClassID == rhs.sourceClassID &&
++ lhs.name == rhs.name &&
++ lhs.listClassProperties == rhs.listClassProperties
++ ;
++}
++
++void am_SourceClass_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sourceClassID;
++ inputStream >> name;
++ inputStream >> listClassProperties;
++}
++
++void am_SourceClass_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sourceClassID;
++ outputStream << name;
++ outputStream << listClassProperties;
++}
++
++am_SourceType_s::am_SourceType_s(const am_sourceID_t& sourceIDValue, const std::string& nameValue, const am_Availability_s& availabilityValue, const am_sourceClass_t& sourceClassIDValue):
++ sourceID(sourceIDValue),
++ name(nameValue),
++ availability(availabilityValue),
++ sourceClassID(sourceClassIDValue)
++{
++}
++
++
++bool operator==(const am_SourceType_s& lhs, const am_SourceType_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sourceID == rhs.sourceID &&
++ lhs.name == rhs.name &&
++ lhs.availability == rhs.availability &&
++ lhs.sourceClassID == rhs.sourceClassID
++ ;
++}
++
++void am_SourceType_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sourceID;
++ inputStream >> name;
++ inputStream >> availability;
++ inputStream >> sourceClassID;
++}
++
++void am_SourceType_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sourceID;
++ outputStream << name;
++ outputStream << availability;
++ outputStream << sourceClassID;
++}
++
++am_SinkType_s::am_SinkType_s(const am_sinkID_t& sinkIDValue, const std::string& nameValue, const am_Availability_s& availabilityValue, const am_mainVolume_t& volumeValue, const am_MuteState_e& muteStateValue, const am_sinkClass_t& sinkClassIDValue):
++ sinkID(sinkIDValue),
++ name(nameValue),
++ availability(availabilityValue),
++ volume(volumeValue),
++ muteState(muteStateValue),
++ sinkClassID(sinkClassIDValue)
++{
++}
++
++
++bool operator==(const am_SinkType_s& lhs, const am_SinkType_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sinkID == rhs.sinkID &&
++ lhs.name == rhs.name &&
++ lhs.availability == rhs.availability &&
++ lhs.volume == rhs.volume &&
++ lhs.muteState == rhs.muteState &&
++ lhs.sinkClassID == rhs.sinkClassID
++ ;
++}
++
++void am_SinkType_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sinkID;
++ inputStream >> name;
++ inputStream >> availability;
++ inputStream >> volume;
++ inputStream >> muteState;
++ inputStream >> sinkClassID;
++}
++
++void am_SinkType_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sinkID;
++ outputStream << name;
++ outputStream << availability;
++ outputStream << volume;
++ outputStream << muteState;
++ outputStream << sinkClassID;
++}
++
++am_Handle_s::am_Handle_s(const am_Handle_e& handleTypeValue, const uint16_t& handleValue):
++ handleType(handleTypeValue),
++ handle(handleValue)
++{
++}
++
++
++bool operator==(const am_Handle_s& lhs, const am_Handle_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.handleType == rhs.handleType &&
++ lhs.handle == rhs.handle
++ ;
++}
++
++void am_Handle_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> handleType;
++ inputStream >> handle;
++}
++
++void am_Handle_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << handleType;
++ outputStream << handle;
++}
++
++am_MainSoundProperty_s::am_MainSoundProperty_s(const am_CustomMainSoundPropertyType_t& typeValue, const int16_t& valueValue):
++ type(typeValue),
++ value(valueValue)
++{
++}
++
++
++bool operator==(const am_MainSoundProperty_s& lhs, const am_MainSoundProperty_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.type == rhs.type &&
++ lhs.value == rhs.value
++ ;
++}
++
++void am_MainSoundProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> type;
++ inputStream >> value;
++}
++
++void am_MainSoundProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << type;
++ outputStream << value;
++}
++
++am_MainConnectionType_s::am_MainConnectionType_s(const am_mainConnectionID_t& mainConnectionIDValue, const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_timeSync_t& delayValue, const am_ConnectionState_e& connectionStateValue):
++ mainConnectionID(mainConnectionIDValue),
++ sourceID(sourceIDValue),
++ sinkID(sinkIDValue),
++ delay(delayValue),
++ connectionState(connectionStateValue)
++{
++}
++
++
++bool operator==(const am_MainConnectionType_s& lhs, const am_MainConnectionType_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.mainConnectionID == rhs.mainConnectionID &&
++ lhs.sourceID == rhs.sourceID &&
++ lhs.sinkID == rhs.sinkID &&
++ lhs.delay == rhs.delay &&
++ lhs.connectionState == rhs.connectionState
++ ;
++}
++
++void am_MainConnectionType_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> mainConnectionID;
++ inputStream >> sourceID;
++ inputStream >> sinkID;
++ inputStream >> delay;
++ inputStream >> connectionState;
++}
++
++void am_MainConnectionType_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << mainConnectionID;
++ outputStream << sourceID;
++ outputStream << sinkID;
++ outputStream << delay;
++ outputStream << connectionState;
++}
++
++am_MainConnection_s::am_MainConnection_s(const am_mainConnectionID_t& mainConnectionIDValue, const am_ConnectionState_e& connectionStateValue, const am_sinkID_t& sinkIDValue, const am_sourceID_t& sourceIDValue, const am_timeSync_t& delayValue, const am_ConnectionID_L& listConnectionIDValue):
++ mainConnectionID(mainConnectionIDValue),
++ connectionState(connectionStateValue),
++ sinkID(sinkIDValue),
++ sourceID(sourceIDValue),
++ delay(delayValue),
++ listConnectionID(listConnectionIDValue)
++{
++}
++
++
++bool operator==(const am_MainConnection_s& lhs, const am_MainConnection_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.mainConnectionID == rhs.mainConnectionID &&
++ lhs.connectionState == rhs.connectionState &&
++ lhs.sinkID == rhs.sinkID &&
++ lhs.sourceID == rhs.sourceID &&
++ lhs.delay == rhs.delay &&
++ lhs.listConnectionID == rhs.listConnectionID
++ ;
++}
++
++void am_MainConnection_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> mainConnectionID;
++ inputStream >> connectionState;
++ inputStream >> sinkID;
++ inputStream >> sourceID;
++ inputStream >> delay;
++ inputStream >> listConnectionID;
++}
++
++void am_MainConnection_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << mainConnectionID;
++ outputStream << connectionState;
++ outputStream << sinkID;
++ outputStream << sourceID;
++ outputStream << delay;
++ outputStream << listConnectionID;
++}
++
++am_NotificationPayload_s::am_NotificationPayload_s(const am_CustomNotificationType_t& typeValue, const int16_t& valueValue):
++ type(typeValue),
++ value(valueValue)
++{
++}
++
++
++bool operator==(const am_NotificationPayload_s& lhs, const am_NotificationPayload_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.type == rhs.type &&
++ lhs.value == rhs.value
++ ;
++}
++
++void am_NotificationPayload_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> type;
++ inputStream >> value;
++}
++
++void am_NotificationPayload_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << type;
++ outputStream << value;
++}
++
++am_NotificationConfiguration_s::am_NotificationConfiguration_s(const am_CustomNotificationType_t& typeValue, const am_NotificationStatus_e& statusValue, const int16_t& parameterValue):
++ type(typeValue),
++ status(statusValue),
++ parameter(parameterValue)
++{
++}
++
++
++bool operator==(const am_NotificationConfiguration_s& lhs, const am_NotificationConfiguration_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.type == rhs.type &&
++ lhs.status == rhs.status &&
++ lhs.parameter == rhs.parameter
++ ;
++}
++
++void am_NotificationConfiguration_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> type;
++ inputStream >> status;
++ inputStream >> parameter;
++}
++
++void am_NotificationConfiguration_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << type;
++ outputStream << status;
++ outputStream << parameter;
++}
++
++am_Sink_s::am_Sink_s(const am_sinkID_t& sinkIDValue, const std::string& nameValue, const am_domainID_t& domainIDValue, const am_sinkClass_t& sinkClassIDValue, const am_volume_t& volumeValue, const bool& visibleValue, const am_Availability_s& availableValue, const am_MuteState_e& muteStateValue, const am_mainVolume_t& mainVolumeValue, const am_SoundProperty_L& listSoundPropertiesValue, const am_ConnectionFormat_L& listConnectionFormatsValue, const am_MainSoundProperty_L& listMainSoundPropertiesValue, const am_NotificationConfiguration_L& listMainNotificationConfigurationsValue, const am_NotificationConfiguration_L& listNotificationConfigurationsValue):
++ sinkID(sinkIDValue),
++ name(nameValue),
++ domainID(domainIDValue),
++ sinkClassID(sinkClassIDValue),
++ volume(volumeValue),
++ visible(visibleValue),
++ available(availableValue),
++ muteState(muteStateValue),
++ mainVolume(mainVolumeValue),
++ listSoundProperties(listSoundPropertiesValue),
++ listConnectionFormats(listConnectionFormatsValue),
++ listMainSoundProperties(listMainSoundPropertiesValue),
++ listMainNotificationConfigurations(listMainNotificationConfigurationsValue),
++ listNotificationConfigurations(listNotificationConfigurationsValue)
++{
++}
++
++
++bool operator==(const am_Sink_s& lhs, const am_Sink_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sinkID == rhs.sinkID &&
++ lhs.name == rhs.name &&
++ lhs.domainID == rhs.domainID &&
++ lhs.sinkClassID == rhs.sinkClassID &&
++ lhs.volume == rhs.volume &&
++ lhs.visible == rhs.visible &&
++ lhs.available == rhs.available &&
++ lhs.muteState == rhs.muteState &&
++ lhs.mainVolume == rhs.mainVolume &&
++ lhs.listSoundProperties == rhs.listSoundProperties &&
++ lhs.listConnectionFormats == rhs.listConnectionFormats &&
++ lhs.listMainSoundProperties == rhs.listMainSoundProperties &&
++ lhs.listMainNotificationConfigurations == rhs.listMainNotificationConfigurations &&
++ lhs.listNotificationConfigurations == rhs.listNotificationConfigurations
++ ;
++}
++
++void am_Sink_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sinkID;
++ inputStream >> name;
++ inputStream >> domainID;
++ inputStream >> sinkClassID;
++ inputStream >> volume;
++ inputStream >> visible;
++ inputStream >> available;
++ inputStream >> muteState;
++ inputStream >> mainVolume;
++ inputStream >> listSoundProperties;
++ inputStream >> listConnectionFormats;
++ inputStream >> listMainSoundProperties;
++ inputStream >> listMainNotificationConfigurations;
++ inputStream >> listNotificationConfigurations;
++}
++
++void am_Sink_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sinkID;
++ outputStream << name;
++ outputStream << domainID;
++ outputStream << sinkClassID;
++ outputStream << volume;
++ outputStream << visible;
++ outputStream << available;
++ outputStream << muteState;
++ outputStream << mainVolume;
++ outputStream << listSoundProperties;
++ outputStream << listConnectionFormats;
++ outputStream << listMainSoundProperties;
++ outputStream << listMainNotificationConfigurations;
++ outputStream << listNotificationConfigurations;
++}
++
++am_Source_s::am_Source_s(const am_sourceID_t& sourceIDValue, const am_domainID_t& domainIDValue, const std::string& nameValue, const am_sourceClass_t& sourceClassIDValue, const am_SourceState_e& sourceStateValue, const am_volume_t& volumeValue, const bool& visibleValue, const am_Availability_s& availableValue, const am_InterruptState_e& interruptStateValue, const am_SoundProperty_L& listSoundPropertiesValue, const am_ConnectionFormat_L& listConnectionFormatsValue, const am_MainSoundProperty_L& listMainSoundPropertiesValue, const am_NotificationConfiguration_L& listMainNotificationConfigurationsValue, const am_NotificationConfiguration_L& listNotificationConfigurationsValue):
++ sourceID(sourceIDValue),
++ domainID(domainIDValue),
++ name(nameValue),
++ sourceClassID(sourceClassIDValue),
++ sourceState(sourceStateValue),
++ volume(volumeValue),
++ visible(visibleValue),
++ available(availableValue),
++ interruptState(interruptStateValue),
++ listSoundProperties(listSoundPropertiesValue),
++ listConnectionFormats(listConnectionFormatsValue),
++ listMainSoundProperties(listMainSoundPropertiesValue),
++ listMainNotificationConfigurations(listMainNotificationConfigurationsValue),
++ listNotificationConfigurations(listNotificationConfigurationsValue)
++{
++}
++
++
++bool operator==(const am_Source_s& lhs, const am_Source_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sourceID == rhs.sourceID &&
++ lhs.domainID == rhs.domainID &&
++ lhs.name == rhs.name &&
++ lhs.sourceClassID == rhs.sourceClassID &&
++ lhs.sourceState == rhs.sourceState &&
++ lhs.volume == rhs.volume &&
++ lhs.visible == rhs.visible &&
++ lhs.available == rhs.available &&
++ lhs.interruptState == rhs.interruptState &&
++ lhs.listSoundProperties == rhs.listSoundProperties &&
++ lhs.listConnectionFormats == rhs.listConnectionFormats &&
++ lhs.listMainSoundProperties == rhs.listMainSoundProperties &&
++ lhs.listMainNotificationConfigurations == rhs.listMainNotificationConfigurations &&
++ lhs.listNotificationConfigurations == rhs.listNotificationConfigurations
++ ;
++}
++
++void am_Source_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sourceID;
++ inputStream >> domainID;
++ inputStream >> name;
++ inputStream >> sourceClassID;
++ inputStream >> sourceState;
++ inputStream >> volume;
++ inputStream >> visible;
++ inputStream >> available;
++ inputStream >> interruptState;
++ inputStream >> listSoundProperties;
++ inputStream >> listConnectionFormats;
++ inputStream >> listMainSoundProperties;
++ inputStream >> listMainNotificationConfigurations;
++ inputStream >> listNotificationConfigurations;
++}
++
++void am_Source_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sourceID;
++ outputStream << domainID;
++ outputStream << name;
++ outputStream << sourceClassID;
++ outputStream << sourceState;
++ outputStream << volume;
++ outputStream << visible;
++ outputStream << available;
++ outputStream << interruptState;
++ outputStream << listSoundProperties;
++ outputStream << listConnectionFormats;
++ outputStream << listMainSoundProperties;
++ outputStream << listMainNotificationConfigurations;
++ outputStream << listNotificationConfigurations;
++}
++
++am_Domain_s::am_Domain_s(const am_domainID_t& domainIDValue, const std::string& nameValue, const std::string& busnameValue, const std::string& nodenameValue, const bool& earlyValue, const bool& completeValue, const am_DomainState_e& stateValue):
++ domainID(domainIDValue),
++ name(nameValue),
++ busname(busnameValue),
++ nodename(nodenameValue),
++ early(earlyValue),
++ complete(completeValue),
++ state(stateValue)
++{
++}
++
++
++bool operator==(const am_Domain_s& lhs, const am_Domain_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.domainID == rhs.domainID &&
++ lhs.name == rhs.name &&
++ lhs.busname == rhs.busname &&
++ lhs.nodename == rhs.nodename &&
++ lhs.early == rhs.early &&
++ lhs.complete == rhs.complete &&
++ lhs.state == rhs.state
++ ;
++}
++
++void am_Domain_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> domainID;
++ inputStream >> name;
++ inputStream >> busname;
++ inputStream >> nodename;
++ inputStream >> early;
++ inputStream >> complete;
++ inputStream >> state;
++}
++
++void am_Domain_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << domainID;
++ outputStream << name;
++ outputStream << busname;
++ outputStream << nodename;
++ outputStream << early;
++ outputStream << complete;
++ outputStream << state;
++}
++
++am_EarlyData_s::am_EarlyData_s(const am_EarlyDataType_e& typeValue, const am_DataType_u& sinksourceValue, const am_EarlyData_u& dataValue):
++ type(typeValue),
++ sinksource(sinksourceValue),
++ data(dataValue)
++{
++}
++
++
++bool operator==(const am_EarlyData_s& lhs, const am_EarlyData_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.type == rhs.type &&
++ lhs.sinksource == rhs.sinksource &&
++ lhs.data == rhs.data
++ ;
++}
++
++void am_EarlyData_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> type;
++ inputStream >> sinksource;
++ inputStream >> data;
++}
++
++void am_EarlyData_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << type;
++ outputStream << sinksource;
++ outputStream << data;
++}
++
++am_Connection_s::am_Connection_s(const am_connectionID_t& connectionIDValue, const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_timeSync_t& delayValue, const am_CustomConnectionFormat_t& connectionFormatValue):
++ connectionID(connectionIDValue),
++ sourceID(sourceIDValue),
++ sinkID(sinkIDValue),
++ delay(delayValue),
++ connectionFormat(connectionFormatValue)
++{
++}
++
++
++bool operator==(const am_Connection_s& lhs, const am_Connection_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.connectionID == rhs.connectionID &&
++ lhs.sourceID == rhs.sourceID &&
++ lhs.sinkID == rhs.sinkID &&
++ lhs.delay == rhs.delay &&
++ lhs.connectionFormat == rhs.connectionFormat
++ ;
++}
++
++void am_Connection_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> connectionID;
++ inputStream >> sourceID;
++ inputStream >> sinkID;
++ inputStream >> delay;
++ inputStream >> connectionFormat;
++}
++
++void am_Connection_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << connectionID;
++ outputStream << sourceID;
++ outputStream << sinkID;
++ outputStream << delay;
++ outputStream << connectionFormat;
++}
++
++am_Volumes_s::am_Volumes_s(const am_VolumeType_e& volumeTypeValue, const am_DataType_u& volumeIDValue, const am_volume_t& volumeValue, const am_CustomRampType_t& rampValue, const am_time_t& timeValue):
++ volumeType(volumeTypeValue),
++ volumeID(volumeIDValue),
++ volume(volumeValue),
++ ramp(rampValue),
++ time(timeValue)
++{
++}
++
++
++bool operator==(const am_Volumes_s& lhs, const am_Volumes_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.volumeType == rhs.volumeType &&
++ lhs.volumeID == rhs.volumeID &&
++ lhs.volume == rhs.volume &&
++ lhs.ramp == rhs.ramp &&
++ lhs.time == rhs.time
++ ;
++}
++
++void am_Volumes_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> volumeType;
++ inputStream >> volumeID;
++ inputStream >> volume;
++ inputStream >> ramp;
++ inputStream >> time;
++}
++
++void am_Volumes_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << volumeType;
++ outputStream << volumeID;
++ outputStream << volume;
++ outputStream << ramp;
++ outputStream << time;
++}
++
++
++
++} // namespace am
++} // namespace genivi
++} // namespace org
+diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am.h
+new file mode 100644
+index 0000000..e75db5d
+--- /dev/null
++++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am.h
+@@ -0,0 +1,2551 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_am_H_
++#define ORG_GENIVI_am_H_
++
++
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <CommonAPI/InputStream.h>
++#include <CommonAPI/OutputStream.h>
++#include <CommonAPI/SerializableStruct.h>
++#include <CommonAPI/SerializableVariant.h>
++#include <CommonAPI/types.h>
++#include <cstdint>
++#include <memory>
++#include <string>
++#include <vector>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++
++namespace am {
++ /**
++ * a source ID
++ */
++ /**
++ * a source ID
++ */
++ typedef uint16_t am_sourceID_t;
++ /**
++ * a mainConnection ID
++ */
++ /**
++ * a mainConnection ID
++ */
++ typedef uint16_t am_mainConnectionID_t;
++ /**
++ * offset time that is introduced in milli seconds.
++ */
++ /**
++ * offset time that is introduced in milli seconds.
++ */
++ typedef int16_t am_timeSync_t;
++ /**
++ * a sink ID
++ */
++ /**
++ * a sink ID
++ */
++ typedef uint16_t am_sinkID_t;
++ /**
++ * represents the connection state
++ */
++ enum class am_ConnectionState_e: int32_t {
++ CS_UNKNOWN = 0,
++ /**
++ * This means the connection is just building up
++ */
++ CS_CONNECTING = 1,
++ /**
++ * the connection is ready to be used
++ */
++ CS_CONNECTED = 2,
++ /**
++ * the connection is in the course to be knocked down
++ */
++ CS_DISCONNECTING = 3,
++ /**
++ * only relevant for connectionStatechanged. Is send after the connection was
++ * removed
++ */
++ CS_DISCONNECTED = 4,
++ /**
++ * this means the connection is still build up but unused at the moment
++ */
++ CS_SUSPENDED = 5,
++ CS_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_ConnectionState_eComparator;
++ /**
++ * this type holds all information of connections relevant to the HMI
++ */
++ /**
++ * this type holds all information of connections relevant to the HMI
++ */
++ struct am_MainConnectionType_s: CommonAPI::SerializableStruct {
++ /**
++ * the ID of the mainconnection
++ */
++ am_mainConnectionID_t mainConnectionID;
++ /**
++ * the sourceID where the connection starts
++ */
++ am_sourceID_t sourceID;
++ /**
++ * the sinkID where the connection ends
++ */
++ am_sinkID_t sinkID;
++ /**
++ * the delay of the mainconnection
++ */
++ am_timeSync_t delay;
++ /**
++ * the current connection state
++ */
++ am_ConnectionState_e connectionState;
++
++ am_MainConnectionType_s() = default;
++ am_MainConnectionType_s(const am_mainConnectionID_t& mainConnectionID, const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, const am_timeSync_t& delay, const am_ConnectionState_e& connectionState);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ typeOutputStream.writeInt32Type();
++ }
++ };
++ typedef std::vector<am_MainConnectionType_s> am_MainConnection_L;
++ /**
++ * product specific identifier of property
++ */
++ /**
++ * product specific identifier of property
++ */
++ typedef uint16_t am_CustomClassProperty_t;
++ /**
++ * describes class properties
++ */
++ /**
++ * describes class properties
++ */
++ struct am_ClassProperty_s: CommonAPI::SerializableStruct {
++ /**
++ * the property as enum
++ */
++ am_CustomClassProperty_t classProperty;
++ /**
++ * the value of the property
++ */
++ int16_t value;
++
++ am_ClassProperty_s() = default;
++ am_ClassProperty_s(const am_CustomClassProperty_t& classProperty, const int16_t& value);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ }
++ };
++ typedef std::vector<am_ClassProperty_s> am_ClassProperty_L;
++ typedef uint16_t am_sinkClass_t;
++ /**
++ * struct describing sinkclasses
++ */
++ /**
++ * struct describing sinkclasses
++ */
++ struct am_SinkClass_s: CommonAPI::SerializableStruct {
++ /**
++ * the ID of the sinkClass
++ */
++ am_sinkClass_t sinkClassID;
++ /**
++ * the name of the sinkClass - must be unique in the system
++ */
++ std::string name;
++ /**
++ * the list of the class properties. These are pairs of a project specific enum
++ * describing the type of the value and an integer holding the real value.
++ */
++ am_ClassProperty_L listClassProperties;
++
++ am_SinkClass_s() = default;
++ am_SinkClass_s(const am_sinkClass_t& sinkClassID, const std::string& name, const am_ClassProperty_L& listClassProperties);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ typedef std::vector<am_SinkClass_s> am_SinkClass_L;
++ /**
++ * This is the volume presented on the command interface. It is in the duty of the
++ * Controller to change the volumes given here into meaningful values on the
++ * routing interface.
++ The range of this type is customer specific.
++ */
++ /**
++ * This is the volume presented on the command interface. It is in the duty of the
++ * Controller to change the volumes given here into meaningful values on the
++ * routing interface.
++ The range of this type is customer specific.
++ */
++ typedef int16_t am_mainVolume_t;
++ /**
++ * This project specific value gives the information about reason for reason for
++ * Source/Sink change
++ */
++ /**
++ * This project specific value gives the information about reason for reason for
++ * Source/Sink change
++ */
++ typedef uint16_t am_CustomAvailabilityReason_t;
++ /**
++ * with the help of this enum, sinks and sources can report their availability
++ * state
++ */
++ enum class am_Availability_e: int32_t {
++ /**
++ * default
++ */
++ A_UNKNOWN = 0,
++ /**
++ * The source / sink is available
++ */
++ A_AVAILABLE = 1,
++ /**
++ * the source / sink is not available
++ */
++ A_UNAVAILABLE = 2,
++ A_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_Availability_eComparator;
++ enum class am_MuteState_e: int32_t {
++ /**
++ * default
++ */
++ MS_UNKNOWN = 0,
++ /**
++ * the source / sink is muted
++ */
++ MS_MUTED = 1,
++ /**
++ * the source / sink is unmuted
++ */
++ MS_UNMUTED = 2,
++ MS_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_MuteState_eComparator;
++ /**
++ * this describes the availability of a sink or a source together with the latest
++ * change
++ */
++ /**
++ * this describes the availability of a sink or a source together with the latest
++ * change
++ */
++ struct am_Availability_s: CommonAPI::SerializableStruct {
++ /**
++ * the current availability state
++ */
++ am_Availability_e availability;
++ /**
++ * the reason for the last change. This can be used to trigger events that deal
++ * with state changes.
++ */
++ am_CustomAvailabilityReason_t availabilityReason;
++
++ am_Availability_s() = default;
++ am_Availability_s(const am_Availability_e& availability, const am_CustomAvailabilityReason_t& availabilityReason);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeUInt16Type();
++ }
++ };
++ /**
++ * this type holds all information of sinks relevant to the HMI
++ */
++ /**
++ * this type holds all information of sinks relevant to the HMI
++ */
++ struct am_SinkType_s: CommonAPI::SerializableStruct {
++ /**
++ * This is the ID of the sink, it is unique in the system. There are 2 ways, ID
++ * can be created: either it is assigned during the registration process (in a
++ * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
++ * is a fixed (the project has to ensure the uniqueness of the ID).
++ */
++ am_sinkID_t sinkID;
++ /**
++ * The name of the sink. Must be unique in the whole system.
++ */
++ std::string name;
++ /**
++ * This attribute reflects the availability of the sink. There are several reasons
++ * why a sink could be not available for the moment: for example the shutdown of
++ * a sink because of overtemperature or over- &amp; undervoltage. The
++ * availability consists of two pieces of information:
++
++ Availablility: the
++ * status itself, can be A_AVAILABLE, A_UNAVAILABLE or A_UNKNOWN
++
++ * AvailabilityReason: this informs about the last reason for a change in
++ * availability. The reasons itself are product specific.
++ */
++ am_Availability_s availability;
++ /**
++ * This is the representation of the Volume for the commandInterface. It is used
++ * by the HMI to set the volume of a sink, the AudioManagerController has to
++ * transform this into real source and sink volumes.
++ */
++ am_mainVolume_t volume;
++ am_MuteState_e muteState;
++ /**
++ * The sinkClassID references to a sinkClass. With the help of classification,
++ * rules can be setup to define the system behaviour.
++ */
++ am_sinkClass_t sinkClassID;
++
++ am_SinkType_s() = default;
++ am_SinkType_s(const am_sinkID_t& sinkID, const std::string& name, const am_Availability_s& availability, const am_mainVolume_t& volume, const am_MuteState_e& muteState, const am_sinkClass_t& sinkClassID);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.writeInt16Type();
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeUInt16Type();
++ }
++ };
++ typedef std::vector<am_SinkType_s> am_SinkType_L;
++ typedef uint16_t am_sourceClass_t;
++ /**
++ * struct describing source classes
++ */
++ /**
++ * struct describing source classes
++ */
++ struct am_SourceClass_s: CommonAPI::SerializableStruct {
++ /**
++ * the source ID
++ */
++ am_sourceClass_t sourceClassID;
++ /**
++ * the name of the sourceClass - must be unique in the system
++ */
++ std::string name;
++ /**
++ * the list of the class properties. These are pairs of a project specific enum
++ * describing the type of the value and an integer holding the real value.
++ */
++ am_ClassProperty_L listClassProperties;
++
++ am_SourceClass_s() = default;
++ am_SourceClass_s(const am_sourceClass_t& sourceClassID, const std::string& name, const am_ClassProperty_L& listClassProperties);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ typedef std::vector<am_SourceClass_s> am_SourceClass_L;
++ /**
++ * this type holds all information of sources relevant to the HMI
++ */
++ /**
++ * this type holds all information of sources relevant to the HMI
++ */
++ struct am_SourceType_s: CommonAPI::SerializableStruct {
++ /**
++ * This is the ID of the source, it is unique in the system. There are 2 ways, ID
++ * can be created: either it is assigned during the registration process (in a
++ * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
++ * is a fixed (the project has to ensure the uniqueness of the ID).
++ */
++ am_sourceID_t sourceID;
++ /**
++ * The name of the source. Must be unique in the whole system.
++ */
++ std::string name;
++ /**
++ * the availability of the source
++ */
++ am_Availability_s availability;
++ /**
++ * the sourceClassID, indicates the class the source is in. This information can
++ * be used by the Controller to implement different behaviour for different
++ * classes.
++ */
++ am_sourceClass_t sourceClassID;
++
++ am_SourceType_s() = default;
++ am_SourceType_s(const am_sourceID_t& sourceID, const std::string& name, const am_Availability_s& availability, const am_sourceClass_t& sourceClassID);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.writeUInt16Type();
++ }
++ };
++ typedef std::vector<am_SourceType_s> am_SourceType_L;
++ /**
++ * describes the different system properties. Project specific
++ */
++ /**
++ * describes the different system properties. Project specific
++ */
++ typedef uint16_t am_CustomSystemPropertyType_t;
++ /**
++ * struct describing system properties
++ */
++ /**
++ * struct describing system properties
++ */
++ struct am_SystemProperty_s: CommonAPI::SerializableStruct {
++ /**
++ * the type that is set
++ */
++ am_CustomSystemPropertyType_t type;
++ /**
++ * the value
++ */
++ int16_t value;
++
++ am_SystemProperty_s() = default;
++ am_SystemProperty_s(const am_CustomSystemPropertyType_t& type, const int16_t& value);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ }
++ };
++ typedef std::vector<am_SystemProperty_s> am_SystemProperty_L;
++ /**
++ * a connection ID
++ */
++ /**
++ * a connection ID
++ */
++ typedef uint16_t am_connectionID_t;
++ typedef std::vector<am_connectionID_t> am_ConnectionID_L;
++ /**
++ * The unit is 0.1 db steps,The smallest value -3000 (=AM_MUTE). The minimum and
++ * maximum can be limited by actual project.
++ */
++ /**
++ * The unit is 0.1 db steps,The smallest value -3000 (=AM_MUTE). The minimum and
++ * maximum can be limited by actual project.
++ */
++ typedef int16_t am_volume_t;
++ /**
++ * Project specific sound properties.
++ */
++ /**
++ * Project specific sound properties.
++ */
++ typedef uint16_t am_CustomSoundPropertyType_t;
++ /**
++ * This enum characterizes the data of the EarlyData_t
++ */
++ enum class am_EarlyDataType_e: int32_t {
++ /**
++ * default
++ */
++ ES_UNKNOWN = 0,
++ /**
++ * the source volume
++ */
++ ED_SOURCE_VOLUME = 1,
++ /**
++ * the sink volume
++ */
++ ED_SINK_VOLUME = 2,
++ /**
++ * a source property
++ */
++ ED_SOURCE_PROPERTY = 3,
++ /**
++ * a sink property
++ */
++ ED_SINK_PROPERTY = 4,
++ ED_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_EarlyDataType_eComparator;
++ /**
++ * struct describing the sound property
++ */
++ /**
++ * struct describing the sound property
++ */
++ struct am_SoundProperty_s: CommonAPI::SerializableStruct {
++ /**
++ * the type of the property - a project specific enum
++ */
++ am_CustomSoundPropertyType_t type;
++ /**
++ * the actual value of the property
++ */
++ int16_t value;
++
++ am_SoundProperty_s() = default;
++ am_SoundProperty_s(const am_CustomSoundPropertyType_t& type, const int16_t& value);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ }
++ };
++ /**
++ * data type depends of am_EarlyDataType_e:
++ volume_t in case of ED_SOURCE_VOLUME,
++ * ED_SINK_VOLUME
++ soundProperty_t in case of ED_SOURCE_PROPERTY,
++ * ED_SINK_PROPERTY
++ */
++ /**
++ * data type depends of am_EarlyDataType_e:
++ volume_t in case of ED_SOURCE_VOLUME,
++ * ED_SINK_VOLUME
++ soundProperty_t in case of ED_SOURCE_PROPERTY,
++ * ED_SINK_PROPERTY
++ */
++ typedef CommonAPI::Variant<am_volume_t, am_SoundProperty_s> am_EarlyData_u;
++ /**
++ * data type depends of am_EarlyDataType_e:
++ sourceID in case of ED_SOURCE_VOLUME,
++ * ED_SOURCE_PROPERTY
++ sinkID in case of ED_SINK_VOLUME, ED_SINK_PROPERTY
++ */
++ /**
++ * data type depends of am_EarlyDataType_e:
++ sourceID in case of ED_SOURCE_VOLUME,
++ * ED_SOURCE_PROPERTY
++ sinkID in case of ED_SINK_VOLUME, ED_SINK_PROPERTY
++ */
++ typedef CommonAPI::Variant<am_sinkID_t, am_sourceID_t> am_DataType_u;
++ struct am_EarlyData_s: CommonAPI::SerializableStruct {
++ am_EarlyDataType_e type;
++ am_DataType_u sinksource;
++ am_EarlyData_u data;
++
++ am_EarlyData_s() = default;
++ am_EarlyData_s(const am_EarlyDataType_e& type, const am_DataType_u& sinksource, const am_EarlyData_u& data);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeVariantType();
++ typeOutputStream.writeVariantType();
++ }
++ };
++ typedef std::vector<am_EarlyData_s> am_EarlyData_L;
++ /**
++ * Here are all SoundProperties that can be set via the CommandInterface. Product
++ * specific
++ */
++ /**
++ * Here are all SoundProperties that can be set via the CommandInterface. Product
++ * specific
++ */
++ typedef uint16_t am_CustomMainSoundPropertyType_t;
++ /**
++ * struct describung mainsound property
++ */
++ /**
++ * struct describung mainsound property
++ */
++ struct am_MainSoundProperty_s: CommonAPI::SerializableStruct {
++ /**
++ * the type of the property
++ */
++ am_CustomMainSoundPropertyType_t type;
++ /**
++ * the actual value
++ */
++ int16_t value;
++
++ am_MainSoundProperty_s() = default;
++ am_MainSoundProperty_s(const am_CustomMainSoundPropertyType_t& type, const int16_t& value);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ }
++ };
++ typedef std::vector<am_MainSoundProperty_s> am_MainSoundProperty_L;
++ /**
++ * gives the type of the Notification.
++ */
++ /**
++ * gives the type of the Notification.
++ */
++ typedef uint16_t am_CustomNotificationType_t;
++ enum class am_NotificationStatus_e: int32_t {
++ NS_UNKNOWN = 0,
++ /**
++ * No notification, the function is turned off
++ */
++ NS_OFF = 1,
++ /**
++ * Periodic notifications are sent out. The period in ms is given by
++ * am_NotificationParameter
++ */
++ NS_PERIODIC = 2,
++ /**
++ * The notification is sent out when the minimum given by am_NotificationParameter
++ * is reached.
++ */
++ NS_MINIMUM = 3,
++ /**
++ * The notification is sent out when the maximum given by am_NotificationParameter
++ * is reached.
++ */
++ NS_MAXIMUM = 4,
++ /**
++ * The notification is sent out when a change happened. The Resolution of the
++ * change is defined by am_NotificationParameter.
++ */
++ NS_CHANGE_ = 5,
++ NS_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_NotificationStatus_eComparator;
++ /**
++ * This struct holds information about the configuration for notifications
++ */
++ /**
++ * This struct holds information about the configuration for notifications
++ */
++ struct am_NotificationConfiguration_s: CommonAPI::SerializableStruct {
++ /**
++ * The notification type of the notification
++ */
++ am_CustomNotificationType_t type;
++ /**
++ * The Notification status. This can be periodic, min/max value based or even off
++ * for example
++ */
++ am_NotificationStatus_e status;
++ /**
++ * This gives additional information to the notification status.
++ Relation between
++ * notification status and the value:
++ NS_PERIODIC - the period in ms
++ NS_MINIMUM
++ * - the minimum value that triggers the notification
++ NS_MAXIMUM - the maximum
++ * value that triggers the notifcation
++ NS_CHANGE - the resolution of the change
++ * value
++ */
++ int16_t parameter;
++
++ am_NotificationConfiguration_s() = default;
++ am_NotificationConfiguration_s(const am_CustomNotificationType_t& type, const am_NotificationStatus_e& status, const int16_t& parameter);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeInt16Type();
++ }
++ };
++ typedef std::vector<am_NotificationConfiguration_s> am_NotificationConfiguration_L;
++ /**
++ * a domain ID
++ */
++ /**
++ * a domain ID
++ */
++ typedef uint16_t am_domainID_t;
++ /**
++ * This project specific value classifies the format in which data is exchanged
++ * within a connection.
++ */
++ /**
++ * This project specific value classifies the format in which data is exchanged
++ * within a connection.
++ */
++ typedef uint16_t am_CustomConnectionFormat_t;
++ /**
++ * This represents one "hopp" in a route
++ */
++ /**
++ * This represents one "hopp" in a route
++ */
++ struct am_RoutingElement_s: CommonAPI::SerializableStruct {
++ /**
++ * the source ID
++ */
++ am_sourceID_t sourceID;
++ /**
++ * the sinkID
++ */
++ am_sinkID_t sinkID;
++ /**
++ * the domainID the routeElement is in
++ */
++ am_domainID_t domainID;
++ /**
++ * the connectionformat that is used for the route
++ */
++ am_CustomConnectionFormat_t connectionFormat;
++
++ am_RoutingElement_s() = default;
++ am_RoutingElement_s(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, const am_domainID_t& domainID, const am_CustomConnectionFormat_t& connectionFormat);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ }
++ };
++ typedef std::vector<am_RoutingElement_s> am_RoutingElement_L;
++ typedef std::vector<am_SoundProperty_s> am_SoundProperty_L;
++ /**
++ * time in ms!
++ */
++ /**
++ * time in ms!
++ */
++ typedef int16_t am_time_t;
++ /**
++ * For products, different ramp types can be defined here.
++ It is in the
++ * responsibility of the product to make sure that the routing plugins are aware
++ * of the ramp types used.
++ */
++ /**
++ * For products, different ramp types can be defined here.
++ It is in the
++ * responsibility of the product to make sure that the routing plugins are aware
++ * of the ramp types used.
++ */
++ typedef uint16_t am_CustomRampType_t;
++ /**
++ * This datatype determines if a sourceID or a sinkID is used in the union
++ * following
++ */
++ enum class am_VolumeType_e: int32_t {
++ VT_UNKNOWN = 0,
++ /**
++ * the following type is a sink
++ */
++ VT_SINK = 1,
++ /**
++ * the following type is a source
++ */
++ VT_SOURCE = 2,
++ VT_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_VolumeType_eComparator;
++ /**
++ * This types describe a mixed description for source and sinks volumes.
++ */
++ /**
++ * This types describe a mixed description for source and sinks volumes.
++ */
++ struct am_Volumes_s: CommonAPI::SerializableStruct {
++ /**
++ * describes the type of the volume: source or sink.
++ */
++ am_VolumeType_e volumeType;
++ /**
++ * either sourceID or sinkID
++ */
++ am_DataType_u volumeID;
++ /**
++ * The volume
++ */
++ am_volume_t volume;
++ /**
++ * the ramp that shall be driven
++ */
++ am_CustomRampType_t ramp;
++ /**
++ * the time for the ramp
++ */
++ am_time_t time;
++
++ am_Volumes_s() = default;
++ am_Volumes_s(const am_VolumeType_e& volumeType, const am_DataType_u& volumeID, const am_volume_t& volume, const am_CustomRampType_t& ramp, const am_time_t& time);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeVariantType();
++ typeOutputStream.writeInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ }
++ };
++ typedef std::vector<am_Volumes_s> am_Volumes_L;
++ typedef std::vector<am_CustomConnectionFormat_t> am_ConnectionFormat_L;
++ typedef bool am_bool_t;
++ typedef std::vector<am_bool_t> am_Convertion_L;
++ /**
++ * a gateway ID
++ */
++ /**
++ * a gateway ID
++ */
++ typedef uint16_t am_gatewayID_t;
++ /**
++ * a converter ID
++ */
++ /**
++ * a converter ID
++ */
++ typedef uint16_t am_converterID_t;
++ /**
++ * a crossfader ID
++ */
++ /**
++ * a crossfader ID
++ */
++ typedef uint16_t am_crossfaderID_t;
++ /**
++ * speed
++ */
++ /**
++ * speed
++ */
++ typedef uint16_t am_speed_t;
++ /**
++ * describes the active sink of a crossfader.
++ */
++ enum class am_HotSink_e: int32_t {
++ /**
++ * default
++ */
++ HS_UNKNOWN = 0,
++ /**
++ * sinkA is active
++ */
++ HS_SINKA = 1,
++ /**
++ * sinkB is active
++ */
++ HS_SINKB = 2,
++ /**
++ * the crossfader is in the transition state
++ */
++ HS_INTERMEDIATE = 3,
++ HS_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_HotSink_eComparator;
++ enum class am_DomainState_e: int32_t {
++ /**
++ * default
++ */
++ DS_UNKNOWN = 0,
++ /**
++ * the domain is controlled by the daemon
++ */
++ DS_CONTROLLED = 1,
++ /**
++ * the domain is independent starting up
++ */
++ DS_INDEPENDENT_STARTUP = 1,
++ /**
++ * the domain is independent running down
++ */
++ DS_INDEPENDENT_RUNDOWN = 2,
++ DS_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_DomainState_eComparator;
++ /**
++ * the errors of the audiomanager. All possible errors are in here. This enum is
++ * used widely as return parameter.
++ */
++ enum class am_Error_e: int32_t {
++ /**
++ * no error - positive reply
++ */
++ E_OK = 0,
++ /**
++ * default
++ */
++ E_UNKNOWN = 1,
++ /**
++ * value out of range
++ */
++ E_OUT_OF_RANGE = 2,
++ /**
++ * not used
++ */
++ E_NOT_USED = 3,
++ /**
++ * a database error occurred
++ */
++ E_DATABASE_ERROR = 4,
++ /**
++ * the desired object already exists
++ */
++ E_ALREADY_EXISTS = 5,
++ /**
++ * there is no change
++ */
++ E_NO_CHANGE = 6,
++ /**
++ * the desired action is not possible
++ */
++ E_NOT_POSSIBLE = 7,
++ /**
++ * the desired object is non existent
++ */
++ E_NON_EXISTENT = 8,
++ /**
++ * the asynchronous action was aborted
++ */
++ E_ABORTED = 9,
++ /**
++ * This error is returned in case a connect is issued with a connectionFormat that
++ * cannot be selected for the connection. This could be either due to the
++ * capabilities of a source or a sink or gateway compatibilities for example
++ */
++ E_WRONG_FORMAT = 10,
++ E_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_Error_eComparator;
++ enum class am_InterruptState_e: int32_t {
++ /**
++ * default
++ */
++ IS_UNKNOWN = 0,
++ /**
++ * the interrupt state is off - no interrupt
++ */
++ IS_OFF = 1,
++ /**
++ * the interrupt state is interrupted - the interrupt is active
++ */
++ IS_INTERRUPTED = 2,
++ IS_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_InterruptState_eComparator;
++ /**
++ * This enumeration is used to define the type of the action that is correlated to
++ * a handle.
++ */
++ enum class am_Handle_e: int32_t {
++ H_UNKNOWN = 0,
++ H_CONNECT = 1,
++ H_DISCONNECT = 2,
++ H_SETSOURCESTATE = 3,
++ H_SETSINKVOLUME = 4,
++ H_SETSOURCEVOLUME = 5,
++ H_SETSINKSOUNDPROPERTY = 6,
++ H_SETSOURCESOUNDPROPERTY = 7,
++ H_SETSINKSOUNDPROPERTIES = 8,
++ H_SETSOURCESOUNDPROPERTIES = 9,
++ H_CROSSFADE = 10,
++ H_SETVOLUMES = 11,
++ H_SETSINKNOTIFICATION = 12,
++ H_SETSOURCENOTIFICATION = 13,
++ H_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_Handle_eComparator;
++ /**
++ * The source state reflects the state of the source
++ */
++ enum class am_SourceState_e: int32_t {
++ SS_UNKNNOWN = 0,
++ /**
++ * The source can be activly heared
++ */
++ SS_ON = 1,
++ /**
++ * The source cannot be heared
++ */
++ SS_OFF = 2,
++ /**
++ * The source is paused. Meaning it cannot be heared but should be prepared to
++ * play again soon.
++ */
++ SS_PAUSED = 3,
++ SS_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_SourceState_eComparator;
++ /**
++ * This enum describes the ready state of the routing part
++ */
++ enum class am_RoutingReady_e: int32_t {
++ RR_UNKNOWN = 0,
++ RR_READY = 1,
++ RR_RUNDOWN = 2
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_RoutingReady_eComparator;
++ /**
++ * a list of routing elements that lead from source to sink
++ */
++ /**
++ * a list of routing elements that lead from source to sink
++ */
++ struct am_Route_s: CommonAPI::SerializableStruct {
++ /**
++ * the sourceID where the route starts
++ */
++ am_sourceID_t sourceID;
++ /**
++ * the sinkID where the route ends
++ */
++ am_sinkID_t sinkID;
++ /**
++ * the actual route as list of routing elements
++ */
++ am_RoutingElement_L route;
++
++ am_Route_s() = default;
++ am_Route_s(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, const am_RoutingElement_L& route);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeUInt16Type();typeOutputStream.writeUInt16Type();typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ /**
++ * This struct describes the attribiutes of a crossfader.
++ */
++ /**
++ * This struct describes the attribiutes of a crossfader.
++ */
++ struct am_Crossfader_s: CommonAPI::SerializableStruct {
++ /**
++ * This is the ID of the crossfader, it is unique in the system. There are 2 ways,
++ * ID can be created: either it is assigned during the registration process (in a
++ * dynamic context, uniqueness will be ensured by the AudioManager daemon), or it
++ * is a fixed (the project has to ensure the uniqueness of the ID).
++ */
++ am_crossfaderID_t crossfaderID;
++ /**
++ * The name of the crossfader. Must be unique in the whole system.
++ */
++ std::string name;
++ /**
++ * The sinkID of the SinkA. Sinks shall be registered before registering the
++ * crossfader.
++ */
++ am_sinkID_t sinkID_A;
++ /**
++ * The sinkID of the SinkB. Sinks shall be registered before registering the
++ * crossfader.
++ */
++ am_sinkID_t sinkID_B;
++ /**
++ * The sourceID of the crossfader source. The source shall be registered before
++ * the crossfader.
++ */
++ am_sourceID_t sourceID;
++ /**
++ * This enum can have 3 states:
++
++ HS_SINKA sinkA is the current hot one, sinkB
++ * is not audible
++ HS_SINKB sinkB is the current hot one, sinkB is not
++ * audible
++ HS_INTERMEDIATE the fader is stuck in between a cross-fading
++ * action. This could be due to an abort or an error. Before using the
++ * crossfader, it must be set to either HS_SINKA or HS_SINKB.
++ */
++ am_HotSink_e hotSink;
++
++ am_Crossfader_s() = default;
++ am_Crossfader_s(const am_crossfaderID_t& crossfaderID, const std::string& name, const am_sinkID_t& sinkID_A, const am_sinkID_t& sinkID_B, const am_sourceID_t& sourceID, const am_HotSink_e& hotSink);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt32Type();
++ }
++ };
++ /**
++ * This struct describes the attributes of a gateway.
++ */
++ /**
++ * This struct describes the attributes of a gateway.
++ */
++ struct am_Gateway_s: CommonAPI::SerializableStruct {
++ /**
++ * This is the ID of the gateway, it is unique in the system. There are 2 ways, ID
++ * can be created: either it is assigned during the registration process (in a
++ * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
++ * is a fixed (the project has to ensure the uniqueness of the ID).
++ */
++ am_gatewayID_t gatewayID;
++ /**
++ * The name of the gateway. Must be unique in the whole system.
++ */
++ std::string name;
++ /**
++ * The sinkID of the gateway sink-end. The sink is a full blown sink with
++ * connectionFormats, sinkClassIDs etc... It makes sense to register the sinks of
++ * a gateway as non-visible. Care needs to be taken that the connectionsFormats
++ * match with the ones in the conversionMatrix. If the sink is located in the
++ * controllingDomain, the ID needs to be retrieved by registering the sink before
++ * registering the gateway. In case the sink is in a different domain, the ID
++ * needs to be retrieved via peeking.
++ */
++ am_sinkID_t sinkID;
++ /**
++ * The sourceID of the gateway sink-end. The sink is a full blown source with
++ * connectionFormats, sinkClassIDs etc... It makes sense to register the sources
++ * of a gateway as non-visible. Care needs to be taken that the
++ * connectionsFormats match with the ones in the conversionMatrix. If the source
++ * is located in the controllingDomain, the ID needs to be retrieved by
++ * registering the source before registering the gateway. In case the source is
++ * in a different domain, the ID needs to be retrieved via peeking.
++ */
++ am_sourceID_t sourceID;
++ /**
++ * The ID of the sink. If the domain is the same like the controlling domain, the
++ * ID is known due to registration. If the domain is different, the ID needs to
++ * be retrieved via peeking.
++ */
++ am_domainID_t domainSinkID;
++ /**
++ * The ID of the source. If the domain is the same like the controlling domain,
++ * the ID is known due to registration. If the domain is different, the ID needs
++ * to be retrieved via peeking.
++ */
++ am_domainID_t domainSourceID;
++ /**
++ * This is the ID of the domain that registers the gateway.
++ */
++ am_domainID_t controlDomainID;
++ /**
++ * This is the list of available formats on the source side of the gateway. It is
++ * not defined during the gateway registration but copied from the source
++ * registration.
++ */
++ am_ConnectionFormat_L listSourceFormats;
++ /**
++ * This is the list of available formats on the sink side of the gateway. It is
++ * not defined during the gateway registration but copied from the sink
++ * registration.
++ */
++ am_ConnectionFormat_L listSinkFormats;
++ /**
++ * This is matrix holding information about the conversion capability of the
++ * gateway, it's length is defined by the length(listSinkFormats) x
++ * length(listSourceFormats).
++ If a SinkFormat can be converted into a
++ * SourceFormat, the vector will hold a 1, if no conversion is possible, a
++ * 0.
++ The data is stored row orientated, where the rows are related to the
++ * sinksFormats and the columns to the sourceFormats. The first value will hold
++ * the conversion information from the first sourceFormat to the first sinkFormat
++ * for example and the seventh value the information about the 3rd sinkFormat to
++ * the 1st sourceFormat in case we would have 3 sourceFormats.
++ */
++ am_Convertion_L convertionMatrix;
++
++ am_Gateway_s() = default;
++ am_Gateway_s(const am_gatewayID_t& gatewayID, const std::string& name, const am_sinkID_t& sinkID, const am_sourceID_t& sourceID, const am_domainID_t& domainSinkID, const am_domainID_t& domainSourceID, const am_domainID_t& controlDomainID, const am_ConnectionFormat_L& listSourceFormats, const am_ConnectionFormat_L& listSinkFormats, const am_Convertion_L& convertionMatrix);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeBoolType();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ /**
++ * This struct describes the attributes of a gateway.
++ */
++ /**
++ * This struct describes the attributes of a gateway.
++ */
++ struct am_Converter_s: CommonAPI::SerializableStruct {
++ /**
++ * This is the ID of the gateway, it is unique in the system. There are 2 ways, ID
++ * can be created: either it is assigned during the registration process (in a
++ * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
++ * is a fixed (the project has to ensure the uniqueness of the ID).
++ */
++ am_converterID_t converterID;
++ /**
++ * The name of the gateway. Must be unique in the whole system.
++ */
++ std::string name;
++ /**
++ * The sinkID of the gateway sink-end. The sink is a full blown sink with
++ * connectionFormats, sinkClassIDs etc... It makes sense to register the sinks of
++ * a gateway as non-visible. Care needs to be taken that the connectionsFormats
++ * match with the ones in the conversionMatrix. If the sink is located in the
++ * controllingDomain, the ID needs to be retrieved by registering the sink before
++ * registering the gateway. In case the sink is in a different domain, the ID
++ * needs to be retrieved via peeking.
++ */
++ am_sinkID_t sinkID;
++ /**
++ * The sourceID of the gateway sink-end. The sink is a full blown source with
++ * connectionFormats, sinkClassIDs etc... It makes sense to register the sources
++ * of a gateway as non-visible. Care needs to be taken that the
++ * connectionsFormats match with the ones in the conversionMatrix. If the source
++ * is located in the controllingDomain, the ID needs to be retrieved by
++ * registering the source before registering the gateway. In case the source is
++ * in a different domain, the ID needs to be retrieved via peeking.
++ */
++ am_sourceID_t sourceID;
++ /**
++ * The ID of the sink. If the domain is the same like the controlling domain, the
++ * ID is known due to registration. If the domain is different, the ID needs to
++ * be retrieved via peeking.
++ */
++ am_domainID_t domainID;
++ /**
++ * This is the list of available formats on the source side of the gateway. It is
++ * not defined during the gateway registration but copied from the source
++ * registration.
++ */
++ am_ConnectionFormat_L listSourceFormats;
++ /**
++ * This is the list of available formats on the sink side of the gateway. It is
++ * not defined during the gateway registration but copied from the sink
++ * registration.
++ */
++ am_ConnectionFormat_L listSinkFormats;
++ /**
++ * This is matrix holding information about the conversion capability of the
++ * gateway, it's length is defined by the length(listSinkFormats) x
++ * length(listSourceFormats).
++ If a SinkFormat can be converted into a
++ * SourceFormat, the vector will hold a 1, if no conversion is possible, a
++ * 0.
++ The data is stored row orientated, where the rows are related to the
++ * sinksFormats and the columns to the sourceFormats. The first value will hold
++ * the conversion information from the first sourceFormat to the first sinkFormat
++ * for example and the seventh value the information about the 3rd sinkFormat to
++ * the 1st sourceFormat in case we would have 3 sourceFormats.
++ */
++ am_Convertion_L convertionMatrix;
++
++ am_Converter_s() = default;
++ am_Converter_s(const am_converterID_t& converterID, const std::string& name, const am_sinkID_t& sinkID, const am_sourceID_t& sourceID, const am_domainID_t& domainID, const am_ConnectionFormat_L& listSourceFormats, const am_ConnectionFormat_L& listSinkFormats, const am_Convertion_L& convertionMatrix);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeBoolType();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ /**
++ * a handle is used for asynchronous operations and is uniquely assigned for each
++ * of this operations
++ */
++ /**
++ * a handle is used for asynchronous operations and is uniquely assigned for each
++ * of this operations
++ */
++ struct am_Handle_s: CommonAPI::SerializableStruct {
++ /**
++ * the handletype
++ */
++ am_Handle_e handleType;
++ /**
++ * the handle as value
++ */
++ uint16_t handle;
++
++ am_Handle_s() = default;
++ am_Handle_s(const am_Handle_e& handleType, const uint16_t& handle);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeUInt16Type();
++ }
++ };
++ /**
++ * struct that holds attribiutes of a mainconnection
++ */
++ /**
++ * struct that holds attribiutes of a mainconnection
++ */
++ struct am_MainConnection_s: CommonAPI::SerializableStruct {
++ /**
++ * the assigned ID
++ */
++ am_mainConnectionID_t mainConnectionID;
++ /**
++ * the current connection state
++ */
++ am_ConnectionState_e connectionState;
++ /**
++ * the sinkID
++ */
++ am_sinkID_t sinkID;
++ /**
++ * the sourceID
++ */
++ am_sourceID_t sourceID;
++ /**
++ * the delay of the connection
++ */
++ am_timeSync_t delay;
++ /**
++ * the list of sub connection IDs the mainconnection consists of
++ */
++ am_ConnectionID_L listConnectionID;
++
++ am_MainConnection_s() = default;
++ am_MainConnection_s(const am_mainConnectionID_t& mainConnectionID, const am_ConnectionState_e& connectionState, const am_sinkID_t& sinkID, const am_sourceID_t& sourceID, const am_timeSync_t& delay, const am_ConnectionID_L& listConnectionID);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ /**
++ * This struct holds the payload of a notification.
++ */
++ /**
++ * This struct holds the payload of a notification.
++ */
++ struct am_NotificationPayload_s: CommonAPI::SerializableStruct {
++ /**
++ * This defines the notification type
++ */
++ am_CustomNotificationType_t type;
++ /**
++ * This is finally the value of the notification. It's meaning depends on the
++ * notificationType
++ */
++ int16_t value;
++
++ am_NotificationPayload_s() = default;
++ am_NotificationPayload_s(const am_CustomNotificationType_t& type, const int16_t& value);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ }
++ };
++ /**
++ * This struct describes the attribiutes of a sink
++ */
++ /**
++ * This struct describes the attribiutes of a sink
++ */
++ struct am_Sink_s: CommonAPI::SerializableStruct {
++ /**
++ * This is the ID of the sink, it is unique in the system. There are 2 ways, ID
++ * can be created: either it is assigned during the registration process (in a
++ * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
++ * is a fixed (the project has to ensure the uniqueness of the ID).
++ */
++ am_sinkID_t sinkID;
++ /**
++ * The name of the sink. Must be unique in the whole system.
++ */
++ std::string name;
++ /**
++ * The domainID is the domain the sink belongs to. A sink can only be in one
++ * domain.
++ */
++ am_domainID_t domainID;
++ /**
++ * The sinkClassID references to a sinkClass. With the help of classification,
++ * rules can be setup to define the system behaviour.
++ */
++ am_sinkClass_t sinkClassID;
++ /**
++ * This is the volume of the sink. It is set by the AudioManagerController.
++ */
++ am_volume_t volume;
++ /**
++ * This Boolean flag indicates whether a sink is visible to the commandInterface
++ * or not. If the User must have the possibility to choose the source in the HMI,
++ * it must be visible. But there are also good reasons for invisible sinks, for
++ * example if the sink is part of a crossfader or gateway. HMI relevant changes
++ * in visible sinks will be automatically reported by the daemon to the
++ * commandInterface.
++ */
++ bool visible;
++ /**
++ * This attribute reflects the availability of the sink. There are several reasons
++ * why a sink could be not available for the moment: for example the shutdown of
++ * a sink because of overtemperature or over- &amp; undervoltage. The
++ * availability consists of two pieces of information:
++
++ Availablility: the
++ * status itself, can be A_AVAILABLE, A_UNAVAILABLE or A_UNKNOWN
++
++ * AvailabilityReason: this informs about the last reason for a change in
++ * availability. The reasons itself are product specific.
++ */
++ am_Availability_s available;
++ /**
++ * This attribute reflects the muteState of the sink. The information is not the
++ * "real" state of the sink, but the HMI representation for he commandInterface
++ * controlled by the AudioManagerController.
++ */
++ am_MuteState_e muteState;
++ /**
++ * This is the representation of the Volume for the commandInterface. It is used
++ * by the HMI to set the volume of a sink, the AudioManagerController has to
++ * transform this into real source and sink volumes.
++ */
++ am_mainVolume_t mainVolume;
++ /**
++ * This is the list of soundProperties, that the sink is capable of. The
++ * soundProperties itself are project specific. For sinks, a possible
++ * soundProperty could be for example settings.
++ */
++ am_SoundProperty_L listSoundProperties;
++ /**
++ * This list holds information about the formats that the Source is capable of
++ * supporting when delivering audio.
++ */
++ am_ConnectionFormat_L listConnectionFormats;
++ /**
++ * This is the list of the available mainSoundProperties. The principle is the
++ * same than with soundProperties, but they are only visible to the
++ * CommandInterface.
++ */
++ am_MainSoundProperty_L listMainSoundProperties;
++ /**
++ * This is the list of the MainNotificationConfigurations. These notifications
++ * work on the level of command interface.
++ */
++ am_NotificationConfiguration_L listMainNotificationConfigurations;
++ /**
++ * This is the list of the NotificationConfigurations. These notifications work on
++ * the level of RoutingPlugins.
++ */
++ am_NotificationConfiguration_L listNotificationConfigurations;
++
++ am_Sink_s() = default;
++ am_Sink_s(const am_sinkID_t& sinkID, const std::string& name, const am_domainID_t& domainID, const am_sinkClass_t& sinkClassID, const am_volume_t& volume, const bool& visible, const am_Availability_s& available, const am_MuteState_e& muteState, const am_mainVolume_t& mainVolume, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, const am_NotificationConfiguration_L& listMainNotificationConfigurations, const am_NotificationConfiguration_L& listNotificationConfigurations);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ typeOutputStream.writeBoolType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeInt16Type();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ /**
++ * This struct describes the attribiutes of a source
++ */
++ /**
++ * This struct describes the attribiutes of a source
++ */
++ struct am_Source_s: CommonAPI::SerializableStruct {
++ /**
++ * This is the ID of the source, it is unique in the system. There are 2 ways, ID
++ * can be created: either it is assigned during the registration process (in a
++ * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
++ * is a fixed (the project has to ensure the uniqueness of the ID).
++ */
++ am_sourceID_t sourceID;
++ /**
++ * The domainID is the domain the source belongs to. A source can only be in one
++ * domain.
++ */
++ am_domainID_t domainID;
++ /**
++ * The name of the source. Must be unique in the whole system.
++ */
++ std::string name;
++ /**
++ * the sourceClassID, indicates the class the source is in. This information can
++ * be used by the Controller to implement different behaviour for different
++ * classes.
++ */
++ am_sourceClass_t sourceClassID;
++ /**
++ * The source state is an indication towards the source if it is actively heard or
++ * not. The source can use this information to implement features like automatic
++ * spin down of CD's in case the CD is not the active source or AF following of a
++ * tuner that is not actively heard. The source state is set by the
++ * AudioManagerController.There are 3 possible states:
++
++ SS_ON: the source is
++ * active
++ SS_OFF: the source is off
++ SS_PAUSED: the source is paused and
++ * not active.
++ */
++ am_SourceState_e sourceState;
++ /**
++ * This is the volume of the source. It is set by the AudioManagerController. It
++ * is used to adopt different audiolevels in a system and mixing of sources (e.g.
++ * navigation hints &amp; music).
++ */
++ am_volume_t volume;
++ /**
++ * This Boolean flag indicates whether a source is visible to the commandInterface
++ * or not. If the User must have the possibility to choose the source in the HMI,
++ * it must be visible. But there are also good reasons for invisible sources, for
++ * example if the source is part of a crossfader or gateway. HMI relevant changes
++ * in visible sources will be automatically reported by the daemon to the
++ * commandInterface.
++ */
++ bool visible;
++ /**
++ * This attribute reflects the availability of the source. There are several
++ * reasons why a source could be not available for the moment. For example a CD
++ * player which has no CD entered in the slot can be unavailable, or a USB player
++ * with no or unreadable stick attached. Other scenarios involve the shutdown of
++ * a source because of overtemperature or over- &amp; undervoltage. The
++ * availability consists of two informations:
++
++ Availablility: the status
++ * itself, can be A_AVAILABLE, A_UNAVAILABLE or A_UNKNOWN
++
++ * AvailabilityReason: this informs about the last reason for a change in
++ * availability. The reasons itself are product specific.
++ */
++ am_Availability_s available;
++ /**
++ * Some special sources can have special behaviors, the are so called "Low Level
++ * Interrupts". Here the current status is documented. The information can be
++ * used by the AudioManagerController to react to the changes by for example
++ * lowering the volume of the mainSources. The two states are
++
++ IS_OFF: the
++ * interrupt is not active at the moment
++ IS_INTERRUPTED: the interrupt is
++ * playing at the moment.
++ */
++ am_InterruptState_e interruptState;
++ /**
++ * This is the list of soundProperties, that the source is capable of. The
++ * soundProperties itself are project specific. For sources, a possible
++ * soundProperty could be navigation volume offset, for example.
++ */
++ am_SoundProperty_L listSoundProperties;
++ /**
++ * This list holds information about the formats that the Source is capable of
++ * supporting when delivering audio.
++ */
++ am_ConnectionFormat_L listConnectionFormats;
++ /**
++ * This is the list of the available mainSoundProperties. The principle is the
++ * same than with soundProperties, but they are only visible to the
++ * CommandInterface.
++ */
++ am_MainSoundProperty_L listMainSoundProperties;
++ /**
++ * The list of MainNotificationConfigurations. These notifications work on the
++ * level of CommandInterface.
++ */
++ am_NotificationConfiguration_L listMainNotificationConfigurations;
++ /**
++ * The list of MainNotificationConfigurations. These notifications work on the
++ * level of RoutingInterface.
++ */
++ am_NotificationConfiguration_L listNotificationConfigurations;
++
++ am_Source_s() = default;
++ am_Source_s(const am_sourceID_t& sourceID, const am_domainID_t& domainID, const std::string& name, const am_sourceClass_t& sourceClassID, const am_SourceState_e& sourceState, const am_volume_t& volume, const bool& visible, const am_Availability_s& available, const am_InterruptState_e& interruptState, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, const am_NotificationConfiguration_L& listMainNotificationConfigurations, const am_NotificationConfiguration_L& listNotificationConfigurations);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeInt16Type();
++ typeOutputStream.writeBoolType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ /**
++ * This struct describes the attribiutes of a domain
++ */
++ /**
++ * This struct describes the attribiutes of a domain
++ */
++ struct am_Domain_s: CommonAPI::SerializableStruct {
++ /**
++ * the domain ID
++ */
++ am_domainID_t domainID;
++ /**
++ * the name of the domain
++ */
++ std::string name;
++ /**
++ * the busname. This is equal to a plugin name and is used to dispatch messages to
++ * the elements of a plugin
++ */
++ std::string busname;
++ /**
++ * the name of the node
++ */
++ std::string nodename;
++ /**
++ * indicated if the domain is independent at startup or not
++ */
++ bool early;
++ /**
++ * indicates if the domain registration is complete or not
++ */
++ bool complete;
++ /**
++ * the current domain state
++ */
++ am_DomainState_e state;
++
++ am_Domain_s() = default;
++ am_Domain_s(const am_domainID_t& domainID, const std::string& name, const std::string& busname, const std::string& nodename, const bool& early, const bool& complete, const am_DomainState_e& state);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.writeStringType();
++ typeOutputStream.writeStringType();
++ typeOutputStream.writeBoolType();
++ typeOutputStream.writeBoolType();
++ typeOutputStream.writeInt32Type();
++ }
++ };
++ /**
++ * a connection
++ */
++ /**
++ * a connection
++ */
++ struct am_Connection_s: CommonAPI::SerializableStruct {
++ /**
++ * the assigned ID
++ */
++ am_connectionID_t connectionID;
++ /**
++ * the source the audio flows from
++ */
++ am_sourceID_t sourceID;
++ /**
++ * the sink the audio flows to
++ */
++ am_sinkID_t sinkID;
++ /**
++ * the delay of the conneciton
++ */
++ am_timeSync_t delay;
++ /**
++ * the used connectionformat
++ */
++ am_CustomConnectionFormat_t connectionFormat;
++
++ am_Connection_s() = default;
++ am_Connection_s(const am_connectionID_t& connectionID, const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, const am_timeSync_t& delay, const am_CustomConnectionFormat_t& connectionFormat);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ typeOutputStream.writeUInt16Type();
++ }
++ };
++
++inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_Availability_e& enumValue) {
++ return inputStream.readEnumValue<int32_t>(enumValue);
++}
++
++inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_Availability_e& enumValue) {
++ return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
++}
++
++struct am_Availability_eComparator {
++ inline bool operator()(const am_Availability_e& lhs, const am_Availability_e& rhs) const {
++ return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
++ }
++};
++
++inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_HotSink_e& enumValue) {
++ return inputStream.readEnumValue<int32_t>(enumValue);
++}
++
++inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_HotSink_e& enumValue) {
++ return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
++}
++
++struct am_HotSink_eComparator {
++ inline bool operator()(const am_HotSink_e& lhs, const am_HotSink_e& rhs) const {
++ return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
++ }
++};
++
++inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_ConnectionState_e& enumValue) {
++ return inputStream.readEnumValue<int32_t>(enumValue);
++}
++
++inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_ConnectionState_e& enumValue) {
++ return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
++}
++
++struct am_ConnectionState_eComparator {
++ inline bool operator()(const am_ConnectionState_e& lhs, const am_ConnectionState_e& rhs) const {
++ return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
++ }
++};
++
++inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_DomainState_e& enumValue) {
++ return inputStream.readEnumValue<int32_t>(enumValue);
++}
++
++inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_DomainState_e& enumValue) {
++ return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
++}
++
++struct am_DomainState_eComparator {
++ inline bool operator()(const am_DomainState_e& lhs, const am_DomainState_e& rhs) const {
++ return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
++ }
++};
++
++inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_EarlyDataType_e& enumValue) {
++ return inputStream.readEnumValue<int32_t>(enumValue);
++}
++
++inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_EarlyDataType_e& enumValue) {
++ return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
++}
++
++struct am_EarlyDataType_eComparator {
++ inline bool operator()(const am_EarlyDataType_e& lhs, const am_EarlyDataType_e& rhs) const {
++ return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
++ }
++};
++
++inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_Error_e& enumValue) {
++ return inputStream.readEnumValue<int32_t>(enumValue);
++}
++
++inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_Error_e& enumValue) {
++ return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
++}
++
++struct am_Error_eComparator {
++ inline bool operator()(const am_Error_e& lhs, const am_Error_e& rhs) const {
++ return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
++ }
++};
++
++inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_MuteState_e& enumValue) {
++ return inputStream.readEnumValue<int32_t>(enumValue);
++}
++
++inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_MuteState_e& enumValue) {
++ return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
++}
++
++struct am_MuteState_eComparator {
++ inline bool operator()(const am_MuteState_e& lhs, const am_MuteState_e& rhs) const {
++ return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
++ }
++};
++
++inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_InterruptState_e& enumValue) {
++ return inputStream.readEnumValue<int32_t>(enumValue);
++}
++
++inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_InterruptState_e& enumValue) {
++ return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
++}
++
++struct am_InterruptState_eComparator {
++ inline bool operator()(const am_InterruptState_e& lhs, const am_InterruptState_e& rhs) const {
++ return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
++ }
++};
++
++inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_VolumeType_e& enumValue) {
++ return inputStream.readEnumValue<int32_t>(enumValue);
++}
++
++inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_VolumeType_e& enumValue) {
++ return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
++}
++
++struct am_VolumeType_eComparator {
++ inline bool operator()(const am_VolumeType_e& lhs, const am_VolumeType_e& rhs) const {
++ return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
++ }
++};
++
++inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_NotificationStatus_e& enumValue) {
++ return inputStream.readEnumValue<int32_t>(enumValue);
++}
++
++inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_NotificationStatus_e& enumValue) {
++ return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
++}
++
++struct am_NotificationStatus_eComparator {
++ inline bool operator()(const am_NotificationStatus_e& lhs, const am_NotificationStatus_e& rhs) const {
++ return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
++ }
++};
++
++inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_Handle_e& enumValue) {
++ return inputStream.readEnumValue<int32_t>(enumValue);
++}
++
++inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_Handle_e& enumValue) {
++ return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
++}
++
++struct am_Handle_eComparator {
++ inline bool operator()(const am_Handle_e& lhs, const am_Handle_e& rhs) const {
++ return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
++ }
++};
++
++inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_SourceState_e& enumValue) {
++ return inputStream.readEnumValue<int32_t>(enumValue);
++}
++
++inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_SourceState_e& enumValue) {
++ return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
++}
++
++struct am_SourceState_eComparator {
++ inline bool operator()(const am_SourceState_e& lhs, const am_SourceState_e& rhs) const {
++ return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
++ }
++};
++
++inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_RoutingReady_e& enumValue) {
++ return inputStream.readEnumValue<int32_t>(enumValue);
++}
++
++inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_RoutingReady_e& enumValue) {
++ return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
++}
++
++struct am_RoutingReady_eComparator {
++ inline bool operator()(const am_RoutingReady_e& lhs, const am_RoutingReady_e& rhs) const {
++ return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
++ }
++};
++
++bool operator==(const am_Route_s& lhs, const am_Route_s& rhs);
++inline bool operator!=(const am_Route_s& lhs, const am_Route_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_Availability_s& lhs, const am_Availability_s& rhs);
++inline bool operator!=(const am_Availability_s& lhs, const am_Availability_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_ClassProperty_s& lhs, const am_ClassProperty_s& rhs);
++inline bool operator!=(const am_ClassProperty_s& lhs, const am_ClassProperty_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_Crossfader_s& lhs, const am_Crossfader_s& rhs);
++inline bool operator!=(const am_Crossfader_s& lhs, const am_Crossfader_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_Gateway_s& lhs, const am_Gateway_s& rhs);
++inline bool operator!=(const am_Gateway_s& lhs, const am_Gateway_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_Converter_s& lhs, const am_Converter_s& rhs);
++inline bool operator!=(const am_Converter_s& lhs, const am_Converter_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_RoutingElement_s& lhs, const am_RoutingElement_s& rhs);
++inline bool operator!=(const am_RoutingElement_s& lhs, const am_RoutingElement_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_SoundProperty_s& lhs, const am_SoundProperty_s& rhs);
++inline bool operator!=(const am_SoundProperty_s& lhs, const am_SoundProperty_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_SystemProperty_s& lhs, const am_SystemProperty_s& rhs);
++inline bool operator!=(const am_SystemProperty_s& lhs, const am_SystemProperty_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_SinkClass_s& lhs, const am_SinkClass_s& rhs);
++inline bool operator!=(const am_SinkClass_s& lhs, const am_SinkClass_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_SourceClass_s& lhs, const am_SourceClass_s& rhs);
++inline bool operator!=(const am_SourceClass_s& lhs, const am_SourceClass_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_SourceType_s& lhs, const am_SourceType_s& rhs);
++inline bool operator!=(const am_SourceType_s& lhs, const am_SourceType_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_SinkType_s& lhs, const am_SinkType_s& rhs);
++inline bool operator!=(const am_SinkType_s& lhs, const am_SinkType_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_Handle_s& lhs, const am_Handle_s& rhs);
++inline bool operator!=(const am_Handle_s& lhs, const am_Handle_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_MainSoundProperty_s& lhs, const am_MainSoundProperty_s& rhs);
++inline bool operator!=(const am_MainSoundProperty_s& lhs, const am_MainSoundProperty_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_MainConnectionType_s& lhs, const am_MainConnectionType_s& rhs);
++inline bool operator!=(const am_MainConnectionType_s& lhs, const am_MainConnectionType_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_MainConnection_s& lhs, const am_MainConnection_s& rhs);
++inline bool operator!=(const am_MainConnection_s& lhs, const am_MainConnection_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_NotificationPayload_s& lhs, const am_NotificationPayload_s& rhs);
++inline bool operator!=(const am_NotificationPayload_s& lhs, const am_NotificationPayload_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_NotificationConfiguration_s& lhs, const am_NotificationConfiguration_s& rhs);
++inline bool operator!=(const am_NotificationConfiguration_s& lhs, const am_NotificationConfiguration_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_Sink_s& lhs, const am_Sink_s& rhs);
++inline bool operator!=(const am_Sink_s& lhs, const am_Sink_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_Source_s& lhs, const am_Source_s& rhs);
++inline bool operator!=(const am_Source_s& lhs, const am_Source_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_Domain_s& lhs, const am_Domain_s& rhs);
++inline bool operator!=(const am_Domain_s& lhs, const am_Domain_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_EarlyData_s& lhs, const am_EarlyData_s& rhs);
++inline bool operator!=(const am_EarlyData_s& lhs, const am_EarlyData_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_Connection_s& lhs, const am_Connection_s& rhs);
++inline bool operator!=(const am_Connection_s& lhs, const am_Connection_s& rhs) {
++ return !(lhs == rhs);
++}
++bool operator==(const am_Volumes_s& lhs, const am_Volumes_s& rhs);
++inline bool operator!=(const am_Volumes_s& lhs, const am_Volumes_s& rhs) {
++ return !(lhs == rhs);
++}
++
++
++static inline const char* getTypeCollectionName() {
++ static const char* typeCollectionName = "org.genivi.am";
++ return typeCollectionName;
++}
++
++inline CommonAPI::Version getTypeCollectionVersion() {
++ return CommonAPI::Version(2, 0);
++}
++
++} // namespace am
++
++} // namespace genivi
++} // namespace org
++
++namespace CommonAPI {
++
++ template<>
++ struct BasicTypeWriter<org::genivi::am::am_Availability_e> {
++ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
++ typeStream.writeInt32EnumType();
++ }
++ };
++
++ template<>
++ struct InputStreamVectorHelper<org::genivi::am::am_Availability_e> {
++ static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_Availability_e>& vectorValue) {
++ inputStream.beginReadInt32EnumVector();
++ }
++ };
++
++ template <>
++ struct OutputStreamVectorHelper<org::genivi::am::am_Availability_e> {
++ static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_Availability_e>& vectorValue) {
++ outputStream.beginWriteInt32EnumVector(vectorValue.size());
++ }
++ };
++ template<>
++ struct BasicTypeWriter<org::genivi::am::am_HotSink_e> {
++ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
++ typeStream.writeInt32EnumType();
++ }
++ };
++
++ template<>
++ struct InputStreamVectorHelper<org::genivi::am::am_HotSink_e> {
++ static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_HotSink_e>& vectorValue) {
++ inputStream.beginReadInt32EnumVector();
++ }
++ };
++
++ template <>
++ struct OutputStreamVectorHelper<org::genivi::am::am_HotSink_e> {
++ static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_HotSink_e>& vectorValue) {
++ outputStream.beginWriteInt32EnumVector(vectorValue.size());
++ }
++ };
++ template<>
++ struct BasicTypeWriter<org::genivi::am::am_ConnectionState_e> {
++ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
++ typeStream.writeInt32EnumType();
++ }
++ };
++
++ template<>
++ struct InputStreamVectorHelper<org::genivi::am::am_ConnectionState_e> {
++ static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_ConnectionState_e>& vectorValue) {
++ inputStream.beginReadInt32EnumVector();
++ }
++ };
++
++ template <>
++ struct OutputStreamVectorHelper<org::genivi::am::am_ConnectionState_e> {
++ static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_ConnectionState_e>& vectorValue) {
++ outputStream.beginWriteInt32EnumVector(vectorValue.size());
++ }
++ };
++ template<>
++ struct BasicTypeWriter<org::genivi::am::am_DomainState_e> {
++ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
++ typeStream.writeInt32EnumType();
++ }
++ };
++
++ template<>
++ struct InputStreamVectorHelper<org::genivi::am::am_DomainState_e> {
++ static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_DomainState_e>& vectorValue) {
++ inputStream.beginReadInt32EnumVector();
++ }
++ };
++
++ template <>
++ struct OutputStreamVectorHelper<org::genivi::am::am_DomainState_e> {
++ static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_DomainState_e>& vectorValue) {
++ outputStream.beginWriteInt32EnumVector(vectorValue.size());
++ }
++ };
++ template<>
++ struct BasicTypeWriter<org::genivi::am::am_EarlyDataType_e> {
++ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
++ typeStream.writeInt32EnumType();
++ }
++ };
++
++ template<>
++ struct InputStreamVectorHelper<org::genivi::am::am_EarlyDataType_e> {
++ static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_EarlyDataType_e>& vectorValue) {
++ inputStream.beginReadInt32EnumVector();
++ }
++ };
++
++ template <>
++ struct OutputStreamVectorHelper<org::genivi::am::am_EarlyDataType_e> {
++ static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_EarlyDataType_e>& vectorValue) {
++ outputStream.beginWriteInt32EnumVector(vectorValue.size());
++ }
++ };
++ template<>
++ struct BasicTypeWriter<org::genivi::am::am_Error_e> {
++ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
++ typeStream.writeInt32EnumType();
++ }
++ };
++
++ template<>
++ struct InputStreamVectorHelper<org::genivi::am::am_Error_e> {
++ static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_Error_e>& vectorValue) {
++ inputStream.beginReadInt32EnumVector();
++ }
++ };
++
++ template <>
++ struct OutputStreamVectorHelper<org::genivi::am::am_Error_e> {
++ static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_Error_e>& vectorValue) {
++ outputStream.beginWriteInt32EnumVector(vectorValue.size());
++ }
++ };
++ template<>
++ struct BasicTypeWriter<org::genivi::am::am_MuteState_e> {
++ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
++ typeStream.writeInt32EnumType();
++ }
++ };
++
++ template<>
++ struct InputStreamVectorHelper<org::genivi::am::am_MuteState_e> {
++ static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_MuteState_e>& vectorValue) {
++ inputStream.beginReadInt32EnumVector();
++ }
++ };
++
++ template <>
++ struct OutputStreamVectorHelper<org::genivi::am::am_MuteState_e> {
++ static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_MuteState_e>& vectorValue) {
++ outputStream.beginWriteInt32EnumVector(vectorValue.size());
++ }
++ };
++ template<>
++ struct BasicTypeWriter<org::genivi::am::am_InterruptState_e> {
++ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
++ typeStream.writeInt32EnumType();
++ }
++ };
++
++ template<>
++ struct InputStreamVectorHelper<org::genivi::am::am_InterruptState_e> {
++ static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_InterruptState_e>& vectorValue) {
++ inputStream.beginReadInt32EnumVector();
++ }
++ };
++
++ template <>
++ struct OutputStreamVectorHelper<org::genivi::am::am_InterruptState_e> {
++ static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_InterruptState_e>& vectorValue) {
++ outputStream.beginWriteInt32EnumVector(vectorValue.size());
++ }
++ };
++ template<>
++ struct BasicTypeWriter<org::genivi::am::am_VolumeType_e> {
++ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
++ typeStream.writeInt32EnumType();
++ }
++ };
++
++ template<>
++ struct InputStreamVectorHelper<org::genivi::am::am_VolumeType_e> {
++ static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_VolumeType_e>& vectorValue) {
++ inputStream.beginReadInt32EnumVector();
++ }
++ };
++
++ template <>
++ struct OutputStreamVectorHelper<org::genivi::am::am_VolumeType_e> {
++ static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_VolumeType_e>& vectorValue) {
++ outputStream.beginWriteInt32EnumVector(vectorValue.size());
++ }
++ };
++ template<>
++ struct BasicTypeWriter<org::genivi::am::am_NotificationStatus_e> {
++ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
++ typeStream.writeInt32EnumType();
++ }
++ };
++
++ template<>
++ struct InputStreamVectorHelper<org::genivi::am::am_NotificationStatus_e> {
++ static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_NotificationStatus_e>& vectorValue) {
++ inputStream.beginReadInt32EnumVector();
++ }
++ };
++
++ template <>
++ struct OutputStreamVectorHelper<org::genivi::am::am_NotificationStatus_e> {
++ static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_NotificationStatus_e>& vectorValue) {
++ outputStream.beginWriteInt32EnumVector(vectorValue.size());
++ }
++ };
++ template<>
++ struct BasicTypeWriter<org::genivi::am::am_Handle_e> {
++ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
++ typeStream.writeInt32EnumType();
++ }
++ };
++
++ template<>
++ struct InputStreamVectorHelper<org::genivi::am::am_Handle_e> {
++ static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_Handle_e>& vectorValue) {
++ inputStream.beginReadInt32EnumVector();
++ }
++ };
++
++ template <>
++ struct OutputStreamVectorHelper<org::genivi::am::am_Handle_e> {
++ static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_Handle_e>& vectorValue) {
++ outputStream.beginWriteInt32EnumVector(vectorValue.size());
++ }
++ };
++ template<>
++ struct BasicTypeWriter<org::genivi::am::am_SourceState_e> {
++ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
++ typeStream.writeInt32EnumType();
++ }
++ };
++
++ template<>
++ struct InputStreamVectorHelper<org::genivi::am::am_SourceState_e> {
++ static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_SourceState_e>& vectorValue) {
++ inputStream.beginReadInt32EnumVector();
++ }
++ };
++
++ template <>
++ struct OutputStreamVectorHelper<org::genivi::am::am_SourceState_e> {
++ static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_SourceState_e>& vectorValue) {
++ outputStream.beginWriteInt32EnumVector(vectorValue.size());
++ }
++ };
++ template<>
++ struct BasicTypeWriter<org::genivi::am::am_RoutingReady_e> {
++ inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
++ typeStream.writeInt32EnumType();
++ }
++ };
++
++ template<>
++ struct InputStreamVectorHelper<org::genivi::am::am_RoutingReady_e> {
++ static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_RoutingReady_e>& vectorValue) {
++ inputStream.beginReadInt32EnumVector();
++ }
++ };
++
++ template <>
++ struct OutputStreamVectorHelper<org::genivi::am::am_RoutingReady_e> {
++ static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_RoutingReady_e>& vectorValue) {
++ outputStream.beginWriteInt32EnumVector(vectorValue.size());
++ }
++ };
++
++}
++
++
++namespace std {
++ //Hash for am_Availability_e
++ template<>
++ struct hash<org::genivi::am::am_Availability_e> {
++ inline size_t operator()(const org::genivi::am::am_Availability_e& am_Availability_e) const {
++ return static_cast<int32_t>(am_Availability_e);
++ }
++ };
++ //Hash for am_HotSink_e
++ template<>
++ struct hash<org::genivi::am::am_HotSink_e> {
++ inline size_t operator()(const org::genivi::am::am_HotSink_e& am_HotSink_e) const {
++ return static_cast<int32_t>(am_HotSink_e);
++ }
++ };
++ //Hash for am_ConnectionState_e
++ template<>
++ struct hash<org::genivi::am::am_ConnectionState_e> {
++ inline size_t operator()(const org::genivi::am::am_ConnectionState_e& am_ConnectionState_e) const {
++ return static_cast<int32_t>(am_ConnectionState_e);
++ }
++ };
++ //Hash for am_DomainState_e
++ template<>
++ struct hash<org::genivi::am::am_DomainState_e> {
++ inline size_t operator()(const org::genivi::am::am_DomainState_e& am_DomainState_e) const {
++ return static_cast<int32_t>(am_DomainState_e);
++ }
++ };
++ //Hash for am_EarlyDataType_e
++ template<>
++ struct hash<org::genivi::am::am_EarlyDataType_e> {
++ inline size_t operator()(const org::genivi::am::am_EarlyDataType_e& am_EarlyDataType_e) const {
++ return static_cast<int32_t>(am_EarlyDataType_e);
++ }
++ };
++ //Hash for am_Error_e
++ template<>
++ struct hash<org::genivi::am::am_Error_e> {
++ inline size_t operator()(const org::genivi::am::am_Error_e& am_Error_e) const {
++ return static_cast<int32_t>(am_Error_e);
++ }
++ };
++ //Hash for am_MuteState_e
++ template<>
++ struct hash<org::genivi::am::am_MuteState_e> {
++ inline size_t operator()(const org::genivi::am::am_MuteState_e& am_MuteState_e) const {
++ return static_cast<int32_t>(am_MuteState_e);
++ }
++ };
++ //Hash for am_InterruptState_e
++ template<>
++ struct hash<org::genivi::am::am_InterruptState_e> {
++ inline size_t operator()(const org::genivi::am::am_InterruptState_e& am_InterruptState_e) const {
++ return static_cast<int32_t>(am_InterruptState_e);
++ }
++ };
++ //Hash for am_VolumeType_e
++ template<>
++ struct hash<org::genivi::am::am_VolumeType_e> {
++ inline size_t operator()(const org::genivi::am::am_VolumeType_e& am_VolumeType_e) const {
++ return static_cast<int32_t>(am_VolumeType_e);
++ }
++ };
++ //Hash for am_NotificationStatus_e
++ template<>
++ struct hash<org::genivi::am::am_NotificationStatus_e> {
++ inline size_t operator()(const org::genivi::am::am_NotificationStatus_e& am_NotificationStatus_e) const {
++ return static_cast<int32_t>(am_NotificationStatus_e);
++ }
++ };
++ //Hash for am_Handle_e
++ template<>
++ struct hash<org::genivi::am::am_Handle_e> {
++ inline size_t operator()(const org::genivi::am::am_Handle_e& am_Handle_e) const {
++ return static_cast<int32_t>(am_Handle_e);
++ }
++ };
++ //Hash for am_SourceState_e
++ template<>
++ struct hash<org::genivi::am::am_SourceState_e> {
++ inline size_t operator()(const org::genivi::am::am_SourceState_e& am_SourceState_e) const {
++ return static_cast<int32_t>(am_SourceState_e);
++ }
++ };
++ //Hash for am_RoutingReady_e
++ template<>
++ struct hash<org::genivi::am::am_RoutingReady_e> {
++ inline size_t operator()(const org::genivi::am::am_RoutingReady_e& am_RoutingReady_e) const {
++ return static_cast<int32_t>(am_RoutingReady_e);
++ }
++ };
++}
++
++#endif // ORG_GENIVI_am_H_
+diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControl.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControl.h
+new file mode 100644
+index 0000000..106e5ad
+--- /dev/null
++++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControl.h
+@@ -0,0 +1,67 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * The interface towards the Controlling Instance (e.g HMI). It handles the
++ * communication towards the HMI and other system components who need to interact
++ * with the audiomanagement.
++There are two rules that have to be kept in mind
++ * when implementing against this interface:
++ * @author Christian Mueller
++ */
++#ifndef ORG_GENIVI_AM_Command_Control_H_
++#define ORG_GENIVI_AM_Command_Control_H_
++
++
++
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <CommonAPI/types.h>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++namespace am {
++
++class CommandControl {
++ public:
++ virtual ~CommandControl() { }
++
++ static inline const char* getInterfaceId();
++ static inline CommonAPI::Version getInterfaceVersion();
++};
++
++const char* CommandControl::getInterfaceId() {
++ static const char* interfaceId = "org.genivi.am.CommandControl";
++ return interfaceId;
++}
++
++CommonAPI::Version CommandControl::getInterfaceVersion() {
++ return CommonAPI::Version(2, 0);
++}
++
++
++} // namespace am
++} // namespace genivi
++} // namespace org
++
++namespace CommonAPI {
++
++}
++
++
++namespace std {
++ //hashes for types
++
++ //hashes for error types
++}
++
++#endif // ORG_GENIVI_AM_Command_Control_H_
+diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusProxy.cpp b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusProxy.cpp
+new file mode 100644
+index 0000000..bf46af3
+--- /dev/null
++++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusProxy.cpp
+@@ -0,0 +1,651 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * The interface towards the Controlling Instance (e.g HMI). It handles the
++ * communication towards the HMI and other system components who need to interact
++ * with the audiomanagement.
++There are two rules that have to be kept in mind
++ * when implementing against this interface:
++ * @author Christian Mueller
++ */
++#include "CommandControlDBusProxy.h"
++
++namespace org {
++namespace genivi {
++namespace am {
++
++std::shared_ptr<CommonAPI::DBus::DBusProxy> createCommandControlDBusProxy(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& interfaceName,
++ const std::string& busName,
++ const std::string& objectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyConnection) {
++ return std::make_shared<CommandControlDBusProxy>(factory, commonApiAddress, interfaceName, busName, objectPath, dbusProxyConnection);
++}
++
++INITIALIZER(registerCommandControlDBusProxy) {
++ CommonAPI::DBus::DBusFactory::registerProxyFactoryMethod(CommandControl::getInterfaceId(),
++ &createCommandControlDBusProxy);
++}
++
++CommandControlDBusProxy::CommandControlDBusProxy(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& interfaceName,
++ const std::string& busName,
++ const std::string& objectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyconnection):
++ CommonAPI::DBus::DBusProxy(factory, commonApiAddress, interfaceName, busName, objectPath, dbusProxyconnection)
++, newMainConnection_(*this, "newMainConnection", "(qqqni)"),
++ removedMainConnection_(*this, "removedMainConnection", "q"),
++ newSink_(*this, "newSink", "(qs(iq)niq)"),
++ removedSink_(*this, "removedSink", "q"),
++ newSource_(*this, "newSource", "(qs(iq)q)"),
++ removedSource_(*this, "removedSource", "q"),
++ numberOfSinkClassesChanged_(*this, "numberOfSinkClassesChanged", ""),
++ numberOfSourceClassesChanged_(*this, "numberOfSourceClassesChanged", ""),
++ mainConnectionStateChanged_(*this, "mainConnectionStateChanged", "qi"),
++ mainSinkSoundPropertyChanged_(*this, "mainSinkSoundPropertyChanged", "q(qn)"),
++ mainSourceSoundPropertyChanged_(*this, "mainSourceSoundPropertyChanged", "q(qn)"),
++ sinkAvailabilityChanged_(*this, "sinkAvailabilityChanged", "q(iq)"),
++ sourceAvailabilityChanged_(*this, "sourceAvailabilityChanged", "q(iq)"),
++ volumeChanged_(*this, "volumeChanged", "qn"),
++ sinkMuteStateChanged_(*this, "sinkMuteStateChanged", "qi"),
++ systemPropertyChanged_(*this, "systemPropertyChanged", "(qn)"),
++ timingInformationChanged_(*this, "timingInformationChanged", "qn"),
++ sinkUpdated_(*this, "sinkUpdated", "qqa(qn)"),
++ sourceUpdated_(*this, "sourceUpdated", "qqa(qn)"),
++ sinkNotification_(*this, "sinkNotification", "q(qn)"),
++ sourceNotification_(*this, "sourceNotification", "q(qn)"),
++ mainSinkNotificationConfigurationChanged_(*this, "mainSinkNotificationConfigurationChanged", "q(qin)"),
++ mainSourceNotificationConfigurationChanged_(*this, "mainSourceNotificationConfigurationChanged", "q(qin)")
++ {
++ }
++
++
++CommandControlDBusProxy::NewMainConnectionEvent& CommandControlDBusProxy::getNewMainConnectionEvent() {
++ return newMainConnection_;
++}
++CommandControlDBusProxy::RemovedMainConnectionEvent& CommandControlDBusProxy::getRemovedMainConnectionEvent() {
++ return removedMainConnection_;
++}
++CommandControlDBusProxy::NewSinkEvent& CommandControlDBusProxy::getNewSinkEvent() {
++ return newSink_;
++}
++CommandControlDBusProxy::RemovedSinkEvent& CommandControlDBusProxy::getRemovedSinkEvent() {
++ return removedSink_;
++}
++CommandControlDBusProxy::NewSourceEvent& CommandControlDBusProxy::getNewSourceEvent() {
++ return newSource_;
++}
++CommandControlDBusProxy::RemovedSourceEvent& CommandControlDBusProxy::getRemovedSourceEvent() {
++ return removedSource_;
++}
++CommandControlDBusProxy::NumberOfSinkClassesChangedEvent& CommandControlDBusProxy::getNumberOfSinkClassesChangedEvent() {
++ return numberOfSinkClassesChanged_;
++}
++CommandControlDBusProxy::NumberOfSourceClassesChangedEvent& CommandControlDBusProxy::getNumberOfSourceClassesChangedEvent() {
++ return numberOfSourceClassesChanged_;
++}
++CommandControlDBusProxy::MainConnectionStateChangedEvent& CommandControlDBusProxy::getMainConnectionStateChangedEvent() {
++ return mainConnectionStateChanged_;
++}
++CommandControlDBusProxy::MainSinkSoundPropertyChangedEvent& CommandControlDBusProxy::getMainSinkSoundPropertyChangedEvent() {
++ return mainSinkSoundPropertyChanged_;
++}
++CommandControlDBusProxy::MainSourceSoundPropertyChangedEvent& CommandControlDBusProxy::getMainSourceSoundPropertyChangedEvent() {
++ return mainSourceSoundPropertyChanged_;
++}
++CommandControlDBusProxy::SinkAvailabilityChangedEvent& CommandControlDBusProxy::getSinkAvailabilityChangedEvent() {
++ return sinkAvailabilityChanged_;
++}
++CommandControlDBusProxy::SourceAvailabilityChangedEvent& CommandControlDBusProxy::getSourceAvailabilityChangedEvent() {
++ return sourceAvailabilityChanged_;
++}
++CommandControlDBusProxy::VolumeChangedEvent& CommandControlDBusProxy::getVolumeChangedEvent() {
++ return volumeChanged_;
++}
++CommandControlDBusProxy::SinkMuteStateChangedEvent& CommandControlDBusProxy::getSinkMuteStateChangedEvent() {
++ return sinkMuteStateChanged_;
++}
++CommandControlDBusProxy::SystemPropertyChangedEvent& CommandControlDBusProxy::getSystemPropertyChangedEvent() {
++ return systemPropertyChanged_;
++}
++CommandControlDBusProxy::TimingInformationChangedEvent& CommandControlDBusProxy::getTimingInformationChangedEvent() {
++ return timingInformationChanged_;
++}
++CommandControlDBusProxy::SinkUpdatedEvent& CommandControlDBusProxy::getSinkUpdatedEvent() {
++ return sinkUpdated_;
++}
++CommandControlDBusProxy::SourceUpdatedEvent& CommandControlDBusProxy::getSourceUpdatedEvent() {
++ return sourceUpdated_;
++}
++CommandControlDBusProxy::SinkNotificationEvent& CommandControlDBusProxy::getSinkNotificationEvent() {
++ return sinkNotification_;
++}
++CommandControlDBusProxy::SourceNotificationEvent& CommandControlDBusProxy::getSourceNotificationEvent() {
++ return sourceNotification_;
++}
++CommandControlDBusProxy::MainSinkNotificationConfigurationChangedEvent& CommandControlDBusProxy::getMainSinkNotificationConfigurationChangedEvent() {
++ return mainSinkNotificationConfigurationChanged_;
++}
++CommandControlDBusProxy::MainSourceNotificationConfigurationChangedEvent& CommandControlDBusProxy::getMainSourceNotificationConfigurationChangedEvent() {
++ return mainSourceNotificationConfigurationChanged_;
++}
++
++/**
++ * connects a source to sink
++(at)return E_OK on success, E_NOT_POSSIBLE on
++ * failure, E_ALREADY_EXISTS if the connection does already exists
++ */
++void CommandControlDBusProxy::connect(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_mainConnectionID_t& mainConnectionID, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_sinkID_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t, am_Error_e> >::callMethodWithReply(
++ *this,
++ "connect",
++ "qq",
++ sourceID, sinkID,
++ callStatus
++ , mainConnectionID, error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::connectAsync(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, ConnectAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_sinkID_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t, am_Error_e> >::callMethodAsync(
++ *this,
++ "connect",
++ "qq",
++ sourceID, sinkID,
++ std::move(callback));
++}
++/**
++ * disconnects a mainConnection
++(at)return E_OK on successes, E_NON_EXISTENT if
++ * the connection does not exist, E_NOT_POSSIBLE on error.
++ */
++void CommandControlDBusProxy::disconnect(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
++ *this,
++ "disconnect",
++ "q",
++ mainConnectionID,
++ callStatus
++ , error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::disconnectAsync(const am_mainConnectionID_t& mainConnectionID, DisconnectAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
++ *this,
++ "disconnect",
++ "q",
++ mainConnectionID,
++ std::move(callback));
++}
++/**
++ * sets the volume for a sink
++(at)return E_OK on success, E_UNKOWN on error,
++ * E_OUT_OF_RANGE in case the value is out of range
++ */
++void CommandControlDBusProxy::setVolume(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_mainVolume_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
++ *this,
++ "setVolume",
++ "qn",
++ sinkID, volume,
++ callStatus
++ , error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setVolumeAsync(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, SetVolumeAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_mainVolume_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
++ *this,
++ "setVolume",
++ "qn",
++ sinkID, volume,
++ std::move(callback));
++}
++/**
++ * This function is used to increment or decrement the current volume for a
++ * sink.
++(at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the
++ * value is not in the given volume range.
++ */
++void CommandControlDBusProxy::volumeStep(const am_sinkID_t& sinkID, const int16_t& volStep, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, int16_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
++ *this,
++ "volumeStep",
++ "qn",
++ sinkID, volStep,
++ callStatus
++ , error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::volumeStepAsync(const am_sinkID_t& sinkID, const int16_t& volStep, VolumeStepAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, int16_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
++ *this,
++ "volumeStep",
++ "qn",
++ sinkID, volStep,
++ std::move(callback));
++}
++/**
++ * sets the mute state of a sink
++(at)return E_OK on success, E_UNKNOWN on error.
++ * If the mute state is already the desired one, the Daemon will return E_OK.
++ */
++void CommandControlDBusProxy::setSinkMuteState(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MuteState_e>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
++ *this,
++ "setSinkMuteState",
++ "qi",
++ sinkID, muteState,
++ callStatus
++ , error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setSinkMuteStateAsync(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, SetSinkMuteStateAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MuteState_e>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
++ *this,
++ "setSinkMuteState",
++ "qi",
++ sinkID, muteState,
++ std::move(callback));
++}
++/**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++(at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++void CommandControlDBusProxy::setMainSinkSoundProperty(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MainSoundProperty_s>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
++ *this,
++ "setMainSinkSoundProperty",
++ "q(qn)",
++ sinkID, soundProperty,
++ callStatus
++ , error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setMainSinkSoundPropertyAsync(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, SetMainSinkSoundPropertyAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MainSoundProperty_s>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
++ *this,
++ "setMainSinkSoundProperty",
++ "q(qn)",
++ sinkID, soundProperty,
++ std::move(callback));
++}
++/**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++(at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++void CommandControlDBusProxy::setMainSourceSoundProperty(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_MainSoundProperty_s>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
++ *this,
++ "setMainSourceSoundProperty",
++ "q(qn)",
++ sourceID, soundProperty,
++ callStatus
++ , error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setMainSourceSoundPropertyAsync(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, SetMainSourceSoundPropertyAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_MainSoundProperty_s>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
++ *this,
++ "setMainSourceSoundProperty",
++ "q(qn)",
++ sourceID, soundProperty,
++ std::move(callback));
++}
++/**
++ * is used to set a specific system property.
++(at)return E_OK on success,
++ * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error
++ */
++void CommandControlDBusProxy::setSystemProperty(const am_SystemProperty_s& property, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_SystemProperty_s>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
++ *this,
++ "setSystemProperty",
++ "(qn)",
++ property,
++ callStatus
++ , error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setSystemPropertyAsync(const am_SystemProperty_s& property, SetSystemPropertyAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_SystemProperty_s>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
++ *this,
++ "setSystemProperty",
++ "(qn)",
++ property,
++ std::move(callback));
++}
++/**
++ * returns the actual list of MainConnections
++(at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++void CommandControlDBusProxy::getListMainConnections(CommonAPI::CallStatus& callStatus, am_MainConnection_L& listConnections, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<am_MainConnection_L, am_Error_e> >::callMethodWithReply(
++ *this,
++ "getListMainConnections",
++ "",
++ callStatus
++ , listConnections, error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainConnectionsAsync(GetListMainConnectionsAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<am_MainConnection_L, am_Error_e> >::callMethodAsync(
++ *this,
++ "getListMainConnections",
++ "",
++ std::move(callback));
++}
++/**
++ * returns the actual list of Sinks
++(at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++void CommandControlDBusProxy::getListMainSinks(CommonAPI::CallStatus& callStatus, am_SinkType_L& listMainSinks, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<am_SinkType_L, am_Error_e> >::callMethodWithReply(
++ *this,
++ "getListMainSinks",
++ "",
++ callStatus
++ , listMainSinks, error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSinksAsync(GetListMainSinksAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<am_SinkType_L, am_Error_e> >::callMethodAsync(
++ *this,
++ "getListMainSinks",
++ "",
++ std::move(callback));
++}
++/**
++ * returns the actual list of Sources
++(at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++void CommandControlDBusProxy::getListMainSources(CommonAPI::CallStatus& callStatus, am_SourceType_L& listMainSources, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<am_SourceType_L, am_Error_e> >::callMethodWithReply(
++ *this,
++ "getListMainSources",
++ "",
++ callStatus
++ , listMainSources, error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSourcesAsync(GetListMainSourcesAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<am_SourceType_L, am_Error_e> >::callMethodAsync(
++ *this,
++ "getListMainSources",
++ "",
++ std::move(callback));
++}
++/**
++ * This is used to retrieve all source sound properties related to a source.
++ * Returns a vector of the sound properties and values as pair
++(at)return E_OK on
++ * success, E_DATABASE_ERROR on error
++ */
++void CommandControlDBusProxy::getListMainSinkSoundProperties(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_MainSoundProperty_L, am_Error_e> >::callMethodWithReply(
++ *this,
++ "getListMainSinkSoundProperties",
++ "q",
++ sinkID,
++ callStatus
++ , listSoundProperties, error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSinkSoundPropertiesAsync(const am_sinkID_t& sinkID, GetListMainSinkSoundPropertiesAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_MainSoundProperty_L, am_Error_e> >::callMethodAsync(
++ *this,
++ "getListMainSinkSoundProperties",
++ "q",
++ sinkID,
++ std::move(callback));
++}
++/**
++ * This is used to retrieve all source sound properties related to a
++ * source.
++(at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++void CommandControlDBusProxy::getListMainSourceSoundProperties(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_MainSoundProperty_L, am_Error_e> >::callMethodWithReply(
++ *this,
++ "getListMainSourceSoundProperties",
++ "q",
++ sourceID,
++ callStatus
++ , listSourceProperties, error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSourceSoundPropertiesAsync(const am_sourceID_t& sourceID, GetListMainSourceSoundPropertiesAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_MainSoundProperty_L, am_Error_e> >::callMethodAsync(
++ *this,
++ "getListMainSourceSoundProperties",
++ "q",
++ sourceID,
++ std::move(callback));
++}
++/**
++ * This is used to retrieve SourceClass Information of all source classes
++ *
++(at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++void CommandControlDBusProxy::getListSourceClasses(CommonAPI::CallStatus& callStatus, am_SourceClass_L& listSourceClasses, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<am_SourceClass_L, am_Error_e> >::callMethodWithReply(
++ *this,
++ "getListSourceClasses",
++ "",
++ callStatus
++ , listSourceClasses, error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListSourceClassesAsync(GetListSourceClassesAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<am_SourceClass_L, am_Error_e> >::callMethodAsync(
++ *this,
++ "getListSourceClasses",
++ "",
++ std::move(callback));
++}
++/**
++ * This is used to retrieve SinkClass Information of all sink classes
++(at)return
++ * E_OK on success, E_DATABASE_ERROR on error
++ */
++void CommandControlDBusProxy::getListSinkClasses(CommonAPI::CallStatus& callStatus, am_SinkClass_L& listSinkClasses, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<am_SinkClass_L, am_Error_e> >::callMethodWithReply(
++ *this,
++ "getListSinkClasses",
++ "",
++ callStatus
++ , listSinkClasses, error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListSinkClassesAsync(GetListSinkClassesAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<am_SinkClass_L, am_Error_e> >::callMethodAsync(
++ *this,
++ "getListSinkClasses",
++ "",
++ std::move(callback));
++}
++/**
++ * Retrieves a complete list of all systemProperties.
++(at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++void CommandControlDBusProxy::getListSystemProperties(CommonAPI::CallStatus& callStatus, am_SystemProperty_L& listSystemProperties, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<am_SystemProperty_L, am_Error_e> >::callMethodWithReply(
++ *this,
++ "getListSystemProperties",
++ "",
++ callStatus
++ , listSystemProperties, error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListSystemPropertiesAsync(GetListSystemPropertiesAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
++ CommonAPI::DBus::DBusSerializableArguments<am_SystemProperty_L, am_Error_e> >::callMethodAsync(
++ *this,
++ "getListSystemProperties",
++ "",
++ std::move(callback));
++}
++/**
++ * returns the delay in ms that the audiopath for the given mainConnection
++ * has
++(at)return E_OK on success, E_NOT_POSSIBLE if timing information is not
++ * yet retrieved, E_DATABASE_ERROR on read error on the database
++ */
++void CommandControlDBusProxy::getTimingInformation(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_timeSync_t& delay, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_timeSync_t, am_Error_e> >::callMethodWithReply(
++ *this,
++ "getTimingInformation",
++ "q",
++ mainConnectionID,
++ callStatus
++ , delay, error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getTimingInformationAsync(const am_mainConnectionID_t& mainConnectionID, GetTimingInformationAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_timeSync_t, am_Error_e> >::callMethodAsync(
++ *this,
++ "getTimingInformation",
++ "q",
++ mainConnectionID,
++ std::move(callback));
++}
++/**
++ * Retrieves the list of MainNotifications for a sink. Does not return the
++ * possible ones.
++ */
++void CommandControlDBusProxy::getListMainSinkNotificationConfigurations(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_NotificationConfiguration_L, am_Error_e> >::callMethodWithReply(
++ *this,
++ "getListMainSinkNotificationConfigurations",
++ "q",
++ sinkID,
++ callStatus
++ , listMainNotificationConfigurations, error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSinkNotificationConfigurationsAsync(const am_sinkID_t& sinkID, GetListMainSinkNotificationConfigurationsAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_NotificationConfiguration_L, am_Error_e> >::callMethodAsync(
++ *this,
++ "getListMainSinkNotificationConfigurations",
++ "q",
++ sinkID,
++ std::move(callback));
++}
++/**
++ * Retrieves the list of MainNotifications for a source. Does not return the
++ * possible ones.
++ */
++void CommandControlDBusProxy::getListMainSourceNotificationConfigurations(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_NotificationConfiguration_L, am_Error_e> >::callMethodWithReply(
++ *this,
++ "getListMainSourceNotificationConfigurations",
++ "q",
++ sourceID,
++ callStatus
++ , listMainNotificationConfigurations, error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSourceNotificationConfigurationsAsync(const am_sourceID_t& sourceID, GetListMainSourceNotificationConfigurationsAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t>,
++ CommonAPI::DBus::DBusSerializableArguments<am_NotificationConfiguration_L, am_Error_e> >::callMethodAsync(
++ *this,
++ "getListMainSourceNotificationConfigurations",
++ "q",
++ sourceID,
++ std::move(callback));
++}
++/**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++(at)return E_OK on
++ * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error
++ */
++void CommandControlDBusProxy::setMainSinkNotificationConfiguration(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_NotificationConfiguration_s>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
++ *this,
++ "setMainSinkNotificationConfiguration",
++ "q(qin)",
++ sinkID, mainNotificationConfiguration,
++ callStatus
++ , error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setMainSinkNotificationConfigurationAsync(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSinkNotificationConfigurationAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_NotificationConfiguration_s>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
++ *this,
++ "setMainSinkNotificationConfiguration",
++ "q(qin)",
++ sinkID, mainNotificationConfiguration,
++ std::move(callback));
++}
++/**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++(at)return E_OK on
++ * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error
++ */
++void CommandControlDBusProxy::setMainSourceNotificationConfiguration(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_NotificationConfiguration_s>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply(
++ *this,
++ "setMainSourceNotificationConfiguration",
++ "q(qin)",
++ sourceID, mainNotificationConfiguration,
++ callStatus
++ , error);
++}
++std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setMainSourceNotificationConfigurationAsync(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSourceNotificationConfigurationAsyncCallback callback) {
++ return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_NotificationConfiguration_s>,
++ CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync(
++ *this,
++ "setMainSourceNotificationConfiguration",
++ "q(qin)",
++ sourceID, mainNotificationConfiguration,
++ std::move(callback));
++}
++
++
++
++void CommandControlDBusProxy::getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const {
++ ownVersionMajor = 2;
++ ownVersionMinor = 0;
++}
++
++} // namespace am
++} // namespace genivi
++} // namespace org
+diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusProxy.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusProxy.h
+new file mode 100644
+index 0000000..c2a53ca
+--- /dev/null
++++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusProxy.h
+@@ -0,0 +1,266 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * The interface towards the Controlling Instance (e.g HMI). It handles the
++ * communication towards the HMI and other system components who need to interact
++ * with the audiomanagement.
++There are two rules that have to be kept in mind
++ * when implementing against this interface:
++ * @author Christian Mueller
++ */
++#ifndef ORG_GENIVI_AM_Command_Control_DBUS_PROXY_H_
++#define ORG_GENIVI_AM_Command_Control_DBUS_PROXY_H_
++
++#include <org/genivi/am/CommandControlProxyBase.h>
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <CommonAPI/DBus/DBusFactory.h>
++#include <CommonAPI/DBus/DBusProxy.h>
++#include <CommonAPI/DBus/DBusEvent.h>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++#include <string>
++
++namespace org {
++namespace genivi {
++namespace am {
++
++class CommandControlDBusProxy: virtual public CommandControlProxyBase, virtual public CommonAPI::DBus::DBusProxy {
++ public:
++ CommandControlDBusProxy(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& interfaceName,
++ const std::string& busName,
++ const std::string& objectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyconnection);
++
++ virtual ~CommandControlDBusProxy() { }
++
++
++ virtual NewMainConnectionEvent& getNewMainConnectionEvent();
++ virtual RemovedMainConnectionEvent& getRemovedMainConnectionEvent();
++ virtual NewSinkEvent& getNewSinkEvent();
++ virtual RemovedSinkEvent& getRemovedSinkEvent();
++ virtual NewSourceEvent& getNewSourceEvent();
++ virtual RemovedSourceEvent& getRemovedSourceEvent();
++ virtual NumberOfSinkClassesChangedEvent& getNumberOfSinkClassesChangedEvent();
++ virtual NumberOfSourceClassesChangedEvent& getNumberOfSourceClassesChangedEvent();
++ virtual MainConnectionStateChangedEvent& getMainConnectionStateChangedEvent();
++ virtual MainSinkSoundPropertyChangedEvent& getMainSinkSoundPropertyChangedEvent();
++ virtual MainSourceSoundPropertyChangedEvent& getMainSourceSoundPropertyChangedEvent();
++ virtual SinkAvailabilityChangedEvent& getSinkAvailabilityChangedEvent();
++ virtual SourceAvailabilityChangedEvent& getSourceAvailabilityChangedEvent();
++ virtual VolumeChangedEvent& getVolumeChangedEvent();
++ virtual SinkMuteStateChangedEvent& getSinkMuteStateChangedEvent();
++ virtual SystemPropertyChangedEvent& getSystemPropertyChangedEvent();
++ virtual TimingInformationChangedEvent& getTimingInformationChangedEvent();
++ virtual SinkUpdatedEvent& getSinkUpdatedEvent();
++ virtual SourceUpdatedEvent& getSourceUpdatedEvent();
++ virtual SinkNotificationEvent& getSinkNotificationEvent();
++ virtual SourceNotificationEvent& getSourceNotificationEvent();
++ virtual MainSinkNotificationConfigurationChangedEvent& getMainSinkNotificationConfigurationChangedEvent();
++ virtual MainSourceNotificationConfigurationChangedEvent& getMainSourceNotificationConfigurationChangedEvent();
++
++ /**
++ * connects a source to sink
++ (at)return E_OK on success, E_NOT_POSSIBLE on
++ * failure, E_ALREADY_EXISTS if the connection does already exists
++ */
++ virtual void connect(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_mainConnectionID_t& mainConnectionID, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> connectAsync(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, ConnectAsyncCallback callback);
++ /**
++ * disconnects a mainConnection
++ (at)return E_OK on successes, E_NON_EXISTENT if
++ * the connection does not exist, E_NOT_POSSIBLE on error.
++ */
++ virtual void disconnect(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> disconnectAsync(const am_mainConnectionID_t& mainConnectionID, DisconnectAsyncCallback callback);
++ /**
++ * sets the volume for a sink
++ (at)return E_OK on success, E_UNKOWN on error,
++ * E_OUT_OF_RANGE in case the value is out of range
++ */
++ virtual void setVolume(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> setVolumeAsync(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, SetVolumeAsyncCallback callback);
++ /**
++ * This function is used to increment or decrement the current volume for a
++ * sink.
++ (at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the
++ * value is not in the given volume range.
++ */
++ virtual void volumeStep(const am_sinkID_t& sinkID, const int16_t& volStep, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> volumeStepAsync(const am_sinkID_t& sinkID, const int16_t& volStep, VolumeStepAsyncCallback callback);
++ /**
++ * sets the mute state of a sink
++ (at)return E_OK on success, E_UNKNOWN on error.
++ * If the mute state is already the desired one, the Daemon will return E_OK.
++ */
++ virtual void setSinkMuteState(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> setSinkMuteStateAsync(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, SetSinkMuteStateAsyncCallback callback);
++ /**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++ (at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++ virtual void setMainSinkSoundProperty(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> setMainSinkSoundPropertyAsync(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, SetMainSinkSoundPropertyAsyncCallback callback);
++ /**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++ (at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++ virtual void setMainSourceSoundProperty(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> setMainSourceSoundPropertyAsync(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, SetMainSourceSoundPropertyAsyncCallback callback);
++ /**
++ * is used to set a specific system property.
++ (at)return E_OK on success,
++ * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error
++ */
++ virtual void setSystemProperty(const am_SystemProperty_s& property, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> setSystemPropertyAsync(const am_SystemProperty_s& property, SetSystemPropertyAsyncCallback callback);
++ /**
++ * returns the actual list of MainConnections
++ (at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++ virtual void getListMainConnections(CommonAPI::CallStatus& callStatus, am_MainConnection_L& listConnections, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> getListMainConnectionsAsync(GetListMainConnectionsAsyncCallback callback);
++ /**
++ * returns the actual list of Sinks
++ (at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++ virtual void getListMainSinks(CommonAPI::CallStatus& callStatus, am_SinkType_L& listMainSinks, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> getListMainSinksAsync(GetListMainSinksAsyncCallback callback);
++ /**
++ * returns the actual list of Sources
++ (at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++ virtual void getListMainSources(CommonAPI::CallStatus& callStatus, am_SourceType_L& listMainSources, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> getListMainSourcesAsync(GetListMainSourcesAsyncCallback callback);
++ /**
++ * This is used to retrieve all source sound properties related to a source.
++ * Returns a vector of the sound properties and values as pair
++ (at)return E_OK on
++ * success, E_DATABASE_ERROR on error
++ */
++ virtual void getListMainSinkSoundProperties(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> getListMainSinkSoundPropertiesAsync(const am_sinkID_t& sinkID, GetListMainSinkSoundPropertiesAsyncCallback callback);
++ /**
++ * This is used to retrieve all source sound properties related to a
++ * source.
++ (at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++ virtual void getListMainSourceSoundProperties(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> getListMainSourceSoundPropertiesAsync(const am_sourceID_t& sourceID, GetListMainSourceSoundPropertiesAsyncCallback callback);
++ /**
++ * This is used to retrieve SourceClass Information of all source classes
++ *
++ (at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++ virtual void getListSourceClasses(CommonAPI::CallStatus& callStatus, am_SourceClass_L& listSourceClasses, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> getListSourceClassesAsync(GetListSourceClassesAsyncCallback callback);
++ /**
++ * This is used to retrieve SinkClass Information of all sink classes
++ (at)return
++ * E_OK on success, E_DATABASE_ERROR on error
++ */
++ virtual void getListSinkClasses(CommonAPI::CallStatus& callStatus, am_SinkClass_L& listSinkClasses, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> getListSinkClassesAsync(GetListSinkClassesAsyncCallback callback);
++ /**
++ * Retrieves a complete list of all systemProperties.
++ (at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++ virtual void getListSystemProperties(CommonAPI::CallStatus& callStatus, am_SystemProperty_L& listSystemProperties, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> getListSystemPropertiesAsync(GetListSystemPropertiesAsyncCallback callback);
++ /**
++ * returns the delay in ms that the audiopath for the given mainConnection
++ * has
++ (at)return E_OK on success, E_NOT_POSSIBLE if timing information is not
++ * yet retrieved, E_DATABASE_ERROR on read error on the database
++ */
++ virtual void getTimingInformation(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_timeSync_t& delay, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> getTimingInformationAsync(const am_mainConnectionID_t& mainConnectionID, GetTimingInformationAsyncCallback callback);
++ /**
++ * Retrieves the list of MainNotifications for a sink. Does not return the
++ * possible ones.
++ */
++ virtual void getListMainSinkNotificationConfigurations(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> getListMainSinkNotificationConfigurationsAsync(const am_sinkID_t& sinkID, GetListMainSinkNotificationConfigurationsAsyncCallback callback);
++ /**
++ * Retrieves the list of MainNotifications for a source. Does not return the
++ * possible ones.
++ */
++ virtual void getListMainSourceNotificationConfigurations(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> getListMainSourceNotificationConfigurationsAsync(const am_sourceID_t& sourceID, GetListMainSourceNotificationConfigurationsAsyncCallback callback);
++ /**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++ (at)return E_OK on
++ * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error
++ */
++ virtual void setMainSinkNotificationConfiguration(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> setMainSinkNotificationConfigurationAsync(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSinkNotificationConfigurationAsyncCallback callback);
++ /**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++ (at)return E_OK on
++ * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error
++ */
++ virtual void setMainSourceNotificationConfiguration(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ virtual std::future<CommonAPI::CallStatus> setMainSourceNotificationConfigurationAsync(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSourceNotificationConfigurationAsyncCallback callback);
++
++
++ virtual void getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const;
++
++ private:
++
++ CommonAPI::DBus::DBusEvent<NewMainConnectionEvent> newMainConnection_;
++ CommonAPI::DBus::DBusEvent<RemovedMainConnectionEvent> removedMainConnection_;
++ CommonAPI::DBus::DBusEvent<NewSinkEvent> newSink_;
++ CommonAPI::DBus::DBusEvent<RemovedSinkEvent> removedSink_;
++ CommonAPI::DBus::DBusEvent<NewSourceEvent> newSource_;
++ CommonAPI::DBus::DBusEvent<RemovedSourceEvent> removedSource_;
++ CommonAPI::DBus::DBusEvent<NumberOfSinkClassesChangedEvent> numberOfSinkClassesChanged_;
++ CommonAPI::DBus::DBusEvent<NumberOfSourceClassesChangedEvent> numberOfSourceClassesChanged_;
++ CommonAPI::DBus::DBusEvent<MainConnectionStateChangedEvent> mainConnectionStateChanged_;
++ CommonAPI::DBus::DBusEvent<MainSinkSoundPropertyChangedEvent> mainSinkSoundPropertyChanged_;
++ CommonAPI::DBus::DBusEvent<MainSourceSoundPropertyChangedEvent> mainSourceSoundPropertyChanged_;
++ CommonAPI::DBus::DBusEvent<SinkAvailabilityChangedEvent> sinkAvailabilityChanged_;
++ CommonAPI::DBus::DBusEvent<SourceAvailabilityChangedEvent> sourceAvailabilityChanged_;
++ CommonAPI::DBus::DBusEvent<VolumeChangedEvent> volumeChanged_;
++ CommonAPI::DBus::DBusEvent<SinkMuteStateChangedEvent> sinkMuteStateChanged_;
++ CommonAPI::DBus::DBusEvent<SystemPropertyChangedEvent> systemPropertyChanged_;
++ CommonAPI::DBus::DBusEvent<TimingInformationChangedEvent> timingInformationChanged_;
++ CommonAPI::DBus::DBusEvent<SinkUpdatedEvent> sinkUpdated_;
++ CommonAPI::DBus::DBusEvent<SourceUpdatedEvent> sourceUpdated_;
++ CommonAPI::DBus::DBusEvent<SinkNotificationEvent> sinkNotification_;
++ CommonAPI::DBus::DBusEvent<SourceNotificationEvent> sourceNotification_;
++ CommonAPI::DBus::DBusEvent<MainSinkNotificationConfigurationChangedEvent> mainSinkNotificationConfigurationChanged_;
++ CommonAPI::DBus::DBusEvent<MainSourceNotificationConfigurationChangedEvent> mainSourceNotificationConfigurationChanged_;
++
++};
++
++
++
++} // namespace am
++} // namespace genivi
++} // namespace org
++
++#endif // ORG_GENIVI_AM_Command_Control_DBUS_PROXY_H_
+diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusStubAdapter.cpp b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusStubAdapter.cpp
+new file mode 100644
+index 0000000..6da5cfd
+--- /dev/null
++++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusStubAdapter.cpp
+@@ -0,0 +1,1096 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++#include "CommandControlDBusStubAdapter.h"
++#include <org/genivi/am/CommandControl.h>
++
++namespace org {
++namespace genivi {
++namespace am {
++
++std::shared_ptr<CommonAPI::DBus::DBusStubAdapter> createCommandControlDBusStubAdapter(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& interfaceName,
++ const std::string& busName,
++ const std::string& objectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyConnection,
++ const std::shared_ptr<CommonAPI::StubBase>& stubBase) {
++ return std::make_shared<CommandControlDBusStubAdapter>(factory, commonApiAddress, interfaceName, busName, objectPath, dbusProxyConnection, stubBase);
++}
++
++INITIALIZER(registerCommandControlDBusStubAdapter) {
++ CommonAPI::DBus::DBusFactory::registerAdapterFactoryMethod(CommandControl::getInterfaceId(),
++ &createCommandControlDBusStubAdapter);
++}
++
++
++
++CommandControlDBusStubAdapterInternal::~CommandControlDBusStubAdapterInternal() {
++ deactivateManagedInstances();
++ CommandControlDBusStubAdapterHelper::deinit();
++}
++
++void CommandControlDBusStubAdapterInternal::deactivateManagedInstances() {
++
++}
++
++const char* CommandControlDBusStubAdapterInternal::getMethodsDBusIntrospectionXmlData() const {
++ static const std::string introspectionData =
++ "<method name=\"getInterfaceVersion\">\n"
++ "<arg name=\"value\" type=\"uu\" direction=\"out\" />"
++ "</method>\n"
++ /**
++ * Callback that is called when the number of connections change
++ */
++ "<signal name=\"newMainConnection\">\n"
++ "<arg name=\"mainConnection\" type=\"(qqqni)\" />\n"
++ "</signal>\n"
++ /**
++ * Callback that is called when the number of connections change
++ */
++ "<signal name=\"removedMainConnection\">\n"
++ "<arg name=\"mainConnection\" type=\"q\" />\n"
++ "</signal>\n"
++ /**
++ * Callback that is called when the number of sinks change
++ */
++ "<signal name=\"newSink\">\n"
++ "<arg name=\"sink\" type=\"(qs(iq)niq)\" />\n"
++ "</signal>\n"
++ /**
++ * Callback that is called when the number of sinks change
++ */
++ "<signal name=\"removedSink\">\n"
++ "<arg name=\"sinkID\" type=\"q\" />\n"
++ "</signal>\n"
++ /**
++ * Callback that is called when the number of sources change
++ */
++ "<signal name=\"newSource\">\n"
++ "<arg name=\"source\" type=\"(qs(iq)q)\" />\n"
++ "</signal>\n"
++ /**
++ * Callback that is called when the number of sources change
++ */
++ "<signal name=\"removedSource\">\n"
++ "<arg name=\"source\" type=\"q\" />\n"
++ "</signal>\n"
++ /**
++ * this callback is fired if the number of sink classes changed
++ */
++ "<signal name=\"numberOfSinkClassesChanged\">\n"
++ "</signal>\n"
++ /**
++ * this callback is fired if the number of source classes changed
++ */
++ "<signal name=\"numberOfSourceClassesChanged\">\n"
++ "</signal>\n"
++ /**
++ * This callback is called when the ConnectionState of a connection changed.
++ */
++ "<signal name=\"mainConnectionStateChanged\">\n"
++ "<arg name=\"connectionID\" type=\"q\" />\n"
++ "<arg name=\"connectionState\" type=\"i\" />\n"
++ "</signal>\n"
++ /**
++ * this callback indicates that a sinkSoundProperty has changed.
++ */
++ "<signal name=\"mainSinkSoundPropertyChanged\">\n"
++ "<arg name=\"sinkID\" type=\"q\" />\n"
++ "<arg name=\"soundProperty\" type=\"(qn)\" />\n"
++ "</signal>\n"
++ /**
++ * this callback indicates that a sourceSoundProperty has changed.
++ */
++ "<signal name=\"mainSourceSoundPropertyChanged\">\n"
++ "<arg name=\"sourceID\" type=\"q\" />\n"
++ "<arg name=\"soundProperty\" type=\"(qn)\" />\n"
++ "</signal>\n"
++ /**
++ * this callback is called when the availability of a sink has changed
++ */
++ "<signal name=\"sinkAvailabilityChanged\">\n"
++ "<arg name=\"sinkID\" type=\"q\" />\n"
++ "<arg name=\"availability\" type=\"(iq)\" />\n"
++ "</signal>\n"
++ /**
++ * this callback is called when the availability of source has changed.
++ */
++ "<signal name=\"sourceAvailabilityChanged\">\n"
++ "<arg name=\"sourceID\" type=\"q\" />\n"
++ "<arg name=\"availability\" type=\"(iq)\" />\n"
++ "</signal>\n"
++ /**
++ * this callback indicates a volume change on the indicated sink
++ */
++ "<signal name=\"volumeChanged\">\n"
++ "<arg name=\"sinkID\" type=\"q\" />\n"
++ "<arg name=\"volume\" type=\"n\" />\n"
++ "</signal>\n"
++ /**
++ * this callback indicates a mute state change on a sink.
++ */
++ "<signal name=\"sinkMuteStateChanged\">\n"
++ "<arg name=\"sinkID\" type=\"q\" />\n"
++ "<arg name=\"muteState\" type=\"i\" />\n"
++ "</signal>\n"
++ /**
++ * is fired if a systemProperty changed
++ */
++ "<signal name=\"systemPropertyChanged\">\n"
++ "<arg name=\"systemProperty\" type=\"(qn)\" />\n"
++ "</signal>\n"
++ /**
++ * This callback is fired if the timinginformation for a mainConnectionID changed
++ */
++ "<signal name=\"timingInformationChanged\">\n"
++ "<arg name=\"mainConnectionID\" type=\"q\" />\n"
++ "<arg name=\"time\" type=\"n\" />\n"
++ "</signal>\n"
++ /**
++ * This callback is called when a sink is updated.
++ */
++ "<signal name=\"sinkUpdated\">\n"
++ "<arg name=\"sinkID\" type=\"q\" />\n"
++ "<arg name=\"sinkClassID\" type=\"q\" />\n"
++ "<arg name=\"listMainSoundProperties\" type=\"a(qn)\" />\n"
++ "</signal>\n"
++ /**
++ * This callback is called when a source is updated.
++ */
++ "<signal name=\"sourceUpdated\">\n"
++ "<arg name=\"sourceID\" type=\"q\" />\n"
++ "<arg name=\"sourceClassID\" type=\"q\" />\n"
++ "<arg name=\"listMainSoundProperties\" type=\"a(qn)\" />\n"
++ "</signal>\n"
++ /**
++ * This callback is called when a notificated value of a sink changes.
++ */
++ "<signal name=\"sinkNotification\">\n"
++ "<arg name=\"sinkID\" type=\"q\" />\n"
++ "<arg name=\"notification\" type=\"(qn)\" />\n"
++ "</signal>\n"
++ /**
++ * This callback is called when a notifcated value of a source changes.
++ */
++ "<signal name=\"sourceNotification\">\n"
++ "<arg name=\"sourceID\" type=\"q\" />\n"
++ "<arg name=\"notification\" type=\"(qn)\" />\n"
++ "</signal>\n"
++ /**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++ "<signal name=\"mainSinkNotificationConfigurationChanged\">\n"
++ "<arg name=\"sinkID\" type=\"q\" />\n"
++ "<arg name=\"mainNotificationConfiguration\" type=\"(qin)\" />\n"
++ "</signal>\n"
++ /**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++ "<signal name=\"mainSourceNotificationConfigurationChanged\">\n"
++ "<arg name=\"sourceID\" type=\"q\" />\n"
++ "<arg name=\"mainNotificationConfiguration\" type=\"(qin)\" />\n"
++ "</signal>\n"
++ /**
++ * connects a source to sink
++ (at)return E_OK on success, E_NOT_POSSIBLE on
++ * failure, E_ALREADY_EXISTS if the connection does already exists
++ */
++ "<method name=\"connect\">\n"
++ "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n"
++ "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n"
++ "<arg name=\"mainConnectionID\" type=\"q\" direction=\"out\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * disconnects a mainConnection
++ (at)return E_OK on successes, E_NON_EXISTENT if
++ * the connection does not exist, E_NOT_POSSIBLE on error.
++ */
++ "<method name=\"disconnect\">\n"
++ "<arg name=\"mainConnectionID\" type=\"q\" direction=\"in\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * sets the volume for a sink
++ (at)return E_OK on success, E_UNKOWN on error,
++ * E_OUT_OF_RANGE in case the value is out of range
++ */
++ "<method name=\"setVolume\">\n"
++ "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n"
++ "<arg name=\"volume\" type=\"n\" direction=\"in\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * This function is used to increment or decrement the current volume for a
++ * sink.
++ (at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the
++ * value is not in the given volume range.
++ */
++ "<method name=\"volumeStep\">\n"
++ "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n"
++ "<arg name=\"volStep\" type=\"n\" direction=\"in\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * sets the mute state of a sink
++ (at)return E_OK on success, E_UNKNOWN on error.
++ * If the mute state is already the desired one, the Daemon will return E_OK.
++ */
++ "<method name=\"setSinkMuteState\">\n"
++ "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n"
++ "<arg name=\"muteState\" type=\"i\" direction=\"in\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++ (at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++ "<method name=\"setMainSinkSoundProperty\">\n"
++ "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n"
++ "<arg name=\"soundProperty\" type=\"(qn)\" direction=\"in\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++ (at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++ "<method name=\"setMainSourceSoundProperty\">\n"
++ "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n"
++ "<arg name=\"soundProperty\" type=\"(qn)\" direction=\"in\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * is used to set a specific system property.
++ (at)return E_OK on success,
++ * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error
++ */
++ "<method name=\"setSystemProperty\">\n"
++ "<arg name=\"property\" type=\"(qn)\" direction=\"in\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * returns the actual list of MainConnections
++ (at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++ "<method name=\"getListMainConnections\">\n"
++ "<arg name=\"listConnections\" type=\"a(qqqni)\" direction=\"out\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * returns the actual list of Sinks
++ (at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++ "<method name=\"getListMainSinks\">\n"
++ "<arg name=\"listMainSinks\" type=\"a(qs(iq)niq)\" direction=\"out\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * returns the actual list of Sources
++ (at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++ "<method name=\"getListMainSources\">\n"
++ "<arg name=\"listMainSources\" type=\"a(qs(iq)q)\" direction=\"out\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * This is used to retrieve all source sound properties related to a source.
++ * Returns a vector of the sound properties and values as pair
++ (at)return E_OK on
++ * success, E_DATABASE_ERROR on error
++ */
++ "<method name=\"getListMainSinkSoundProperties\">\n"
++ "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n"
++ "<arg name=\"listSoundProperties\" type=\"a(qn)\" direction=\"out\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * This is used to retrieve all source sound properties related to a
++ * source.
++ (at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++ "<method name=\"getListMainSourceSoundProperties\">\n"
++ "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n"
++ "<arg name=\"listSourceProperties\" type=\"a(qn)\" direction=\"out\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * This is used to retrieve SourceClass Information of all source classes
++ *
++ (at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++ "<method name=\"getListSourceClasses\">\n"
++ "<arg name=\"listSourceClasses\" type=\"a(qsa(qn))\" direction=\"out\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * This is used to retrieve SinkClass Information of all sink classes
++ (at)return
++ * E_OK on success, E_DATABASE_ERROR on error
++ */
++ "<method name=\"getListSinkClasses\">\n"
++ "<arg name=\"listSinkClasses\" type=\"a(qsa(qn))\" direction=\"out\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * Retrieves a complete list of all systemProperties.
++ (at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++ "<method name=\"getListSystemProperties\">\n"
++ "<arg name=\"listSystemProperties\" type=\"a(qn)\" direction=\"out\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * returns the delay in ms that the audiopath for the given mainConnection
++ * has
++ (at)return E_OK on success, E_NOT_POSSIBLE if timing information is not
++ * yet retrieved, E_DATABASE_ERROR on read error on the database
++ */
++ "<method name=\"getTimingInformation\">\n"
++ "<arg name=\"mainConnectionID\" type=\"q\" direction=\"in\" />\n"
++ "<arg name=\"delay\" type=\"n\" direction=\"out\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * Retrieves the list of MainNotifications for a sink. Does not return the
++ * possible ones.
++ */
++ "<method name=\"getListMainSinkNotificationConfigurations\">\n"
++ "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n"
++ "<arg name=\"listMainNotificationConfigurations\" type=\"a(qin)\" direction=\"out\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * Retrieves the list of MainNotifications for a source. Does not return the
++ * possible ones.
++ */
++ "<method name=\"getListMainSourceNotificationConfigurations\">\n"
++ "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n"
++ "<arg name=\"listMainNotificationConfigurations\" type=\"a(qin)\" direction=\"out\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++ (at)return E_OK on
++ * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error
++ */
++ "<method name=\"setMainSinkNotificationConfiguration\">\n"
++ "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n"
++ "<arg name=\"mainNotificationConfiguration\" type=\"(qin)\" direction=\"in\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++ /**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++ (at)return E_OK on
++ * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error
++ */
++ "<method name=\"setMainSourceNotificationConfiguration\">\n"
++ "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n"
++ "<arg name=\"mainNotificationConfiguration\" type=\"(qin)\" direction=\"in\" />\n"
++ "<arg name=\"error\" type=\"i\" direction=\"out\" />\n"
++ "</method>\n"
++
++ ;
++ return introspectionData.c_str();
++}
++
++CommonAPI::DBus::DBusGetAttributeStubDispatcher<
++ CommandControlStub,
++ CommonAPI::Version
++ > CommandControlDBusStubAdapterInternal::getCommandControlInterfaceVersionStubDispatcher(&CommandControlStub::getInterfaceVersion, "uu");
++
++
++
++/**
++ * connects a source to sink
++(at)return E_OK on success, E_NOT_POSSIBLE on
++ * failure, E_ALREADY_EXISTS if the connection does already exists
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sourceID_t, am_sinkID_t>,
++ std::tuple<am_mainConnectionID_t, am_Error_e>
++ > CommandControlDBusStubAdapterInternal::connectStubDispatcher(&CommandControlStub::connect, "qi");
++/**
++ * disconnects a mainConnection
++(at)return E_OK on successes, E_NON_EXISTENT if
++ * the connection does not exist, E_NOT_POSSIBLE on error.
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_mainConnectionID_t>,
++ std::tuple<am_Error_e>
++ > CommandControlDBusStubAdapterInternal::disconnectStubDispatcher(&CommandControlStub::disconnect, "i");
++/**
++ * sets the volume for a sink
++(at)return E_OK on success, E_UNKOWN on error,
++ * E_OUT_OF_RANGE in case the value is out of range
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sinkID_t, am_mainVolume_t>,
++ std::tuple<am_Error_e>
++ > CommandControlDBusStubAdapterInternal::setVolumeStubDispatcher(&CommandControlStub::setVolume, "i");
++/**
++ * This function is used to increment or decrement the current volume for a
++ * sink.
++(at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the
++ * value is not in the given volume range.
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sinkID_t, int16_t>,
++ std::tuple<am_Error_e>
++ > CommandControlDBusStubAdapterInternal::volumeStepStubDispatcher(&CommandControlStub::volumeStep, "i");
++/**
++ * sets the mute state of a sink
++(at)return E_OK on success, E_UNKNOWN on error.
++ * If the mute state is already the desired one, the Daemon will return E_OK.
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sinkID_t, am_MuteState_e>,
++ std::tuple<am_Error_e>
++ > CommandControlDBusStubAdapterInternal::setSinkMuteStateStubDispatcher(&CommandControlStub::setSinkMuteState, "i");
++/**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++(at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sinkID_t, am_MainSoundProperty_s>,
++ std::tuple<am_Error_e>
++ > CommandControlDBusStubAdapterInternal::setMainSinkSoundPropertyStubDispatcher(&CommandControlStub::setMainSinkSoundProperty, "i");
++/**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++(at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sourceID_t, am_MainSoundProperty_s>,
++ std::tuple<am_Error_e>
++ > CommandControlDBusStubAdapterInternal::setMainSourceSoundPropertyStubDispatcher(&CommandControlStub::setMainSourceSoundProperty, "i");
++/**
++ * is used to set a specific system property.
++(at)return E_OK on success,
++ * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_SystemProperty_s>,
++ std::tuple<am_Error_e>
++ > CommandControlDBusStubAdapterInternal::setSystemPropertyStubDispatcher(&CommandControlStub::setSystemProperty, "i");
++/**
++ * returns the actual list of MainConnections
++(at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<>,
++ std::tuple<am_MainConnection_L, am_Error_e>
++ > CommandControlDBusStubAdapterInternal::getListMainConnectionsStubDispatcher(&CommandControlStub::getListMainConnections, "a(qqqni)i");
++/**
++ * returns the actual list of Sinks
++(at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<>,
++ std::tuple<am_SinkType_L, am_Error_e>
++ > CommandControlDBusStubAdapterInternal::getListMainSinksStubDispatcher(&CommandControlStub::getListMainSinks, "a(qs(iq)niq)i");
++/**
++ * returns the actual list of Sources
++(at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<>,
++ std::tuple<am_SourceType_L, am_Error_e>
++ > CommandControlDBusStubAdapterInternal::getListMainSourcesStubDispatcher(&CommandControlStub::getListMainSources, "a(qs(iq)q)i");
++/**
++ * This is used to retrieve all source sound properties related to a source.
++ * Returns a vector of the sound properties and values as pair
++(at)return E_OK on
++ * success, E_DATABASE_ERROR on error
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sinkID_t>,
++ std::tuple<am_MainSoundProperty_L, am_Error_e>
++ > CommandControlDBusStubAdapterInternal::getListMainSinkSoundPropertiesStubDispatcher(&CommandControlStub::getListMainSinkSoundProperties, "a(qn)i");
++/**
++ * This is used to retrieve all source sound properties related to a
++ * source.
++(at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sourceID_t>,
++ std::tuple<am_MainSoundProperty_L, am_Error_e>
++ > CommandControlDBusStubAdapterInternal::getListMainSourceSoundPropertiesStubDispatcher(&CommandControlStub::getListMainSourceSoundProperties, "a(qn)i");
++/**
++ * This is used to retrieve SourceClass Information of all source classes
++ *
++(at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<>,
++ std::tuple<am_SourceClass_L, am_Error_e>
++ > CommandControlDBusStubAdapterInternal::getListSourceClassesStubDispatcher(&CommandControlStub::getListSourceClasses, "a(qsa(qn))i");
++/**
++ * This is used to retrieve SinkClass Information of all sink classes
++(at)return
++ * E_OK on success, E_DATABASE_ERROR on error
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<>,
++ std::tuple<am_SinkClass_L, am_Error_e>
++ > CommandControlDBusStubAdapterInternal::getListSinkClassesStubDispatcher(&CommandControlStub::getListSinkClasses, "a(qsa(qn))i");
++/**
++ * Retrieves a complete list of all systemProperties.
++(at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<>,
++ std::tuple<am_SystemProperty_L, am_Error_e>
++ > CommandControlDBusStubAdapterInternal::getListSystemPropertiesStubDispatcher(&CommandControlStub::getListSystemProperties, "a(qn)i");
++/**
++ * returns the delay in ms that the audiopath for the given mainConnection
++ * has
++(at)return E_OK on success, E_NOT_POSSIBLE if timing information is not
++ * yet retrieved, E_DATABASE_ERROR on read error on the database
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_mainConnectionID_t>,
++ std::tuple<am_timeSync_t, am_Error_e>
++ > CommandControlDBusStubAdapterInternal::getTimingInformationStubDispatcher(&CommandControlStub::getTimingInformation, "ni");
++/**
++ * Retrieves the list of MainNotifications for a sink. Does not return the
++ * possible ones.
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sinkID_t>,
++ std::tuple<am_NotificationConfiguration_L, am_Error_e>
++ > CommandControlDBusStubAdapterInternal::getListMainSinkNotificationConfigurationsStubDispatcher(&CommandControlStub::getListMainSinkNotificationConfigurations, "a(qin)i");
++/**
++ * Retrieves the list of MainNotifications for a source. Does not return the
++ * possible ones.
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sourceID_t>,
++ std::tuple<am_NotificationConfiguration_L, am_Error_e>
++ > CommandControlDBusStubAdapterInternal::getListMainSourceNotificationConfigurationsStubDispatcher(&CommandControlStub::getListMainSourceNotificationConfigurations, "a(qin)i");
++/**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++(at)return E_OK on
++ * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sinkID_t, am_NotificationConfiguration_s>,
++ std::tuple<am_Error_e>
++ > CommandControlDBusStubAdapterInternal::setMainSinkNotificationConfigurationStubDispatcher(&CommandControlStub::setMainSinkNotificationConfiguration, "i");
++/**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++(at)return E_OK on
++ * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error
++ */
++CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sourceID_t, am_NotificationConfiguration_s>,
++ std::tuple<am_Error_e>
++ > CommandControlDBusStubAdapterInternal::setMainSourceNotificationConfigurationStubDispatcher(&CommandControlStub::setMainSourceNotificationConfiguration, "i");
++
++
++
++/**
++ * Callback that is called when the number of connections change
++ */
++void CommandControlDBusStubAdapterInternal::fireNewMainConnectionEvent(const am_MainConnectionType_s& mainConnection) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_MainConnectionType_s>>
++ ::sendSignal(
++ *this,
++ "newMainConnection",
++ "(qqqni)",
++ mainConnection
++ );
++}
++/**
++ * Callback that is called when the number of connections change
++ */
++void CommandControlDBusStubAdapterInternal::fireRemovedMainConnectionEvent(const am_mainConnectionID_t& mainConnection) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t>>
++ ::sendSignal(
++ *this,
++ "removedMainConnection",
++ "q",
++ mainConnection
++ );
++}
++/**
++ * Callback that is called when the number of sinks change
++ */
++void CommandControlDBusStubAdapterInternal::fireNewSinkEvent(const am_SinkType_s& sink) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_SinkType_s>>
++ ::sendSignal(
++ *this,
++ "newSink",
++ "(qs(iq)niq)",
++ sink
++ );
++}
++/**
++ * Callback that is called when the number of sinks change
++ */
++void CommandControlDBusStubAdapterInternal::fireRemovedSinkEvent(const am_sinkID_t& sinkID) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t>>
++ ::sendSignal(
++ *this,
++ "removedSink",
++ "q",
++ sinkID
++ );
++}
++/**
++ * Callback that is called when the number of sources change
++ */
++void CommandControlDBusStubAdapterInternal::fireNewSourceEvent(const am_SourceType_s& source) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_SourceType_s>>
++ ::sendSignal(
++ *this,
++ "newSource",
++ "(qs(iq)q)",
++ source
++ );
++}
++/**
++ * Callback that is called when the number of sources change
++ */
++void CommandControlDBusStubAdapterInternal::fireRemovedSourceEvent(const am_sourceID_t& source) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t>>
++ ::sendSignal(
++ *this,
++ "removedSource",
++ "q",
++ source
++ );
++}
++/**
++ * this callback is fired if the number of sink classes changed
++ */
++void CommandControlDBusStubAdapterInternal::fireNumberOfSinkClassesChangedEvent() {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<>>
++ ::sendSignal(
++ *this,
++ "numberOfSinkClassesChanged",
++ ""
++ );
++}
++/**
++ * this callback is fired if the number of source classes changed
++ */
++void CommandControlDBusStubAdapterInternal::fireNumberOfSourceClassesChangedEvent() {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<>>
++ ::sendSignal(
++ *this,
++ "numberOfSourceClassesChanged",
++ ""
++ );
++}
++/**
++ * This callback is called when the ConnectionState of a connection changed.
++ */
++void CommandControlDBusStubAdapterInternal::fireMainConnectionStateChangedEvent(const am_mainConnectionID_t& connectionID, const am_ConnectionState_e& connectionState) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t, am_ConnectionState_e>>
++ ::sendSignal(
++ *this,
++ "mainConnectionStateChanged",
++ "qi",
++ connectionID, connectionState
++ );
++}
++/**
++ * this callback indicates that a sinkSoundProperty has changed.
++ */
++void CommandControlDBusStubAdapterInternal::fireMainSinkSoundPropertyChangedEvent(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MainSoundProperty_s>>
++ ::sendSignal(
++ *this,
++ "mainSinkSoundPropertyChanged",
++ "q(qn)",
++ sinkID, soundProperty
++ );
++}
++/**
++ * this callback indicates that a sourceSoundProperty has changed.
++ */
++void CommandControlDBusStubAdapterInternal::fireMainSourceSoundPropertyChangedEvent(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_MainSoundProperty_s>>
++ ::sendSignal(
++ *this,
++ "mainSourceSoundPropertyChanged",
++ "q(qn)",
++ sourceID, soundProperty
++ );
++}
++/**
++ * this callback is called when the availability of a sink has changed
++ */
++void CommandControlDBusStubAdapterInternal::fireSinkAvailabilityChangedEvent(const am_sinkID_t& sinkID, const am_Availability_s& availability) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_Availability_s>>
++ ::sendSignal(
++ *this,
++ "sinkAvailabilityChanged",
++ "q(iq)",
++ sinkID, availability
++ );
++}
++/**
++ * this callback is called when the availability of source has changed.
++ */
++void CommandControlDBusStubAdapterInternal::fireSourceAvailabilityChangedEvent(const am_sourceID_t& sourceID, const am_Availability_s& availability) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_Availability_s>>
++ ::sendSignal(
++ *this,
++ "sourceAvailabilityChanged",
++ "q(iq)",
++ sourceID, availability
++ );
++}
++/**
++ * this callback indicates a volume change on the indicated sink
++ */
++void CommandControlDBusStubAdapterInternal::fireVolumeChangedEvent(const am_sinkID_t& sinkID, const am_mainVolume_t& volume) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_mainVolume_t>>
++ ::sendSignal(
++ *this,
++ "volumeChanged",
++ "qn",
++ sinkID, volume
++ );
++}
++/**
++ * this callback indicates a mute state change on a sink.
++ */
++void CommandControlDBusStubAdapterInternal::fireSinkMuteStateChangedEvent(const am_sinkID_t& sinkID, const am_MuteState_e& muteState) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MuteState_e>>
++ ::sendSignal(
++ *this,
++ "sinkMuteStateChanged",
++ "qi",
++ sinkID, muteState
++ );
++}
++/**
++ * is fired if a systemProperty changed
++ */
++void CommandControlDBusStubAdapterInternal::fireSystemPropertyChangedEvent(const am_SystemProperty_s& systemProperty) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_SystemProperty_s>>
++ ::sendSignal(
++ *this,
++ "systemPropertyChanged",
++ "(qn)",
++ systemProperty
++ );
++}
++/**
++ * This callback is fired if the timinginformation for a mainConnectionID changed
++ */
++void CommandControlDBusStubAdapterInternal::fireTimingInformationChangedEvent(const am_mainConnectionID_t& mainConnectionID, const am_timeSync_t& time) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t, am_timeSync_t>>
++ ::sendSignal(
++ *this,
++ "timingInformationChanged",
++ "qn",
++ mainConnectionID, time
++ );
++}
++/**
++ * This callback is called when a sink is updated.
++ */
++void CommandControlDBusStubAdapterInternal::fireSinkUpdatedEvent(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_MainSoundProperty_L& listMainSoundProperties) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_sinkClass_t, am_MainSoundProperty_L>>
++ ::sendSignal(
++ *this,
++ "sinkUpdated",
++ "qqa(qn)",
++ sinkID, sinkClassID, listMainSoundProperties
++ );
++}
++/**
++ * This callback is called when a source is updated.
++ */
++void CommandControlDBusStubAdapterInternal::fireSourceUpdatedEvent(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_MainSoundProperty_L& listMainSoundProperties) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_sourceClass_t, am_MainSoundProperty_L>>
++ ::sendSignal(
++ *this,
++ "sourceUpdated",
++ "qqa(qn)",
++ sourceID, sourceClassID, listMainSoundProperties
++ );
++}
++/**
++ * This callback is called when a notificated value of a sink changes.
++ */
++void CommandControlDBusStubAdapterInternal::fireSinkNotificationEvent(const am_sinkID_t& sinkID, const am_NotificationPayload_s& notification) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_NotificationPayload_s>>
++ ::sendSignal(
++ *this,
++ "sinkNotification",
++ "q(qn)",
++ sinkID, notification
++ );
++}
++/**
++ * This callback is called when a notifcated value of a source changes.
++ */
++void CommandControlDBusStubAdapterInternal::fireSourceNotificationEvent(const am_sourceID_t& sourceID, const am_NotificationPayload_s& notification) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_NotificationPayload_s>>
++ ::sendSignal(
++ *this,
++ "sourceNotification",
++ "q(qn)",
++ sourceID, notification
++ );
++}
++/**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++void CommandControlDBusStubAdapterInternal::fireMainSinkNotificationConfigurationChangedEvent(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_NotificationConfiguration_s>>
++ ::sendSignal(
++ *this,
++ "mainSinkNotificationConfigurationChanged",
++ "q(qin)",
++ sinkID, mainNotificationConfiguration
++ );
++}
++/**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++void CommandControlDBusStubAdapterInternal::fireMainSourceNotificationConfigurationChangedEvent(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration) {
++ CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_NotificationConfiguration_s>>
++ ::sendSignal(
++ *this,
++ "mainSourceNotificationConfigurationChanged",
++ "q(qin)",
++ sourceID, mainNotificationConfiguration
++ );
++}
++
++
++const CommandControlDBusStubAdapterHelper::StubDispatcherTable& CommandControlDBusStubAdapterInternal::getStubDispatcherTable() {
++ return stubDispatcherTable_;
++}
++
++const CommonAPI::DBus::StubAttributeTable& CommandControlDBusStubAdapterInternal::getStubAttributeTable() {
++ return stubAttributeTable_;
++}
++
++CommandControlDBusStubAdapterInternal::CommandControlDBusStubAdapterInternal(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& dbusInterfaceName,
++ const std::string& dbusBusName,
++ const std::string& dbusObjectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection,
++ const std::shared_ptr<CommonAPI::StubBase>& stub):
++ CommonAPI::DBus::DBusStubAdapter(
++ factory,
++ commonApiAddress,
++ dbusInterfaceName,
++ dbusBusName,
++ dbusObjectPath,
++ dbusConnection,
++ false),
++ CommandControlDBusStubAdapterHelper(
++ factory,
++ commonApiAddress,
++ dbusInterfaceName,
++ dbusBusName,
++ dbusObjectPath,
++ dbusConnection,
++ std::dynamic_pointer_cast<CommandControlStub>(stub),
++ false),
++ stubDispatcherTable_({
++ /**
++ * connects a source to sink
++ (at)return E_OK on success, E_NOT_POSSIBLE on
++ * failure, E_ALREADY_EXISTS if the connection does already exists
++ */
++ { { "connect", "qq" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::connectStubDispatcher },
++ /**
++ * disconnects a mainConnection
++ (at)return E_OK on successes, E_NON_EXISTENT if
++ * the connection does not exist, E_NOT_POSSIBLE on error.
++ */
++ { { "disconnect", "q" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::disconnectStubDispatcher },
++ /**
++ * sets the volume for a sink
++ (at)return E_OK on success, E_UNKOWN on error,
++ * E_OUT_OF_RANGE in case the value is out of range
++ */
++ { { "setVolume", "qn" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::setVolumeStubDispatcher },
++ /**
++ * This function is used to increment or decrement the current volume for a
++ * sink.
++ (at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the
++ * value is not in the given volume range.
++ */
++ { { "volumeStep", "qn" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::volumeStepStubDispatcher },
++ /**
++ * sets the mute state of a sink
++ (at)return E_OK on success, E_UNKNOWN on error.
++ * If the mute state is already the desired one, the Daemon will return E_OK.
++ */
++ { { "setSinkMuteState", "qi" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::setSinkMuteStateStubDispatcher },
++ /**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++ (at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++ { { "setMainSinkSoundProperty", "q(qn)" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::setMainSinkSoundPropertyStubDispatcher },
++ /**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++ (at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++ { { "setMainSourceSoundProperty", "q(qn)" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::setMainSourceSoundPropertyStubDispatcher },
++ /**
++ * is used to set a specific system property.
++ (at)return E_OK on success,
++ * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error
++ */
++ { { "setSystemProperty", "(qn)" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::setSystemPropertyStubDispatcher },
++ /**
++ * returns the actual list of MainConnections
++ (at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++ { { "getListMainConnections", "" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListMainConnectionsStubDispatcher },
++ /**
++ * returns the actual list of Sinks
++ (at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++ { { "getListMainSinks", "" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListMainSinksStubDispatcher },
++ /**
++ * returns the actual list of Sources
++ (at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++ { { "getListMainSources", "" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListMainSourcesStubDispatcher },
++ /**
++ * This is used to retrieve all source sound properties related to a source.
++ * Returns a vector of the sound properties and values as pair
++ (at)return E_OK on
++ * success, E_DATABASE_ERROR on error
++ */
++ { { "getListMainSinkSoundProperties", "q" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListMainSinkSoundPropertiesStubDispatcher },
++ /**
++ * This is used to retrieve all source sound properties related to a
++ * source.
++ (at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++ { { "getListMainSourceSoundProperties", "q" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListMainSourceSoundPropertiesStubDispatcher },
++ /**
++ * This is used to retrieve SourceClass Information of all source classes
++ *
++ (at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++ { { "getListSourceClasses", "" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListSourceClassesStubDispatcher },
++ /**
++ * This is used to retrieve SinkClass Information of all sink classes
++ (at)return
++ * E_OK on success, E_DATABASE_ERROR on error
++ */
++ { { "getListSinkClasses", "" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListSinkClassesStubDispatcher },
++ /**
++ * Retrieves a complete list of all systemProperties.
++ (at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++ { { "getListSystemProperties", "" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListSystemPropertiesStubDispatcher },
++ /**
++ * returns the delay in ms that the audiopath for the given mainConnection
++ * has
++ (at)return E_OK on success, E_NOT_POSSIBLE if timing information is not
++ * yet retrieved, E_DATABASE_ERROR on read error on the database
++ */
++ { { "getTimingInformation", "q" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getTimingInformationStubDispatcher },
++ /**
++ * Retrieves the list of MainNotifications for a sink. Does not return the
++ * possible ones.
++ */
++ { { "getListMainSinkNotificationConfigurations", "q" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListMainSinkNotificationConfigurationsStubDispatcher },
++ /**
++ * Retrieves the list of MainNotifications for a source. Does not return the
++ * possible ones.
++ */
++ { { "getListMainSourceNotificationConfigurations", "q" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListMainSourceNotificationConfigurationsStubDispatcher },
++ /**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++ (at)return E_OK on
++ * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error
++ */
++ { { "setMainSinkNotificationConfiguration", "q(qin)" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::setMainSinkNotificationConfigurationStubDispatcher },
++ /**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++ (at)return E_OK on
++ * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error
++ */
++ { { "setMainSourceNotificationConfiguration", "q(qin)" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::setMainSourceNotificationConfigurationStubDispatcher }
++ }),
++ stubAttributeTable_() {
++
++ stubDispatcherTable_.insert({ { "getInterfaceVersion", "" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getCommandControlInterfaceVersionStubDispatcher });
++}
++
++const bool CommandControlDBusStubAdapterInternal::hasFreedesktopProperties() {
++ return false;
++}
++
++} // namespace am
++} // namespace genivi
++} // namespace org
+diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusStubAdapter.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusStubAdapter.h
+new file mode 100644
+index 0000000..0909211
+--- /dev/null
++++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusStubAdapter.h
+@@ -0,0 +1,422 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * The interface towards the Controlling Instance (e.g HMI). It handles the
++ * communication towards the HMI and other system components who need to interact
++ * with the audiomanagement.
++There are two rules that have to be kept in mind
++ * when implementing against this interface:
++ * @author Christian Mueller
++ */
++#ifndef ORG_GENIVI_AM_Command_Control_DBUS_STUB_ADAPTER_H_
++#define ORG_GENIVI_AM_Command_Control_DBUS_STUB_ADAPTER_H_
++
++#include <org/genivi/am/CommandControlStub.h>
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <CommonAPI/DBus/DBusStubAdapterHelper.h>
++#include <CommonAPI/DBus/DBusStubAdapter.h>
++#include <CommonAPI/DBus/DBusFactory.h>
++#include <CommonAPI/DBus/DBusServicePublisher.h>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++namespace am {
++
++typedef CommonAPI::DBus::DBusStubAdapterHelper<CommandControlStub> CommandControlDBusStubAdapterHelper;
++
++class CommandControlDBusStubAdapterInternal: public virtual CommandControlStubAdapter, public CommandControlDBusStubAdapterHelper {
++ public:
++ CommandControlDBusStubAdapterInternal(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& dbusInterfaceName,
++ const std::string& dbusBusName,
++ const std::string& dbusObjectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection,
++ const std::shared_ptr<CommonAPI::StubBase>& stub);
++
++ ~CommandControlDBusStubAdapterInternal();
++
++ virtual const bool hasFreedesktopProperties();
++
++
++ /**
++ * Callback that is called when the number of connections change
++ */
++ void fireNewMainConnectionEvent(const am_MainConnectionType_s& mainConnection);
++ /**
++ * Callback that is called when the number of connections change
++ */
++ void fireRemovedMainConnectionEvent(const am_mainConnectionID_t& mainConnection);
++ /**
++ * Callback that is called when the number of sinks change
++ */
++ void fireNewSinkEvent(const am_SinkType_s& sink);
++ /**
++ * Callback that is called when the number of sinks change
++ */
++ void fireRemovedSinkEvent(const am_sinkID_t& sinkID);
++ /**
++ * Callback that is called when the number of sources change
++ */
++ void fireNewSourceEvent(const am_SourceType_s& source);
++ /**
++ * Callback that is called when the number of sources change
++ */
++ void fireRemovedSourceEvent(const am_sourceID_t& source);
++ /**
++ * this callback is fired if the number of sink classes changed
++ */
++ void fireNumberOfSinkClassesChangedEvent();
++ /**
++ * this callback is fired if the number of source classes changed
++ */
++ void fireNumberOfSourceClassesChangedEvent();
++ /**
++ * This callback is called when the ConnectionState of a connection changed.
++ */
++ void fireMainConnectionStateChangedEvent(const am_mainConnectionID_t& connectionID, const am_ConnectionState_e& connectionState);
++ /**
++ * this callback indicates that a sinkSoundProperty has changed.
++ */
++ void fireMainSinkSoundPropertyChangedEvent(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty);
++ /**
++ * this callback indicates that a sourceSoundProperty has changed.
++ */
++ void fireMainSourceSoundPropertyChangedEvent(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty);
++ /**
++ * this callback is called when the availability of a sink has changed
++ */
++ void fireSinkAvailabilityChangedEvent(const am_sinkID_t& sinkID, const am_Availability_s& availability);
++ /**
++ * this callback is called when the availability of source has changed.
++ */
++ void fireSourceAvailabilityChangedEvent(const am_sourceID_t& sourceID, const am_Availability_s& availability);
++ /**
++ * this callback indicates a volume change on the indicated sink
++ */
++ void fireVolumeChangedEvent(const am_sinkID_t& sinkID, const am_mainVolume_t& volume);
++ /**
++ * this callback indicates a mute state change on a sink.
++ */
++ void fireSinkMuteStateChangedEvent(const am_sinkID_t& sinkID, const am_MuteState_e& muteState);
++ /**
++ * is fired if a systemProperty changed
++ */
++ void fireSystemPropertyChangedEvent(const am_SystemProperty_s& systemProperty);
++ /**
++ * This callback is fired if the timinginformation for a mainConnectionID changed
++ */
++ void fireTimingInformationChangedEvent(const am_mainConnectionID_t& mainConnectionID, const am_timeSync_t& time);
++ /**
++ * This callback is called when a sink is updated.
++ */
++ void fireSinkUpdatedEvent(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_MainSoundProperty_L& listMainSoundProperties);
++ /**
++ * This callback is called when a source is updated.
++ */
++ void fireSourceUpdatedEvent(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_MainSoundProperty_L& listMainSoundProperties);
++ /**
++ * This callback is called when a notificated value of a sink changes.
++ */
++ void fireSinkNotificationEvent(const am_sinkID_t& sinkID, const am_NotificationPayload_s& notification);
++ /**
++ * This callback is called when a notifcated value of a source changes.
++ */
++ void fireSourceNotificationEvent(const am_sourceID_t& sourceID, const am_NotificationPayload_s& notification);
++ /**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++ void fireMainSinkNotificationConfigurationChangedEvent(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration);
++ /**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++ void fireMainSourceNotificationConfigurationChangedEvent(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration);
++
++
++ const CommandControlDBusStubAdapterHelper::StubDispatcherTable& getStubDispatcherTable();
++ const CommonAPI::DBus::StubAttributeTable& getStubAttributeTable();
++
++ void deactivateManagedInstances();
++
++
++static CommonAPI::DBus::DBusGetAttributeStubDispatcher<
++ CommandControlStub,
++ CommonAPI::Version
++ > getCommandControlInterfaceVersionStubDispatcher;
++
++
++
++/**
++ * connects a source to sink
++(at)return E_OK on success, E_NOT_POSSIBLE on
++ * failure, E_ALREADY_EXISTS if the connection does already exists
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sourceID_t, am_sinkID_t>,
++ std::tuple<am_mainConnectionID_t, am_Error_e>
++ > connectStubDispatcher;
++/**
++ * disconnects a mainConnection
++(at)return E_OK on successes, E_NON_EXISTENT if
++ * the connection does not exist, E_NOT_POSSIBLE on error.
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_mainConnectionID_t>,
++ std::tuple<am_Error_e>
++ > disconnectStubDispatcher;
++/**
++ * sets the volume for a sink
++(at)return E_OK on success, E_UNKOWN on error,
++ * E_OUT_OF_RANGE in case the value is out of range
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sinkID_t, am_mainVolume_t>,
++ std::tuple<am_Error_e>
++ > setVolumeStubDispatcher;
++/**
++ * This function is used to increment or decrement the current volume for a
++ * sink.
++(at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the
++ * value is not in the given volume range.
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sinkID_t, int16_t>,
++ std::tuple<am_Error_e>
++ > volumeStepStubDispatcher;
++/**
++ * sets the mute state of a sink
++(at)return E_OK on success, E_UNKNOWN on error.
++ * If the mute state is already the desired one, the Daemon will return E_OK.
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sinkID_t, am_MuteState_e>,
++ std::tuple<am_Error_e>
++ > setSinkMuteStateStubDispatcher;
++/**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++(at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sinkID_t, am_MainSoundProperty_s>,
++ std::tuple<am_Error_e>
++ > setMainSinkSoundPropertyStubDispatcher;
++/**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++(at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sourceID_t, am_MainSoundProperty_s>,
++ std::tuple<am_Error_e>
++ > setMainSourceSoundPropertyStubDispatcher;
++/**
++ * is used to set a specific system property.
++(at)return E_OK on success,
++ * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_SystemProperty_s>,
++ std::tuple<am_Error_e>
++ > setSystemPropertyStubDispatcher;
++/**
++ * returns the actual list of MainConnections
++(at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<>,
++ std::tuple<am_MainConnection_L, am_Error_e>
++ > getListMainConnectionsStubDispatcher;
++/**
++ * returns the actual list of Sinks
++(at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<>,
++ std::tuple<am_SinkType_L, am_Error_e>
++ > getListMainSinksStubDispatcher;
++/**
++ * returns the actual list of Sources
++(at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<>,
++ std::tuple<am_SourceType_L, am_Error_e>
++ > getListMainSourcesStubDispatcher;
++/**
++ * This is used to retrieve all source sound properties related to a source.
++ * Returns a vector of the sound properties and values as pair
++(at)return E_OK on
++ * success, E_DATABASE_ERROR on error
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sinkID_t>,
++ std::tuple<am_MainSoundProperty_L, am_Error_e>
++ > getListMainSinkSoundPropertiesStubDispatcher;
++/**
++ * This is used to retrieve all source sound properties related to a
++ * source.
++(at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sourceID_t>,
++ std::tuple<am_MainSoundProperty_L, am_Error_e>
++ > getListMainSourceSoundPropertiesStubDispatcher;
++/**
++ * This is used to retrieve SourceClass Information of all source classes
++ *
++(at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<>,
++ std::tuple<am_SourceClass_L, am_Error_e>
++ > getListSourceClassesStubDispatcher;
++/**
++ * This is used to retrieve SinkClass Information of all sink classes
++(at)return
++ * E_OK on success, E_DATABASE_ERROR on error
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<>,
++ std::tuple<am_SinkClass_L, am_Error_e>
++ > getListSinkClassesStubDispatcher;
++/**
++ * Retrieves a complete list of all systemProperties.
++(at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<>,
++ std::tuple<am_SystemProperty_L, am_Error_e>
++ > getListSystemPropertiesStubDispatcher;
++/**
++ * returns the delay in ms that the audiopath for the given mainConnection
++ * has
++(at)return E_OK on success, E_NOT_POSSIBLE if timing information is not
++ * yet retrieved, E_DATABASE_ERROR on read error on the database
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_mainConnectionID_t>,
++ std::tuple<am_timeSync_t, am_Error_e>
++ > getTimingInformationStubDispatcher;
++/**
++ * Retrieves the list of MainNotifications for a sink. Does not return the
++ * possible ones.
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sinkID_t>,
++ std::tuple<am_NotificationConfiguration_L, am_Error_e>
++ > getListMainSinkNotificationConfigurationsStubDispatcher;
++/**
++ * Retrieves the list of MainNotifications for a source. Does not return the
++ * possible ones.
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sourceID_t>,
++ std::tuple<am_NotificationConfiguration_L, am_Error_e>
++ > getListMainSourceNotificationConfigurationsStubDispatcher;
++/**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++(at)return E_OK on
++ * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sinkID_t, am_NotificationConfiguration_s>,
++ std::tuple<am_Error_e>
++ > setMainSinkNotificationConfigurationStubDispatcher;
++/**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++(at)return E_OK on
++ * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error
++ */
++static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
++ CommandControlStub,
++ std::tuple<am_sourceID_t, am_NotificationConfiguration_s>,
++ std::tuple<am_Error_e>
++ > setMainSourceNotificationConfigurationStubDispatcher;
++
++
++
++
++ protected:
++ virtual const char* getMethodsDBusIntrospectionXmlData() const;
++
++ private:
++ CommandControlDBusStubAdapterHelper::StubDispatcherTable stubDispatcherTable_;
++ CommonAPI::DBus::StubAttributeTable stubAttributeTable_;
++};
++
++class CommandControlDBusStubAdapter: public CommandControlDBusStubAdapterInternal, public std::enable_shared_from_this<CommandControlDBusStubAdapter> {
++public:
++ CommandControlDBusStubAdapter(
++ const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory,
++ const std::string& commonApiAddress,
++ const std::string& dbusInterfaceName,
++ const std::string& dbusBusName,
++ const std::string& dbusObjectPath,
++ const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection,
++ const std::shared_ptr<CommonAPI::StubBase>& stub) :
++ CommonAPI::DBus::DBusStubAdapter(
++ factory,
++ commonApiAddress,
++ dbusInterfaceName,
++ dbusBusName,
++ dbusObjectPath,
++ dbusConnection,
++ false),
++ CommandControlDBusStubAdapterInternal(
++ factory,
++ commonApiAddress,
++ dbusInterfaceName,
++ dbusBusName,
++ dbusObjectPath,
++ dbusConnection,
++ stub) { }
++};
++
++} // namespace am
++} // namespace genivi
++} // namespace org
++
++#endif // ORG_GENIVI_AM_Command_Control_DBUS_STUB_ADAPTER_H_
+diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlProxy.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlProxy.h
+new file mode 100644
+index 0000000..03e6a62
+--- /dev/null
++++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlProxy.h
+@@ -0,0 +1,1194 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * The interface towards the Controlling Instance (e.g HMI). It handles the
++ * communication towards the HMI and other system components who need to interact
++ * with the audiomanagement.
++There are two rules that have to be kept in mind
++ * when implementing against this interface:
++ * @author Christian Mueller
++ */
++#ifndef ORG_GENIVI_AM_Command_Control_PROXY_H_
++#define ORG_GENIVI_AM_Command_Control_PROXY_H_
++
++#include "CommandControlProxyBase.h"
++
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++namespace am {
++
++template <typename ... _AttributeExtensions>
++class CommandControlProxy: virtual public CommandControl, virtual public CommandControlProxyBase
++, public _AttributeExtensions... {
++public:
++ CommandControlProxy(std::shared_ptr<CommonAPI::Proxy> delegate);
++ ~CommandControlProxy();
++
++ typedef CommandControl InterfaceType;
++
++
++
++ /**
++ * Callback that is called when the number of connections change
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast newMainConnection.
++ */
++ virtual NewMainConnectionEvent& getNewMainConnectionEvent() {
++ return delegate_->getNewMainConnectionEvent();
++ }
++ /**
++ * Callback that is called when the number of connections change
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast removedMainConnection.
++ */
++ virtual RemovedMainConnectionEvent& getRemovedMainConnectionEvent() {
++ return delegate_->getRemovedMainConnectionEvent();
++ }
++ /**
++ * Callback that is called when the number of sinks change
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast newSink.
++ */
++ virtual NewSinkEvent& getNewSinkEvent() {
++ return delegate_->getNewSinkEvent();
++ }
++ /**
++ * Callback that is called when the number of sinks change
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast removedSink.
++ */
++ virtual RemovedSinkEvent& getRemovedSinkEvent() {
++ return delegate_->getRemovedSinkEvent();
++ }
++ /**
++ * Callback that is called when the number of sources change
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast newSource.
++ */
++ virtual NewSourceEvent& getNewSourceEvent() {
++ return delegate_->getNewSourceEvent();
++ }
++ /**
++ * Callback that is called when the number of sources change
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast removedSource.
++ */
++ virtual RemovedSourceEvent& getRemovedSourceEvent() {
++ return delegate_->getRemovedSourceEvent();
++ }
++ /**
++ * this callback is fired if the number of sink classes changed
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast numberOfSinkClassesChanged.
++ */
++ virtual NumberOfSinkClassesChangedEvent& getNumberOfSinkClassesChangedEvent() {
++ return delegate_->getNumberOfSinkClassesChangedEvent();
++ }
++ /**
++ * this callback is fired if the number of source classes changed
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast numberOfSourceClassesChanged.
++ */
++ virtual NumberOfSourceClassesChangedEvent& getNumberOfSourceClassesChangedEvent() {
++ return delegate_->getNumberOfSourceClassesChangedEvent();
++ }
++ /**
++ * This callback is called when the ConnectionState of a connection changed.
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast mainConnectionStateChanged.
++ */
++ virtual MainConnectionStateChangedEvent& getMainConnectionStateChangedEvent() {
++ return delegate_->getMainConnectionStateChangedEvent();
++ }
++ /**
++ * this callback indicates that a sinkSoundProperty has changed.
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast mainSinkSoundPropertyChanged.
++ */
++ virtual MainSinkSoundPropertyChangedEvent& getMainSinkSoundPropertyChangedEvent() {
++ return delegate_->getMainSinkSoundPropertyChangedEvent();
++ }
++ /**
++ * this callback indicates that a sourceSoundProperty has changed.
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast mainSourceSoundPropertyChanged.
++ */
++ virtual MainSourceSoundPropertyChangedEvent& getMainSourceSoundPropertyChangedEvent() {
++ return delegate_->getMainSourceSoundPropertyChangedEvent();
++ }
++ /**
++ * this callback is called when the availability of a sink has changed
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast sinkAvailabilityChanged.
++ */
++ virtual SinkAvailabilityChangedEvent& getSinkAvailabilityChangedEvent() {
++ return delegate_->getSinkAvailabilityChangedEvent();
++ }
++ /**
++ * this callback is called when the availability of source has changed.
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast sourceAvailabilityChanged.
++ */
++ virtual SourceAvailabilityChangedEvent& getSourceAvailabilityChangedEvent() {
++ return delegate_->getSourceAvailabilityChangedEvent();
++ }
++ /**
++ * this callback indicates a volume change on the indicated sink
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast volumeChanged.
++ */
++ virtual VolumeChangedEvent& getVolumeChangedEvent() {
++ return delegate_->getVolumeChangedEvent();
++ }
++ /**
++ * this callback indicates a mute state change on a sink.
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast sinkMuteStateChanged.
++ */
++ virtual SinkMuteStateChangedEvent& getSinkMuteStateChangedEvent() {
++ return delegate_->getSinkMuteStateChangedEvent();
++ }
++ /**
++ * is fired if a systemProperty changed
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast systemPropertyChanged.
++ */
++ virtual SystemPropertyChangedEvent& getSystemPropertyChangedEvent() {
++ return delegate_->getSystemPropertyChangedEvent();
++ }
++ /**
++ * This callback is fired if the timinginformation for a mainConnectionID changed
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast timingInformationChanged.
++ */
++ virtual TimingInformationChangedEvent& getTimingInformationChangedEvent() {
++ return delegate_->getTimingInformationChangedEvent();
++ }
++ /**
++ * This callback is called when a sink is updated.
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast sinkUpdated.
++ */
++ virtual SinkUpdatedEvent& getSinkUpdatedEvent() {
++ return delegate_->getSinkUpdatedEvent();
++ }
++ /**
++ * This callback is called when a source is updated.
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast sourceUpdated.
++ */
++ virtual SourceUpdatedEvent& getSourceUpdatedEvent() {
++ return delegate_->getSourceUpdatedEvent();
++ }
++ /**
++ * This callback is called when a notificated value of a sink changes.
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast sinkNotification.
++ */
++ virtual SinkNotificationEvent& getSinkNotificationEvent() {
++ return delegate_->getSinkNotificationEvent();
++ }
++ /**
++ * This callback is called when a notifcated value of a source changes.
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast sourceNotification.
++ */
++ virtual SourceNotificationEvent& getSourceNotificationEvent() {
++ return delegate_->getSourceNotificationEvent();
++ }
++ /**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast mainSinkNotificationConfigurationChanged.
++ */
++ virtual MainSinkNotificationConfigurationChangedEvent& getMainSinkNotificationConfigurationChangedEvent() {
++ return delegate_->getMainSinkNotificationConfigurationChangedEvent();
++ }
++ /**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++ /**
++ * Returns the wrapper class that provides access to the broadcast mainSourceNotificationConfigurationChanged.
++ */
++ virtual MainSourceNotificationConfigurationChangedEvent& getMainSourceNotificationConfigurationChangedEvent() {
++ return delegate_->getMainSourceNotificationConfigurationChangedEvent();
++ }
++
++ /**
++ * connects a source to sink
++ (at)return E_OK on success, E_NOT_POSSIBLE on
++ * failure, E_ALREADY_EXISTS if the connection does already exists
++ *
++ * Calls connect with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void connect(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_mainConnectionID_t& mainConnectionID, am_Error_e& error);
++ /**
++ * Calls connect with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> connectAsync(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, ConnectAsyncCallback callback);
++ /**
++ * disconnects a mainConnection
++ (at)return E_OK on successes, E_NON_EXISTENT if
++ * the connection does not exist, E_NOT_POSSIBLE on error.
++ *
++ * Calls disconnect with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void disconnect(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ /**
++ * Calls disconnect with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> disconnectAsync(const am_mainConnectionID_t& mainConnectionID, DisconnectAsyncCallback callback);
++ /**
++ * sets the volume for a sink
++ (at)return E_OK on success, E_UNKOWN on error,
++ * E_OUT_OF_RANGE in case the value is out of range
++ *
++ * Calls setVolume with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void setVolume(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ /**
++ * Calls setVolume with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> setVolumeAsync(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, SetVolumeAsyncCallback callback);
++ /**
++ * This function is used to increment or decrement the current volume for a
++ * sink.
++ (at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the
++ * value is not in the given volume range.
++ *
++ * Calls volumeStep with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void volumeStep(const am_sinkID_t& sinkID, const int16_t& volStep, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ /**
++ * Calls volumeStep with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> volumeStepAsync(const am_sinkID_t& sinkID, const int16_t& volStep, VolumeStepAsyncCallback callback);
++ /**
++ * sets the mute state of a sink
++ (at)return E_OK on success, E_UNKNOWN on error.
++ * If the mute state is already the desired one, the Daemon will return E_OK.
++ *
++ * Calls setSinkMuteState with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void setSinkMuteState(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ /**
++ * Calls setSinkMuteState with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> setSinkMuteStateAsync(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, SetSinkMuteStateAsyncCallback callback);
++ /**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++ (at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ *
++ * Calls setMainSinkSoundProperty with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void setMainSinkSoundProperty(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ /**
++ * Calls setMainSinkSoundProperty with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> setMainSinkSoundPropertyAsync(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, SetMainSinkSoundPropertyAsyncCallback callback);
++ /**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++ (at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ *
++ * Calls setMainSourceSoundProperty with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void setMainSourceSoundProperty(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ /**
++ * Calls setMainSourceSoundProperty with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> setMainSourceSoundPropertyAsync(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, SetMainSourceSoundPropertyAsyncCallback callback);
++ /**
++ * is used to set a specific system property.
++ (at)return E_OK on success,
++ * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error
++ *
++ * Calls setSystemProperty with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void setSystemProperty(const am_SystemProperty_s& property, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ /**
++ * Calls setSystemProperty with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> setSystemPropertyAsync(const am_SystemProperty_s& property, SetSystemPropertyAsyncCallback callback);
++ /**
++ * returns the actual list of MainConnections
++ (at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ *
++ * Calls getListMainConnections with synchronous semantics.
++ *
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void getListMainConnections(CommonAPI::CallStatus& callStatus, am_MainConnection_L& listConnections, am_Error_e& error);
++ /**
++ * Calls getListMainConnections with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> getListMainConnectionsAsync(GetListMainConnectionsAsyncCallback callback);
++ /**
++ * returns the actual list of Sinks
++ (at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ *
++ * Calls getListMainSinks with synchronous semantics.
++ *
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void getListMainSinks(CommonAPI::CallStatus& callStatus, am_SinkType_L& listMainSinks, am_Error_e& error);
++ /**
++ * Calls getListMainSinks with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> getListMainSinksAsync(GetListMainSinksAsyncCallback callback);
++ /**
++ * returns the actual list of Sources
++ (at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ *
++ * Calls getListMainSources with synchronous semantics.
++ *
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void getListMainSources(CommonAPI::CallStatus& callStatus, am_SourceType_L& listMainSources, am_Error_e& error);
++ /**
++ * Calls getListMainSources with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> getListMainSourcesAsync(GetListMainSourcesAsyncCallback callback);
++ /**
++ * This is used to retrieve all source sound properties related to a source.
++ * Returns a vector of the sound properties and values as pair
++ (at)return E_OK on
++ * success, E_DATABASE_ERROR on error
++ *
++ * Calls getListMainSinkSoundProperties with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void getListMainSinkSoundProperties(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error);
++ /**
++ * Calls getListMainSinkSoundProperties with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> getListMainSinkSoundPropertiesAsync(const am_sinkID_t& sinkID, GetListMainSinkSoundPropertiesAsyncCallback callback);
++ /**
++ * This is used to retrieve all source sound properties related to a
++ * source.
++ (at)return E_OK on success, E_DATABASE_ERROR on error
++ *
++ * Calls getListMainSourceSoundProperties with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void getListMainSourceSoundProperties(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error);
++ /**
++ * Calls getListMainSourceSoundProperties with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> getListMainSourceSoundPropertiesAsync(const am_sourceID_t& sourceID, GetListMainSourceSoundPropertiesAsyncCallback callback);
++ /**
++ * This is used to retrieve SourceClass Information of all source classes
++ *
++ (at)return E_OK on success, E_DATABASE_ERROR on error
++ *
++ * Calls getListSourceClasses with synchronous semantics.
++ *
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void getListSourceClasses(CommonAPI::CallStatus& callStatus, am_SourceClass_L& listSourceClasses, am_Error_e& error);
++ /**
++ * Calls getListSourceClasses with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> getListSourceClassesAsync(GetListSourceClassesAsyncCallback callback);
++ /**
++ * This is used to retrieve SinkClass Information of all sink classes
++ (at)return
++ * E_OK on success, E_DATABASE_ERROR on error
++ *
++ * Calls getListSinkClasses with synchronous semantics.
++ *
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void getListSinkClasses(CommonAPI::CallStatus& callStatus, am_SinkClass_L& listSinkClasses, am_Error_e& error);
++ /**
++ * Calls getListSinkClasses with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> getListSinkClassesAsync(GetListSinkClassesAsyncCallback callback);
++ /**
++ * Retrieves a complete list of all systemProperties.
++ (at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ *
++ * Calls getListSystemProperties with synchronous semantics.
++ *
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void getListSystemProperties(CommonAPI::CallStatus& callStatus, am_SystemProperty_L& listSystemProperties, am_Error_e& error);
++ /**
++ * Calls getListSystemProperties with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> getListSystemPropertiesAsync(GetListSystemPropertiesAsyncCallback callback);
++ /**
++ * returns the delay in ms that the audiopath for the given mainConnection
++ * has
++ (at)return E_OK on success, E_NOT_POSSIBLE if timing information is not
++ * yet retrieved, E_DATABASE_ERROR on read error on the database
++ *
++ * Calls getTimingInformation with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void getTimingInformation(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_timeSync_t& delay, am_Error_e& error);
++ /**
++ * Calls getTimingInformation with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> getTimingInformationAsync(const am_mainConnectionID_t& mainConnectionID, GetTimingInformationAsyncCallback callback);
++ /**
++ * Retrieves the list of MainNotifications for a sink. Does not return the
++ * possible ones.
++ *
++ * Calls getListMainSinkNotificationConfigurations with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void getListMainSinkNotificationConfigurations(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error);
++ /**
++ * Calls getListMainSinkNotificationConfigurations with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> getListMainSinkNotificationConfigurationsAsync(const am_sinkID_t& sinkID, GetListMainSinkNotificationConfigurationsAsyncCallback callback);
++ /**
++ * Retrieves the list of MainNotifications for a source. Does not return the
++ * possible ones.
++ *
++ * Calls getListMainSourceNotificationConfigurations with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void getListMainSourceNotificationConfigurations(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error);
++ /**
++ * Calls getListMainSourceNotificationConfigurations with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> getListMainSourceNotificationConfigurationsAsync(const am_sourceID_t& sourceID, GetListMainSourceNotificationConfigurationsAsyncCallback callback);
++ /**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++ (at)return E_OK on
++ * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error
++ *
++ * Calls setMainSinkNotificationConfiguration with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void setMainSinkNotificationConfiguration(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ /**
++ * Calls setMainSinkNotificationConfiguration with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> setMainSinkNotificationConfigurationAsync(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSinkNotificationConfigurationAsyncCallback callback);
++ /**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++ (at)return E_OK on
++ * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error
++ *
++ * Calls setMainSourceNotificationConfiguration with synchronous semantics.
++ *
++ * All const parameters are input parameters to this method.
++ * All non-const parameters will be filled with the returned values.
++ * The CallStatus will be filled when the method returns and indicate either
++ * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
++ * will be set.
++ */
++ virtual void setMainSourceNotificationConfiguration(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error);
++ /**
++ * Calls setMainSourceNotificationConfiguration with asynchronous semantics.
++ *
++ * The provided callback will be called when the reply to this call arrives or
++ * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
++ * or which type of error has occurred. In case of any error, ONLY the CallStatus
++ * will have a defined value.
++ * The std::future returned by this method will be fulfilled at arrival of the reply.
++ * It will provide the same value for CallStatus as will be handed to the callback.
++ */
++ virtual std::future<CommonAPI::CallStatus> setMainSourceNotificationConfigurationAsync(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSourceNotificationConfigurationAsyncCallback callback);
++
++
++ /**
++ * Returns the CommonAPI address of the remote partner this proxy communicates with.
++ */
++ virtual std::string getAddress() const;
++
++ /**
++ * Returns the domain of the remote partner this proxy communicates with.
++ */
++ virtual const std::string& getDomain() const;
++
++ /**
++ * Returns the service ID of the remote partner this proxy communicates with.
++ */
++ virtual const std::string& getServiceId() const;
++
++ /**
++ * Returns the instance ID of the remote partner this proxy communicates with.
++ */
++ virtual const std::string& getInstanceId() const;
++
++ /**
++ * Returns true if the remote partner for this proxy is currently known to be available.
++ */
++ virtual bool isAvailable() const;
++
++ /**
++ * Returns true if the remote partner for this proxy is available.
++ */
++ virtual bool isAvailableBlocking() const;
++
++ /**
++ * Returns the wrapper class that is used to (de-)register for notifications about
++ * the availability of the remote partner of this proxy.
++ */
++ virtual CommonAPI::ProxyStatusEvent& getProxyStatusEvent();
++
++ /**
++ * Returns the wrapper class that is used to access version information of the remote
++ * partner of this proxy.
++ */
++ virtual CommonAPI::InterfaceVersionAttribute& getInterfaceVersionAttribute();
++
++ private:
++ std::shared_ptr<CommandControlProxyBase> delegate_;
++};
++
++#ifdef WIN32
++ typedef CommandControlProxy<CommonAPI::WINDummyAttributeExtension<CommonAPI::WINDummyAttribute>> CommandControlProxyDefault;
++#else
++ typedef CommandControlProxy<> CommandControlProxyDefault;
++#endif
++
++
++//
++// CommandControlProxy Implementation
++//
++template <typename ... _AttributeExtensions>
++CommandControlProxy<_AttributeExtensions...>::CommandControlProxy(std::shared_ptr<CommonAPI::Proxy> delegate):
++ _AttributeExtensions(*(std::dynamic_pointer_cast<CommandControlProxyBase>(delegate)))...,
++ delegate_(std::dynamic_pointer_cast<CommandControlProxyBase>(delegate)) {
++}
++
++template <typename ... _AttributeExtensions>
++CommandControlProxy<_AttributeExtensions...>::~CommandControlProxy() {
++}
++
++/**
++ * connects a source to sink
++(at)return E_OK on success, E_NOT_POSSIBLE on
++ * failure, E_ALREADY_EXISTS if the connection does already exists
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::connect(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_mainConnectionID_t& mainConnectionID, am_Error_e& error) {
++ delegate_->connect(sourceID, sinkID, callStatus, mainConnectionID, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::connectAsync(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, ConnectAsyncCallback callback) {
++ return delegate_->connectAsync(sourceID, sinkID, callback);
++}
++/**
++ * disconnects a mainConnection
++(at)return E_OK on successes, E_NON_EXISTENT if
++ * the connection does not exist, E_NOT_POSSIBLE on error.
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::disconnect(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ delegate_->disconnect(mainConnectionID, callStatus, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::disconnectAsync(const am_mainConnectionID_t& mainConnectionID, DisconnectAsyncCallback callback) {
++ return delegate_->disconnectAsync(mainConnectionID, callback);
++}
++/**
++ * sets the volume for a sink
++(at)return E_OK on success, E_UNKOWN on error,
++ * E_OUT_OF_RANGE in case the value is out of range
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::setVolume(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ delegate_->setVolume(sinkID, volume, callStatus, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::setVolumeAsync(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, SetVolumeAsyncCallback callback) {
++ return delegate_->setVolumeAsync(sinkID, volume, callback);
++}
++/**
++ * This function is used to increment or decrement the current volume for a
++ * sink.
++(at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the
++ * value is not in the given volume range.
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::volumeStep(const am_sinkID_t& sinkID, const int16_t& volStep, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ delegate_->volumeStep(sinkID, volStep, callStatus, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::volumeStepAsync(const am_sinkID_t& sinkID, const int16_t& volStep, VolumeStepAsyncCallback callback) {
++ return delegate_->volumeStepAsync(sinkID, volStep, callback);
++}
++/**
++ * sets the mute state of a sink
++(at)return E_OK on success, E_UNKNOWN on error.
++ * If the mute state is already the desired one, the Daemon will return E_OK.
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::setSinkMuteState(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ delegate_->setSinkMuteState(sinkID, muteState, callStatus, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::setSinkMuteStateAsync(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, SetSinkMuteStateAsyncCallback callback) {
++ return delegate_->setSinkMuteStateAsync(sinkID, muteState, callback);
++}
++/**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++(at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::setMainSinkSoundProperty(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ delegate_->setMainSinkSoundProperty(sinkID, soundProperty, callStatus, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::setMainSinkSoundPropertyAsync(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, SetMainSinkSoundPropertyAsyncCallback callback) {
++ return delegate_->setMainSinkSoundPropertyAsync(sinkID, soundProperty, callback);
++}
++/**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++(at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::setMainSourceSoundProperty(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ delegate_->setMainSourceSoundProperty(sourceID, soundProperty, callStatus, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::setMainSourceSoundPropertyAsync(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, SetMainSourceSoundPropertyAsyncCallback callback) {
++ return delegate_->setMainSourceSoundPropertyAsync(sourceID, soundProperty, callback);
++}
++/**
++ * is used to set a specific system property.
++(at)return E_OK on success,
++ * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::setSystemProperty(const am_SystemProperty_s& property, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ delegate_->setSystemProperty(property, callStatus, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::setSystemPropertyAsync(const am_SystemProperty_s& property, SetSystemPropertyAsyncCallback callback) {
++ return delegate_->setSystemPropertyAsync(property, callback);
++}
++/**
++ * returns the actual list of MainConnections
++(at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::getListMainConnections(CommonAPI::CallStatus& callStatus, am_MainConnection_L& listConnections, am_Error_e& error) {
++ delegate_->getListMainConnections(callStatus, listConnections, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListMainConnectionsAsync(GetListMainConnectionsAsyncCallback callback) {
++ return delegate_->getListMainConnectionsAsync(callback);
++}
++/**
++ * returns the actual list of Sinks
++(at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::getListMainSinks(CommonAPI::CallStatus& callStatus, am_SinkType_L& listMainSinks, am_Error_e& error) {
++ delegate_->getListMainSinks(callStatus, listMainSinks, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListMainSinksAsync(GetListMainSinksAsyncCallback callback) {
++ return delegate_->getListMainSinksAsync(callback);
++}
++/**
++ * returns the actual list of Sources
++(at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::getListMainSources(CommonAPI::CallStatus& callStatus, am_SourceType_L& listMainSources, am_Error_e& error) {
++ delegate_->getListMainSources(callStatus, listMainSources, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListMainSourcesAsync(GetListMainSourcesAsyncCallback callback) {
++ return delegate_->getListMainSourcesAsync(callback);
++}
++/**
++ * This is used to retrieve all source sound properties related to a source.
++ * Returns a vector of the sound properties and values as pair
++(at)return E_OK on
++ * success, E_DATABASE_ERROR on error
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::getListMainSinkSoundProperties(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error) {
++ delegate_->getListMainSinkSoundProperties(sinkID, callStatus, listSoundProperties, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListMainSinkSoundPropertiesAsync(const am_sinkID_t& sinkID, GetListMainSinkSoundPropertiesAsyncCallback callback) {
++ return delegate_->getListMainSinkSoundPropertiesAsync(sinkID, callback);
++}
++/**
++ * This is used to retrieve all source sound properties related to a
++ * source.
++(at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::getListMainSourceSoundProperties(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error) {
++ delegate_->getListMainSourceSoundProperties(sourceID, callStatus, listSourceProperties, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListMainSourceSoundPropertiesAsync(const am_sourceID_t& sourceID, GetListMainSourceSoundPropertiesAsyncCallback callback) {
++ return delegate_->getListMainSourceSoundPropertiesAsync(sourceID, callback);
++}
++/**
++ * This is used to retrieve SourceClass Information of all source classes
++ *
++(at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::getListSourceClasses(CommonAPI::CallStatus& callStatus, am_SourceClass_L& listSourceClasses, am_Error_e& error) {
++ delegate_->getListSourceClasses(callStatus, listSourceClasses, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListSourceClassesAsync(GetListSourceClassesAsyncCallback callback) {
++ return delegate_->getListSourceClassesAsync(callback);
++}
++/**
++ * This is used to retrieve SinkClass Information of all sink classes
++(at)return
++ * E_OK on success, E_DATABASE_ERROR on error
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::getListSinkClasses(CommonAPI::CallStatus& callStatus, am_SinkClass_L& listSinkClasses, am_Error_e& error) {
++ delegate_->getListSinkClasses(callStatus, listSinkClasses, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListSinkClassesAsync(GetListSinkClassesAsyncCallback callback) {
++ return delegate_->getListSinkClassesAsync(callback);
++}
++/**
++ * Retrieves a complete list of all systemProperties.
++(at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::getListSystemProperties(CommonAPI::CallStatus& callStatus, am_SystemProperty_L& listSystemProperties, am_Error_e& error) {
++ delegate_->getListSystemProperties(callStatus, listSystemProperties, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListSystemPropertiesAsync(GetListSystemPropertiesAsyncCallback callback) {
++ return delegate_->getListSystemPropertiesAsync(callback);
++}
++/**
++ * returns the delay in ms that the audiopath for the given mainConnection
++ * has
++(at)return E_OK on success, E_NOT_POSSIBLE if timing information is not
++ * yet retrieved, E_DATABASE_ERROR on read error on the database
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::getTimingInformation(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_timeSync_t& delay, am_Error_e& error) {
++ delegate_->getTimingInformation(mainConnectionID, callStatus, delay, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getTimingInformationAsync(const am_mainConnectionID_t& mainConnectionID, GetTimingInformationAsyncCallback callback) {
++ return delegate_->getTimingInformationAsync(mainConnectionID, callback);
++}
++/**
++ * Retrieves the list of MainNotifications for a sink. Does not return the
++ * possible ones.
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::getListMainSinkNotificationConfigurations(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) {
++ delegate_->getListMainSinkNotificationConfigurations(sinkID, callStatus, listMainNotificationConfigurations, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListMainSinkNotificationConfigurationsAsync(const am_sinkID_t& sinkID, GetListMainSinkNotificationConfigurationsAsyncCallback callback) {
++ return delegate_->getListMainSinkNotificationConfigurationsAsync(sinkID, callback);
++}
++/**
++ * Retrieves the list of MainNotifications for a source. Does not return the
++ * possible ones.
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::getListMainSourceNotificationConfigurations(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) {
++ delegate_->getListMainSourceNotificationConfigurations(sourceID, callStatus, listMainNotificationConfigurations, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListMainSourceNotificationConfigurationsAsync(const am_sourceID_t& sourceID, GetListMainSourceNotificationConfigurationsAsyncCallback callback) {
++ return delegate_->getListMainSourceNotificationConfigurationsAsync(sourceID, callback);
++}
++/**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++(at)return E_OK on
++ * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::setMainSinkNotificationConfiguration(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ delegate_->setMainSinkNotificationConfiguration(sinkID, mainNotificationConfiguration, callStatus, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::setMainSinkNotificationConfigurationAsync(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSinkNotificationConfigurationAsyncCallback callback) {
++ return delegate_->setMainSinkNotificationConfigurationAsync(sinkID, mainNotificationConfiguration, callback);
++}
++/**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++(at)return E_OK on
++ * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error
++ */
++template <typename ... _AttributeExtensions>
++void CommandControlProxy<_AttributeExtensions...>::setMainSourceNotificationConfiguration(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
++ delegate_->setMainSourceNotificationConfiguration(sourceID, mainNotificationConfiguration, callStatus, error);
++}
++
++template <typename ... _AttributeExtensions>
++std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::setMainSourceNotificationConfigurationAsync(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSourceNotificationConfigurationAsyncCallback callback) {
++ return delegate_->setMainSourceNotificationConfigurationAsync(sourceID, mainNotificationConfiguration, callback);
++}
++
++template <typename ... _AttributeExtensions>
++std::string CommandControlProxy<_AttributeExtensions...>::getAddress() const {
++ return delegate_->getAddress();
++}
++
++template <typename ... _AttributeExtensions>
++const std::string& CommandControlProxy<_AttributeExtensions...>::getDomain() const {
++ return delegate_->getDomain();
++}
++
++template <typename ... _AttributeExtensions>
++const std::string& CommandControlProxy<_AttributeExtensions...>::getServiceId() const {
++ return delegate_->getServiceId();
++}
++
++template <typename ... _AttributeExtensions>
++const std::string& CommandControlProxy<_AttributeExtensions...>::getInstanceId() const {
++ return delegate_->getInstanceId();
++}
++
++template <typename ... _AttributeExtensions>
++bool CommandControlProxy<_AttributeExtensions...>::isAvailable() const {
++ return delegate_->isAvailable();
++}
++
++template <typename ... _AttributeExtensions>
++bool CommandControlProxy<_AttributeExtensions...>::isAvailableBlocking() const {
++ return delegate_->isAvailableBlocking();
++}
++
++template <typename ... _AttributeExtensions>
++CommonAPI::ProxyStatusEvent& CommandControlProxy<_AttributeExtensions...>::getProxyStatusEvent() {
++ return delegate_->getProxyStatusEvent();
++}
++
++template <typename ... _AttributeExtensions>
++CommonAPI::InterfaceVersionAttribute& CommandControlProxy<_AttributeExtensions...>::getInterfaceVersionAttribute() {
++ return delegate_->getInterfaceVersionAttribute();
++}
++
++
++} // namespace am
++} // namespace genivi
++} // namespace org
++
++
++#endif // ORG_GENIVI_AM_Command_Control_PROXY_H_
+diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlProxyBase.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlProxyBase.h
+new file mode 100644
+index 0000000..767b9e1
+--- /dev/null
++++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlProxyBase.h
+@@ -0,0 +1,348 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * The interface towards the Controlling Instance (e.g HMI). It handles the
++ * communication towards the HMI and other system components who need to interact
++ * with the audiomanagement.
++There are two rules that have to be kept in mind
++ * when implementing against this interface:
++ * @author Christian Mueller
++ */
++#ifndef ORG_GENIVI_AM_Command_Control_PROXY_BASE_H_
++#define ORG_GENIVI_AM_Command_Control_PROXY_BASE_H_
++
++#include "CommandControl.h"
++
++
++#include <org/genivi/am.h>
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <CommonAPI/InputStream.h>
++#include <CommonAPI/OutputStream.h>
++#include <CommonAPI/SerializableStruct.h>
++#include <cstdint>
++#include <string>
++#include <vector>
++
++#include <CommonAPI/Event.h>
++#include <CommonAPI/Proxy.h>
++#include <functional>
++#include <future>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++namespace am {
++
++class CommandControlProxyBase: virtual public CommonAPI::Proxy {
++ public:
++ typedef CommonAPI::Event<am_MainConnectionType_s> NewMainConnectionEvent;
++ typedef CommonAPI::Event<am_mainConnectionID_t> RemovedMainConnectionEvent;
++ typedef CommonAPI::Event<am_SinkType_s> NewSinkEvent;
++ typedef CommonAPI::Event<am_sinkID_t> RemovedSinkEvent;
++ typedef CommonAPI::Event<am_SourceType_s> NewSourceEvent;
++ typedef CommonAPI::Event<am_sourceID_t> RemovedSourceEvent;
++ typedef CommonAPI::Event<> NumberOfSinkClassesChangedEvent;
++ typedef CommonAPI::Event<> NumberOfSourceClassesChangedEvent;
++ typedef CommonAPI::Event<am_mainConnectionID_t, am_ConnectionState_e> MainConnectionStateChangedEvent;
++ typedef CommonAPI::Event<am_sinkID_t, am_MainSoundProperty_s> MainSinkSoundPropertyChangedEvent;
++ typedef CommonAPI::Event<am_sourceID_t, am_MainSoundProperty_s> MainSourceSoundPropertyChangedEvent;
++ typedef CommonAPI::Event<am_sinkID_t, am_Availability_s> SinkAvailabilityChangedEvent;
++ typedef CommonAPI::Event<am_sourceID_t, am_Availability_s> SourceAvailabilityChangedEvent;
++ typedef CommonAPI::Event<am_sinkID_t, am_mainVolume_t> VolumeChangedEvent;
++ typedef CommonAPI::Event<am_sinkID_t, am_MuteState_e> SinkMuteStateChangedEvent;
++ typedef CommonAPI::Event<am_SystemProperty_s> SystemPropertyChangedEvent;
++ typedef CommonAPI::Event<am_mainConnectionID_t, am_timeSync_t> TimingInformationChangedEvent;
++ typedef CommonAPI::Event<am_sinkID_t, am_sinkClass_t, am_MainSoundProperty_L> SinkUpdatedEvent;
++ typedef CommonAPI::Event<am_sourceID_t, am_sourceClass_t, am_MainSoundProperty_L> SourceUpdatedEvent;
++ typedef CommonAPI::Event<am_sinkID_t, am_NotificationPayload_s> SinkNotificationEvent;
++ typedef CommonAPI::Event<am_sourceID_t, am_NotificationPayload_s> SourceNotificationEvent;
++ typedef CommonAPI::Event<am_sinkID_t, am_NotificationConfiguration_s> MainSinkNotificationConfigurationChangedEvent;
++ typedef CommonAPI::Event<am_sourceID_t, am_NotificationConfiguration_s> MainSourceNotificationConfigurationChangedEvent;
++
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_mainConnectionID_t&, const am_Error_e&)> ConnectAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> DisconnectAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> SetVolumeAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> VolumeStepAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> SetSinkMuteStateAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> SetMainSinkSoundPropertyAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> SetMainSourceSoundPropertyAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> SetSystemPropertyAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_MainConnection_L&, const am_Error_e&)> GetListMainConnectionsAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_SinkType_L&, const am_Error_e&)> GetListMainSinksAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_SourceType_L&, const am_Error_e&)> GetListMainSourcesAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_MainSoundProperty_L&, const am_Error_e&)> GetListMainSinkSoundPropertiesAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_MainSoundProperty_L&, const am_Error_e&)> GetListMainSourceSoundPropertiesAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_SourceClass_L&, const am_Error_e&)> GetListSourceClassesAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_SinkClass_L&, const am_Error_e&)> GetListSinkClassesAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_SystemProperty_L&, const am_Error_e&)> GetListSystemPropertiesAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_timeSync_t&, const am_Error_e&)> GetTimingInformationAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_NotificationConfiguration_L&, const am_Error_e&)> GetListMainSinkNotificationConfigurationsAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_NotificationConfiguration_L&, const am_Error_e&)> GetListMainSourceNotificationConfigurationsAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> SetMainSinkNotificationConfigurationAsyncCallback;
++ typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> SetMainSourceNotificationConfigurationAsyncCallback;
++
++
++ /**
++ * Callback that is called when the number of connections change
++ */
++ virtual NewMainConnectionEvent& getNewMainConnectionEvent() = 0;
++ /**
++ * Callback that is called when the number of connections change
++ */
++ virtual RemovedMainConnectionEvent& getRemovedMainConnectionEvent() = 0;
++ /**
++ * Callback that is called when the number of sinks change
++ */
++ virtual NewSinkEvent& getNewSinkEvent() = 0;
++ /**
++ * Callback that is called when the number of sinks change
++ */
++ virtual RemovedSinkEvent& getRemovedSinkEvent() = 0;
++ /**
++ * Callback that is called when the number of sources change
++ */
++ virtual NewSourceEvent& getNewSourceEvent() = 0;
++ /**
++ * Callback that is called when the number of sources change
++ */
++ virtual RemovedSourceEvent& getRemovedSourceEvent() = 0;
++ /**
++ * this callback is fired if the number of sink classes changed
++ */
++ virtual NumberOfSinkClassesChangedEvent& getNumberOfSinkClassesChangedEvent() = 0;
++ /**
++ * this callback is fired if the number of source classes changed
++ */
++ virtual NumberOfSourceClassesChangedEvent& getNumberOfSourceClassesChangedEvent() = 0;
++ /**
++ * This callback is called when the ConnectionState of a connection changed.
++ */
++ virtual MainConnectionStateChangedEvent& getMainConnectionStateChangedEvent() = 0;
++ /**
++ * this callback indicates that a sinkSoundProperty has changed.
++ */
++ virtual MainSinkSoundPropertyChangedEvent& getMainSinkSoundPropertyChangedEvent() = 0;
++ /**
++ * this callback indicates that a sourceSoundProperty has changed.
++ */
++ virtual MainSourceSoundPropertyChangedEvent& getMainSourceSoundPropertyChangedEvent() = 0;
++ /**
++ * this callback is called when the availability of a sink has changed
++ */
++ virtual SinkAvailabilityChangedEvent& getSinkAvailabilityChangedEvent() = 0;
++ /**
++ * this callback is called when the availability of source has changed.
++ */
++ virtual SourceAvailabilityChangedEvent& getSourceAvailabilityChangedEvent() = 0;
++ /**
++ * this callback indicates a volume change on the indicated sink
++ */
++ virtual VolumeChangedEvent& getVolumeChangedEvent() = 0;
++ /**
++ * this callback indicates a mute state change on a sink.
++ */
++ virtual SinkMuteStateChangedEvent& getSinkMuteStateChangedEvent() = 0;
++ /**
++ * is fired if a systemProperty changed
++ */
++ virtual SystemPropertyChangedEvent& getSystemPropertyChangedEvent() = 0;
++ /**
++ * This callback is fired if the timinginformation for a mainConnectionID changed
++ */
++ virtual TimingInformationChangedEvent& getTimingInformationChangedEvent() = 0;
++ /**
++ * This callback is called when a sink is updated.
++ */
++ virtual SinkUpdatedEvent& getSinkUpdatedEvent() = 0;
++ /**
++ * This callback is called when a source is updated.
++ */
++ virtual SourceUpdatedEvent& getSourceUpdatedEvent() = 0;
++ /**
++ * This callback is called when a notificated value of a sink changes.
++ */
++ virtual SinkNotificationEvent& getSinkNotificationEvent() = 0;
++ /**
++ * This callback is called when a notifcated value of a source changes.
++ */
++ virtual SourceNotificationEvent& getSourceNotificationEvent() = 0;
++ /**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++ virtual MainSinkNotificationConfigurationChangedEvent& getMainSinkNotificationConfigurationChangedEvent() = 0;
++ /**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++ virtual MainSourceNotificationConfigurationChangedEvent& getMainSourceNotificationConfigurationChangedEvent() = 0;
++
++ /**
++ * connects a source to sink
++ (at)return E_OK on success, E_NOT_POSSIBLE on
++ * failure, E_ALREADY_EXISTS if the connection does already exists
++ */
++ virtual void connect(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_mainConnectionID_t& mainConnectionID, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> connectAsync(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, ConnectAsyncCallback callback) = 0;
++ /**
++ * disconnects a mainConnection
++ (at)return E_OK on successes, E_NON_EXISTENT if
++ * the connection does not exist, E_NOT_POSSIBLE on error.
++ */
++ virtual void disconnect(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> disconnectAsync(const am_mainConnectionID_t& mainConnectionID, DisconnectAsyncCallback callback) = 0;
++ /**
++ * sets the volume for a sink
++ (at)return E_OK on success, E_UNKOWN on error,
++ * E_OUT_OF_RANGE in case the value is out of range
++ */
++ virtual void setVolume(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> setVolumeAsync(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, SetVolumeAsyncCallback callback) = 0;
++ /**
++ * This function is used to increment or decrement the current volume for a
++ * sink.
++ (at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the
++ * value is not in the given volume range.
++ */
++ virtual void volumeStep(const am_sinkID_t& sinkID, const int16_t& volStep, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> volumeStepAsync(const am_sinkID_t& sinkID, const int16_t& volStep, VolumeStepAsyncCallback callback) = 0;
++ /**
++ * sets the mute state of a sink
++ (at)return E_OK on success, E_UNKNOWN on error.
++ * If the mute state is already the desired one, the Daemon will return E_OK.
++ */
++ virtual void setSinkMuteState(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> setSinkMuteStateAsync(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, SetSinkMuteStateAsyncCallback callback) = 0;
++ /**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++ (at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++ virtual void setMainSinkSoundProperty(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> setMainSinkSoundPropertyAsync(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, SetMainSinkSoundPropertyAsyncCallback callback) = 0;
++ /**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++ (at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++ virtual void setMainSourceSoundProperty(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> setMainSourceSoundPropertyAsync(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, SetMainSourceSoundPropertyAsyncCallback callback) = 0;
++ /**
++ * is used to set a specific system property.
++ (at)return E_OK on success,
++ * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error
++ */
++ virtual void setSystemProperty(const am_SystemProperty_s& property, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> setSystemPropertyAsync(const am_SystemProperty_s& property, SetSystemPropertyAsyncCallback callback) = 0;
++ /**
++ * returns the actual list of MainConnections
++ (at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++ virtual void getListMainConnections(CommonAPI::CallStatus& callStatus, am_MainConnection_L& listConnections, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> getListMainConnectionsAsync(GetListMainConnectionsAsyncCallback callback) = 0;
++ /**
++ * returns the actual list of Sinks
++ (at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++ virtual void getListMainSinks(CommonAPI::CallStatus& callStatus, am_SinkType_L& listMainSinks, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> getListMainSinksAsync(GetListMainSinksAsyncCallback callback) = 0;
++ /**
++ * returns the actual list of Sources
++ (at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++ virtual void getListMainSources(CommonAPI::CallStatus& callStatus, am_SourceType_L& listMainSources, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> getListMainSourcesAsync(GetListMainSourcesAsyncCallback callback) = 0;
++ /**
++ * This is used to retrieve all source sound properties related to a source.
++ * Returns a vector of the sound properties and values as pair
++ (at)return E_OK on
++ * success, E_DATABASE_ERROR on error
++ */
++ virtual void getListMainSinkSoundProperties(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> getListMainSinkSoundPropertiesAsync(const am_sinkID_t& sinkID, GetListMainSinkSoundPropertiesAsyncCallback callback) = 0;
++ /**
++ * This is used to retrieve all source sound properties related to a
++ * source.
++ (at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++ virtual void getListMainSourceSoundProperties(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> getListMainSourceSoundPropertiesAsync(const am_sourceID_t& sourceID, GetListMainSourceSoundPropertiesAsyncCallback callback) = 0;
++ /**
++ * This is used to retrieve SourceClass Information of all source classes
++ *
++ (at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++ virtual void getListSourceClasses(CommonAPI::CallStatus& callStatus, am_SourceClass_L& listSourceClasses, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> getListSourceClassesAsync(GetListSourceClassesAsyncCallback callback) = 0;
++ /**
++ * This is used to retrieve SinkClass Information of all sink classes
++ (at)return
++ * E_OK on success, E_DATABASE_ERROR on error
++ */
++ virtual void getListSinkClasses(CommonAPI::CallStatus& callStatus, am_SinkClass_L& listSinkClasses, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> getListSinkClassesAsync(GetListSinkClassesAsyncCallback callback) = 0;
++ /**
++ * Retrieves a complete list of all systemProperties.
++ (at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++ virtual void getListSystemProperties(CommonAPI::CallStatus& callStatus, am_SystemProperty_L& listSystemProperties, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> getListSystemPropertiesAsync(GetListSystemPropertiesAsyncCallback callback) = 0;
++ /**
++ * returns the delay in ms that the audiopath for the given mainConnection
++ * has
++ (at)return E_OK on success, E_NOT_POSSIBLE if timing information is not
++ * yet retrieved, E_DATABASE_ERROR on read error on the database
++ */
++ virtual void getTimingInformation(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_timeSync_t& delay, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> getTimingInformationAsync(const am_mainConnectionID_t& mainConnectionID, GetTimingInformationAsyncCallback callback) = 0;
++ /**
++ * Retrieves the list of MainNotifications for a sink. Does not return the
++ * possible ones.
++ */
++ virtual void getListMainSinkNotificationConfigurations(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> getListMainSinkNotificationConfigurationsAsync(const am_sinkID_t& sinkID, GetListMainSinkNotificationConfigurationsAsyncCallback callback) = 0;
++ /**
++ * Retrieves the list of MainNotifications for a source. Does not return the
++ * possible ones.
++ */
++ virtual void getListMainSourceNotificationConfigurations(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> getListMainSourceNotificationConfigurationsAsync(const am_sourceID_t& sourceID, GetListMainSourceNotificationConfigurationsAsyncCallback callback) = 0;
++ /**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++ (at)return E_OK on
++ * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error
++ */
++ virtual void setMainSinkNotificationConfiguration(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> setMainSinkNotificationConfigurationAsync(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSinkNotificationConfigurationAsyncCallback callback) = 0;
++ /**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++ (at)return E_OK on
++ * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error
++ */
++ virtual void setMainSourceNotificationConfiguration(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0;
++ virtual std::future<CommonAPI::CallStatus> setMainSourceNotificationConfigurationAsync(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSourceNotificationConfigurationAsyncCallback callback) = 0;
++};
++
++} // namespace am
++} // namespace genivi
++} // namespace org
++
++#endif // ORG_GENIVI_AM_Command_Control_PROXY_BASE_H_
+diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStub.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStub.h
+new file mode 100644
+index 0000000..4e15ce0
+--- /dev/null
++++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStub.h
+@@ -0,0 +1,492 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * The interface towards the Controlling Instance (e.g HMI). It handles the
++ * communication towards the HMI and other system components who need to interact
++ * with the audiomanagement.
++There are two rules that have to be kept in mind
++ * when implementing against this interface:
++ * @author Christian Mueller
++ */
++#ifndef ORG_GENIVI_AM_Command_Control_STUB_H_
++#define ORG_GENIVI_AM_Command_Control_STUB_H_
++
++
++
++#include <org/genivi/am.h>
++
++#include "CommandControl.h"
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <CommonAPI/InputStream.h>
++#include <CommonAPI/OutputStream.h>
++#include <CommonAPI/SerializableStruct.h>
++#include <cstdint>
++#include <string>
++#include <unordered_set>
++#include <vector>
++
++#include <CommonAPI/Stub.h>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++namespace am {
++
++/**
++ * Receives messages from remote and handles all dispatching of deserialized calls
++ * to a stub for the service CommandControl. Also provides means to send broadcasts
++ * and attribute-changed-notifications of observable attributes as defined by this service.
++ * An application developer should not need to bother with this class.
++ */
++class CommandControlStubAdapter: virtual public CommonAPI::StubAdapter, public CommandControl {
++ public:
++
++ /**
++ * Sends a broadcast event for newMainConnection. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireNewMainConnectionEvent(const am_MainConnectionType_s& mainConnection) = 0;
++ /**
++ * Sends a broadcast event for removedMainConnection. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireRemovedMainConnectionEvent(const am_mainConnectionID_t& mainConnection) = 0;
++ /**
++ * Sends a broadcast event for newSink. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireNewSinkEvent(const am_SinkType_s& sink) = 0;
++ /**
++ * Sends a broadcast event for removedSink. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireRemovedSinkEvent(const am_sinkID_t& sinkID) = 0;
++ /**
++ * Sends a broadcast event for newSource. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireNewSourceEvent(const am_SourceType_s& source) = 0;
++ /**
++ * Sends a broadcast event for removedSource. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireRemovedSourceEvent(const am_sourceID_t& source) = 0;
++ /**
++ * Sends a broadcast event for numberOfSinkClassesChanged. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireNumberOfSinkClassesChangedEvent() = 0;
++ /**
++ * Sends a broadcast event for numberOfSourceClassesChanged. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireNumberOfSourceClassesChangedEvent() = 0;
++ /**
++ * Sends a broadcast event for mainConnectionStateChanged. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireMainConnectionStateChangedEvent(const am_mainConnectionID_t& connectionID, const am_ConnectionState_e& connectionState) = 0;
++ /**
++ * Sends a broadcast event for mainSinkSoundPropertyChanged. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireMainSinkSoundPropertyChangedEvent(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty) = 0;
++ /**
++ * Sends a broadcast event for mainSourceSoundPropertyChanged. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireMainSourceSoundPropertyChangedEvent(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty) = 0;
++ /**
++ * Sends a broadcast event for sinkAvailabilityChanged. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireSinkAvailabilityChangedEvent(const am_sinkID_t& sinkID, const am_Availability_s& availability) = 0;
++ /**
++ * Sends a broadcast event for sourceAvailabilityChanged. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireSourceAvailabilityChangedEvent(const am_sourceID_t& sourceID, const am_Availability_s& availability) = 0;
++ /**
++ * Sends a broadcast event for volumeChanged. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireVolumeChangedEvent(const am_sinkID_t& sinkID, const am_mainVolume_t& volume) = 0;
++ /**
++ * Sends a broadcast event for sinkMuteStateChanged. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireSinkMuteStateChangedEvent(const am_sinkID_t& sinkID, const am_MuteState_e& muteState) = 0;
++ /**
++ * Sends a broadcast event for systemPropertyChanged. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireSystemPropertyChangedEvent(const am_SystemProperty_s& systemProperty) = 0;
++ /**
++ * Sends a broadcast event for timingInformationChanged. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireTimingInformationChangedEvent(const am_mainConnectionID_t& mainConnectionID, const am_timeSync_t& time) = 0;
++ /**
++ * Sends a broadcast event for sinkUpdated. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireSinkUpdatedEvent(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_MainSoundProperty_L& listMainSoundProperties) = 0;
++ /**
++ * Sends a broadcast event for sourceUpdated. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireSourceUpdatedEvent(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_MainSoundProperty_L& listMainSoundProperties) = 0;
++ /**
++ * Sends a broadcast event for sinkNotification. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireSinkNotificationEvent(const am_sinkID_t& sinkID, const am_NotificationPayload_s& notification) = 0;
++ /**
++ * Sends a broadcast event for sourceNotification. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireSourceNotificationEvent(const am_sourceID_t& sourceID, const am_NotificationPayload_s& notification) = 0;
++ /**
++ * Sends a broadcast event for mainSinkNotificationConfigurationChanged. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireMainSinkNotificationConfigurationChangedEvent(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration) = 0;
++ /**
++ * Sends a broadcast event for mainSourceNotificationConfigurationChanged. Should not be called directly.
++ * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
++ */
++ virtual void fireMainSourceNotificationConfigurationChangedEvent(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration) = 0;
++
++
++ virtual void deactivateManagedInstances() = 0;
++protected:
++ /**
++ * Defines properties for storing the ClientIds of clients / proxies that have
++ * subscribed to the selective broadcasts
++ */
++};
++
++
++/**
++ * Defines the necessary callbacks to handle remote set events related to the attributes
++ * defined in the IDL description for CommandControl.
++ * For each attribute two callbacks are defined:
++ * - a verification callback that allows to verify the requested value and to prevent setting
++ * e.g. an invalid value ("onRemoteSet<AttributeName>").
++ * - an action callback to do local work after the attribute value has been changed
++ * ("onRemote<AttributeName>Changed").
++ *
++ * This class and the one below are the ones an application developer needs to have
++ * a look at if he wants to implement a service.
++ */
++class CommandControlStubRemoteEvent {
++ public:
++ virtual ~CommandControlStubRemoteEvent() { }
++
++};
++
++
++/**
++ * Defines the interface that must be implemented by any class that should provide
++ * the service CommandControl to remote clients.
++ * This class and the one above are the ones an application developer needs to have
++ * a look at if he wants to implement a service.
++ */
++class CommandControlStub: public virtual CommonAPI::Stub<CommandControlStubAdapter, CommandControlStubRemoteEvent> {
++public:
++ virtual ~CommandControlStub() { }
++ virtual const CommonAPI::Version& getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
++
++
++ /**
++ * connects a source to sink
++ (at)return E_OK on success, E_NOT_POSSIBLE on
++ * failure, E_ALREADY_EXISTS if the connection does already exists
++ */
++ /// This is the method that will be called on remote calls on the method connect.
++ virtual void connect(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_sinkID_t sinkID, am_mainConnectionID_t& mainConnectionID, am_Error_e& error) = 0;
++ /**
++ * disconnects a mainConnection
++ (at)return E_OK on successes, E_NON_EXISTENT if
++ * the connection does not exist, E_NOT_POSSIBLE on error.
++ */
++ /// This is the method that will be called on remote calls on the method disconnect.
++ virtual void disconnect(const std::shared_ptr<CommonAPI::ClientId> clientId, am_mainConnectionID_t mainConnectionID, am_Error_e& error) = 0;
++ /**
++ * sets the volume for a sink
++ (at)return E_OK on success, E_UNKOWN on error,
++ * E_OUT_OF_RANGE in case the value is out of range
++ */
++ /// This is the method that will be called on remote calls on the method setVolume.
++ virtual void setVolume(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_mainVolume_t volume, am_Error_e& error) = 0;
++ /**
++ * This function is used to increment or decrement the current volume for a
++ * sink.
++ (at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the
++ * value is not in the given volume range.
++ */
++ /// This is the method that will be called on remote calls on the method volumeStep.
++ virtual void volumeStep(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, int16_t volStep, am_Error_e& error) = 0;
++ /**
++ * sets the mute state of a sink
++ (at)return E_OK on success, E_UNKNOWN on error.
++ * If the mute state is already the desired one, the Daemon will return E_OK.
++ */
++ /// This is the method that will be called on remote calls on the method setSinkMuteState.
++ virtual void setSinkMuteState(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MuteState_e muteState, am_Error_e& error) = 0;
++ /**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++ (at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++ /// This is the method that will be called on remote calls on the method setMainSinkSoundProperty.
++ virtual void setMainSinkSoundProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MainSoundProperty_s soundProperty, am_Error_e& error) = 0;
++ /**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++ (at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++ /// This is the method that will be called on remote calls on the method setMainSourceSoundProperty.
++ virtual void setMainSourceSoundProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_MainSoundProperty_s soundProperty, am_Error_e& error) = 0;
++ /**
++ * is used to set a specific system property.
++ (at)return E_OK on success,
++ * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error
++ */
++ /// This is the method that will be called on remote calls on the method setSystemProperty.
++ virtual void setSystemProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SystemProperty_s property, am_Error_e& error) = 0;
++ /**
++ * returns the actual list of MainConnections
++ (at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++ /// This is the method that will be called on remote calls on the method getListMainConnections.
++ virtual void getListMainConnections(const std::shared_ptr<CommonAPI::ClientId> clientId, am_MainConnection_L& listConnections, am_Error_e& error) = 0;
++ /**
++ * returns the actual list of Sinks
++ (at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++ /// This is the method that will be called on remote calls on the method getListMainSinks.
++ virtual void getListMainSinks(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SinkType_L& listMainSinks, am_Error_e& error) = 0;
++ /**
++ * returns the actual list of Sources
++ (at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++ /// This is the method that will be called on remote calls on the method getListMainSources.
++ virtual void getListMainSources(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SourceType_L& listMainSources, am_Error_e& error) = 0;
++ /**
++ * This is used to retrieve all source sound properties related to a source.
++ * Returns a vector of the sound properties and values as pair
++ (at)return E_OK on
++ * success, E_DATABASE_ERROR on error
++ */
++ /// This is the method that will be called on remote calls on the method getListMainSinkSoundProperties.
++ virtual void getListMainSinkSoundProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error) = 0;
++ /**
++ * This is used to retrieve all source sound properties related to a
++ * source.
++ (at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++ /// This is the method that will be called on remote calls on the method getListMainSourceSoundProperties.
++ virtual void getListMainSourceSoundProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error) = 0;
++ /**
++ * This is used to retrieve SourceClass Information of all source classes
++ *
++ (at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++ /// This is the method that will be called on remote calls on the method getListSourceClasses.
++ virtual void getListSourceClasses(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SourceClass_L& listSourceClasses, am_Error_e& error) = 0;
++ /**
++ * This is used to retrieve SinkClass Information of all sink classes
++ (at)return
++ * E_OK on success, E_DATABASE_ERROR on error
++ */
++ /// This is the method that will be called on remote calls on the method getListSinkClasses.
++ virtual void getListSinkClasses(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SinkClass_L& listSinkClasses, am_Error_e& error) = 0;
++ /**
++ * Retrieves a complete list of all systemProperties.
++ (at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++ /// This is the method that will be called on remote calls on the method getListSystemProperties.
++ virtual void getListSystemProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SystemProperty_L& listSystemProperties, am_Error_e& error) = 0;
++ /**
++ * returns the delay in ms that the audiopath for the given mainConnection
++ * has
++ (at)return E_OK on success, E_NOT_POSSIBLE if timing information is not
++ * yet retrieved, E_DATABASE_ERROR on read error on the database
++ */
++ /// This is the method that will be called on remote calls on the method getTimingInformation.
++ virtual void getTimingInformation(const std::shared_ptr<CommonAPI::ClientId> clientId, am_mainConnectionID_t mainConnectionID, am_timeSync_t& delay, am_Error_e& error) = 0;
++ /**
++ * Retrieves the list of MainNotifications for a sink. Does not return the
++ * possible ones.
++ */
++ /// This is the method that will be called on remote calls on the method getListMainSinkNotificationConfigurations.
++ virtual void getListMainSinkNotificationConfigurations(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) = 0;
++ /**
++ * Retrieves the list of MainNotifications for a source. Does not return the
++ * possible ones.
++ */
++ /// This is the method that will be called on remote calls on the method getListMainSourceNotificationConfigurations.
++ virtual void getListMainSourceNotificationConfigurations(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) = 0;
++ /**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++ (at)return E_OK on
++ * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error
++ */
++ /// This is the method that will be called on remote calls on the method setMainSinkNotificationConfiguration.
++ virtual void setMainSinkNotificationConfiguration(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error) = 0;
++ /**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++ (at)return E_OK on
++ * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error
++ */
++ /// This is the method that will be called on remote calls on the method setMainSourceNotificationConfiguration.
++ virtual void setMainSourceNotificationConfiguration(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error) = 0;
++ /**
++ * Callback that is called when the number of connections change
++ */
++ /// Sends a broadcast event for newMainConnection.
++ virtual void fireNewMainConnectionEvent(const am_MainConnectionType_s& mainConnection) = 0;
++ /**
++ * Callback that is called when the number of connections change
++ */
++ /// Sends a broadcast event for removedMainConnection.
++ virtual void fireRemovedMainConnectionEvent(const am_mainConnectionID_t& mainConnection) = 0;
++ /**
++ * Callback that is called when the number of sinks change
++ */
++ /// Sends a broadcast event for newSink.
++ virtual void fireNewSinkEvent(const am_SinkType_s& sink) = 0;
++ /**
++ * Callback that is called when the number of sinks change
++ */
++ /// Sends a broadcast event for removedSink.
++ virtual void fireRemovedSinkEvent(const am_sinkID_t& sinkID) = 0;
++ /**
++ * Callback that is called when the number of sources change
++ */
++ /// Sends a broadcast event for newSource.
++ virtual void fireNewSourceEvent(const am_SourceType_s& source) = 0;
++ /**
++ * Callback that is called when the number of sources change
++ */
++ /// Sends a broadcast event for removedSource.
++ virtual void fireRemovedSourceEvent(const am_sourceID_t& source) = 0;
++ /**
++ * this callback is fired if the number of sink classes changed
++ */
++ /// Sends a broadcast event for numberOfSinkClassesChanged.
++ virtual void fireNumberOfSinkClassesChangedEvent() = 0;
++ /**
++ * this callback is fired if the number of source classes changed
++ */
++ /// Sends a broadcast event for numberOfSourceClassesChanged.
++ virtual void fireNumberOfSourceClassesChangedEvent() = 0;
++ /**
++ * This callback is called when the ConnectionState of a connection changed.
++ */
++ /// Sends a broadcast event for mainConnectionStateChanged.
++ virtual void fireMainConnectionStateChangedEvent(const am_mainConnectionID_t& connectionID, const am_ConnectionState_e& connectionState) = 0;
++ /**
++ * this callback indicates that a sinkSoundProperty has changed.
++ */
++ /// Sends a broadcast event for mainSinkSoundPropertyChanged.
++ virtual void fireMainSinkSoundPropertyChangedEvent(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty) = 0;
++ /**
++ * this callback indicates that a sourceSoundProperty has changed.
++ */
++ /// Sends a broadcast event for mainSourceSoundPropertyChanged.
++ virtual void fireMainSourceSoundPropertyChangedEvent(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty) = 0;
++ /**
++ * this callback is called when the availability of a sink has changed
++ */
++ /// Sends a broadcast event for sinkAvailabilityChanged.
++ virtual void fireSinkAvailabilityChangedEvent(const am_sinkID_t& sinkID, const am_Availability_s& availability) = 0;
++ /**
++ * this callback is called when the availability of source has changed.
++ */
++ /// Sends a broadcast event for sourceAvailabilityChanged.
++ virtual void fireSourceAvailabilityChangedEvent(const am_sourceID_t& sourceID, const am_Availability_s& availability) = 0;
++ /**
++ * this callback indicates a volume change on the indicated sink
++ */
++ /// Sends a broadcast event for volumeChanged.
++ virtual void fireVolumeChangedEvent(const am_sinkID_t& sinkID, const am_mainVolume_t& volume) = 0;
++ /**
++ * this callback indicates a mute state change on a sink.
++ */
++ /// Sends a broadcast event for sinkMuteStateChanged.
++ virtual void fireSinkMuteStateChangedEvent(const am_sinkID_t& sinkID, const am_MuteState_e& muteState) = 0;
++ /**
++ * is fired if a systemProperty changed
++ */
++ /// Sends a broadcast event for systemPropertyChanged.
++ virtual void fireSystemPropertyChangedEvent(const am_SystemProperty_s& systemProperty) = 0;
++ /**
++ * This callback is fired if the timinginformation for a mainConnectionID changed
++ */
++ /// Sends a broadcast event for timingInformationChanged.
++ virtual void fireTimingInformationChangedEvent(const am_mainConnectionID_t& mainConnectionID, const am_timeSync_t& time) = 0;
++ /**
++ * This callback is called when a sink is updated.
++ */
++ /// Sends a broadcast event for sinkUpdated.
++ virtual void fireSinkUpdatedEvent(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_MainSoundProperty_L& listMainSoundProperties) = 0;
++ /**
++ * This callback is called when a source is updated.
++ */
++ /// Sends a broadcast event for sourceUpdated.
++ virtual void fireSourceUpdatedEvent(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_MainSoundProperty_L& listMainSoundProperties) = 0;
++ /**
++ * This callback is called when a notificated value of a sink changes.
++ */
++ /// Sends a broadcast event for sinkNotification.
++ virtual void fireSinkNotificationEvent(const am_sinkID_t& sinkID, const am_NotificationPayload_s& notification) = 0;
++ /**
++ * This callback is called when a notifcated value of a source changes.
++ */
++ /// Sends a broadcast event for sourceNotification.
++ virtual void fireSourceNotificationEvent(const am_sourceID_t& sourceID, const am_NotificationPayload_s& notification) = 0;
++ /**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++ /// Sends a broadcast event for mainSinkNotificationConfigurationChanged.
++ virtual void fireMainSinkNotificationConfigurationChangedEvent(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration) = 0;
++ /**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++ /// Sends a broadcast event for mainSourceNotificationConfigurationChanged.
++ virtual void fireMainSourceNotificationConfigurationChangedEvent(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration) = 0;
++
++ using CommonAPI::Stub<CommandControlStubAdapter, CommandControlStubRemoteEvent>::initStubAdapter;
++ typedef CommonAPI::Stub<CommandControlStubAdapter, CommandControlStubRemoteEvent>::StubAdapterType StubAdapterType;
++ typedef CommonAPI::Stub<CommandControlStubAdapter, CommandControlStubRemoteEvent>::RemoteEventHandlerType RemoteEventHandlerType;
++ typedef CommandControlStubRemoteEvent RemoteEventType;
++ typedef CommandControl StubInterface;
++};
++
++} // namespace am
++} // namespace genivi
++} // namespace org
++
++#endif // ORG_GENIVI_AM_Command_Control_STUB_H_
+diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStubDefault.cpp b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStubDefault.cpp
+new file mode 100644
+index 0000000..cca1a5e
+--- /dev/null
++++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStubDefault.cpp
+@@ -0,0 +1,456 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++#include <org/genivi/am/CommandControlStubDefault.h>
++
++namespace org {
++namespace genivi {
++namespace am {
++
++CommandControlStubDefault::CommandControlStubDefault():
++ remoteEventHandler_(this),
++ interfaceVersion_(CommandControl::getInterfaceVersion()) {
++}
++
++const CommonAPI::Version& CommandControlStubDefault::getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> clientId) {
++ return interfaceVersion_;
++}
++
++CommandControlStubRemoteEvent* CommandControlStubDefault::initStubAdapter(const std::shared_ptr<CommandControlStubAdapter>& stubAdapter) {
++ CommonAPI::Stub<CommandControlStubAdapter, CommandControlStubRemoteEvent>::stubAdapter_ = stubAdapter;
++ return &remoteEventHandler_;
++}
++
++
++/**
++ * connects a source to sink
++(at)return E_OK on success, E_NOT_POSSIBLE on
++ * failure, E_ALREADY_EXISTS if the connection does already exists
++ */
++void CommandControlStubDefault::connect(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_sinkID_t sinkID, am_mainConnectionID_t& mainConnectionID, am_Error_e& error) {
++ // Call old style methods in default
++ connect(sourceID, sinkID, mainConnectionID, error);
++}
++void CommandControlStubDefault::connect(am_sourceID_t sourceID, am_sinkID_t sinkID, am_mainConnectionID_t& mainConnectionID, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * disconnects a mainConnection
++(at)return E_OK on successes, E_NON_EXISTENT if
++ * the connection does not exist, E_NOT_POSSIBLE on error.
++ */
++void CommandControlStubDefault::disconnect(const std::shared_ptr<CommonAPI::ClientId> clientId, am_mainConnectionID_t mainConnectionID, am_Error_e& error) {
++ // Call old style methods in default
++ disconnect(mainConnectionID, error);
++}
++void CommandControlStubDefault::disconnect(am_mainConnectionID_t mainConnectionID, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * sets the volume for a sink
++(at)return E_OK on success, E_UNKOWN on error,
++ * E_OUT_OF_RANGE in case the value is out of range
++ */
++void CommandControlStubDefault::setVolume(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_mainVolume_t volume, am_Error_e& error) {
++ // Call old style methods in default
++ setVolume(sinkID, volume, error);
++}
++void CommandControlStubDefault::setVolume(am_sinkID_t sinkID, am_mainVolume_t volume, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * This function is used to increment or decrement the current volume for a
++ * sink.
++(at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the
++ * value is not in the given volume range.
++ */
++void CommandControlStubDefault::volumeStep(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, int16_t volStep, am_Error_e& error) {
++ // Call old style methods in default
++ volumeStep(sinkID, volStep, error);
++}
++void CommandControlStubDefault::volumeStep(am_sinkID_t sinkID, int16_t volStep, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * sets the mute state of a sink
++(at)return E_OK on success, E_UNKNOWN on error.
++ * If the mute state is already the desired one, the Daemon will return E_OK.
++ */
++void CommandControlStubDefault::setSinkMuteState(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MuteState_e muteState, am_Error_e& error) {
++ // Call old style methods in default
++ setSinkMuteState(sinkID, muteState, error);
++}
++void CommandControlStubDefault::setSinkMuteState(am_sinkID_t sinkID, am_MuteState_e muteState, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++(at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++void CommandControlStubDefault::setMainSinkSoundProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MainSoundProperty_s soundProperty, am_Error_e& error) {
++ // Call old style methods in default
++ setMainSinkSoundProperty(sinkID, soundProperty, error);
++}
++void CommandControlStubDefault::setMainSinkSoundProperty(am_sinkID_t sinkID, am_MainSoundProperty_s soundProperty, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++(at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++void CommandControlStubDefault::setMainSourceSoundProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_MainSoundProperty_s soundProperty, am_Error_e& error) {
++ // Call old style methods in default
++ setMainSourceSoundProperty(sourceID, soundProperty, error);
++}
++void CommandControlStubDefault::setMainSourceSoundProperty(am_sourceID_t sourceID, am_MainSoundProperty_s soundProperty, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * is used to set a specific system property.
++(at)return E_OK on success,
++ * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error
++ */
++void CommandControlStubDefault::setSystemProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SystemProperty_s property, am_Error_e& error) {
++ // Call old style methods in default
++ setSystemProperty(property, error);
++}
++void CommandControlStubDefault::setSystemProperty(am_SystemProperty_s property, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * returns the actual list of MainConnections
++(at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++void CommandControlStubDefault::getListMainConnections(const std::shared_ptr<CommonAPI::ClientId> clientId, am_MainConnection_L& listConnections, am_Error_e& error) {
++ // Call old style methods in default
++ getListMainConnections(listConnections, error);
++}
++void CommandControlStubDefault::getListMainConnections(am_MainConnection_L& listConnections, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * returns the actual list of Sinks
++(at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++void CommandControlStubDefault::getListMainSinks(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SinkType_L& listMainSinks, am_Error_e& error) {
++ // Call old style methods in default
++ getListMainSinks(listMainSinks, error);
++}
++void CommandControlStubDefault::getListMainSinks(am_SinkType_L& listMainSinks, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * returns the actual list of Sources
++(at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++void CommandControlStubDefault::getListMainSources(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SourceType_L& listMainSources, am_Error_e& error) {
++ // Call old style methods in default
++ getListMainSources(listMainSources, error);
++}
++void CommandControlStubDefault::getListMainSources(am_SourceType_L& listMainSources, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * This is used to retrieve all source sound properties related to a source.
++ * Returns a vector of the sound properties and values as pair
++(at)return E_OK on
++ * success, E_DATABASE_ERROR on error
++ */
++void CommandControlStubDefault::getListMainSinkSoundProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error) {
++ // Call old style methods in default
++ getListMainSinkSoundProperties(sinkID, listSoundProperties, error);
++}
++void CommandControlStubDefault::getListMainSinkSoundProperties(am_sinkID_t sinkID, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * This is used to retrieve all source sound properties related to a
++ * source.
++(at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++void CommandControlStubDefault::getListMainSourceSoundProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error) {
++ // Call old style methods in default
++ getListMainSourceSoundProperties(sourceID, listSourceProperties, error);
++}
++void CommandControlStubDefault::getListMainSourceSoundProperties(am_sourceID_t sourceID, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * This is used to retrieve SourceClass Information of all source classes
++ *
++(at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++void CommandControlStubDefault::getListSourceClasses(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SourceClass_L& listSourceClasses, am_Error_e& error) {
++ // Call old style methods in default
++ getListSourceClasses(listSourceClasses, error);
++}
++void CommandControlStubDefault::getListSourceClasses(am_SourceClass_L& listSourceClasses, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * This is used to retrieve SinkClass Information of all sink classes
++(at)return
++ * E_OK on success, E_DATABASE_ERROR on error
++ */
++void CommandControlStubDefault::getListSinkClasses(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SinkClass_L& listSinkClasses, am_Error_e& error) {
++ // Call old style methods in default
++ getListSinkClasses(listSinkClasses, error);
++}
++void CommandControlStubDefault::getListSinkClasses(am_SinkClass_L& listSinkClasses, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * Retrieves a complete list of all systemProperties.
++(at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++void CommandControlStubDefault::getListSystemProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SystemProperty_L& listSystemProperties, am_Error_e& error) {
++ // Call old style methods in default
++ getListSystemProperties(listSystemProperties, error);
++}
++void CommandControlStubDefault::getListSystemProperties(am_SystemProperty_L& listSystemProperties, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * returns the delay in ms that the audiopath for the given mainConnection
++ * has
++(at)return E_OK on success, E_NOT_POSSIBLE if timing information is not
++ * yet retrieved, E_DATABASE_ERROR on read error on the database
++ */
++void CommandControlStubDefault::getTimingInformation(const std::shared_ptr<CommonAPI::ClientId> clientId, am_mainConnectionID_t mainConnectionID, am_timeSync_t& delay, am_Error_e& error) {
++ // Call old style methods in default
++ getTimingInformation(mainConnectionID, delay, error);
++}
++void CommandControlStubDefault::getTimingInformation(am_mainConnectionID_t mainConnectionID, am_timeSync_t& delay, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * Retrieves the list of MainNotifications for a sink. Does not return the
++ * possible ones.
++ */
++void CommandControlStubDefault::getListMainSinkNotificationConfigurations(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) {
++ // Call old style methods in default
++ getListMainSinkNotificationConfigurations(sinkID, listMainNotificationConfigurations, error);
++}
++void CommandControlStubDefault::getListMainSinkNotificationConfigurations(am_sinkID_t sinkID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * Retrieves the list of MainNotifications for a source. Does not return the
++ * possible ones.
++ */
++void CommandControlStubDefault::getListMainSourceNotificationConfigurations(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) {
++ // Call old style methods in default
++ getListMainSourceNotificationConfigurations(sourceID, listMainNotificationConfigurations, error);
++}
++void CommandControlStubDefault::getListMainSourceNotificationConfigurations(am_sourceID_t sourceID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++(at)return E_OK on
++ * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error
++ */
++void CommandControlStubDefault::setMainSinkNotificationConfiguration(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error) {
++ // Call old style methods in default
++ setMainSinkNotificationConfiguration(sinkID, mainNotificationConfiguration, error);
++}
++void CommandControlStubDefault::setMainSinkNotificationConfiguration(am_sinkID_t sinkID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error) {
++ // No operation in default
++}
++
++/**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++(at)return E_OK on
++ * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error
++ */
++void CommandControlStubDefault::setMainSourceNotificationConfiguration(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error) {
++ // Call old style methods in default
++ setMainSourceNotificationConfiguration(sourceID, mainNotificationConfiguration, error);
++}
++void CommandControlStubDefault::setMainSourceNotificationConfiguration(am_sourceID_t sourceID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error) {
++ // No operation in default
++}
++
++
++/**
++ * Callback that is called when the number of connections change
++ */
++void CommandControlStubDefault::fireNewMainConnectionEvent(const am_MainConnectionType_s& mainConnection) {
++ stubAdapter_->fireNewMainConnectionEvent(mainConnection);
++}
++/**
++ * Callback that is called when the number of connections change
++ */
++void CommandControlStubDefault::fireRemovedMainConnectionEvent(const am_mainConnectionID_t& mainConnection) {
++ stubAdapter_->fireRemovedMainConnectionEvent(mainConnection);
++}
++/**
++ * Callback that is called when the number of sinks change
++ */
++void CommandControlStubDefault::fireNewSinkEvent(const am_SinkType_s& sink) {
++ stubAdapter_->fireNewSinkEvent(sink);
++}
++/**
++ * Callback that is called when the number of sinks change
++ */
++void CommandControlStubDefault::fireRemovedSinkEvent(const am_sinkID_t& sinkID) {
++ stubAdapter_->fireRemovedSinkEvent(sinkID);
++}
++/**
++ * Callback that is called when the number of sources change
++ */
++void CommandControlStubDefault::fireNewSourceEvent(const am_SourceType_s& source) {
++ stubAdapter_->fireNewSourceEvent(source);
++}
++/**
++ * Callback that is called when the number of sources change
++ */
++void CommandControlStubDefault::fireRemovedSourceEvent(const am_sourceID_t& source) {
++ stubAdapter_->fireRemovedSourceEvent(source);
++}
++/**
++ * this callback is fired if the number of sink classes changed
++ */
++void CommandControlStubDefault::fireNumberOfSinkClassesChangedEvent() {
++ stubAdapter_->fireNumberOfSinkClassesChangedEvent();
++}
++/**
++ * this callback is fired if the number of source classes changed
++ */
++void CommandControlStubDefault::fireNumberOfSourceClassesChangedEvent() {
++ stubAdapter_->fireNumberOfSourceClassesChangedEvent();
++}
++/**
++ * This callback is called when the ConnectionState of a connection changed.
++ */
++void CommandControlStubDefault::fireMainConnectionStateChangedEvent(const am_mainConnectionID_t& connectionID, const am_ConnectionState_e& connectionState) {
++ stubAdapter_->fireMainConnectionStateChangedEvent(connectionID, connectionState);
++}
++/**
++ * this callback indicates that a sinkSoundProperty has changed.
++ */
++void CommandControlStubDefault::fireMainSinkSoundPropertyChangedEvent(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty) {
++ stubAdapter_->fireMainSinkSoundPropertyChangedEvent(sinkID, soundProperty);
++}
++/**
++ * this callback indicates that a sourceSoundProperty has changed.
++ */
++void CommandControlStubDefault::fireMainSourceSoundPropertyChangedEvent(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty) {
++ stubAdapter_->fireMainSourceSoundPropertyChangedEvent(sourceID, soundProperty);
++}
++/**
++ * this callback is called when the availability of a sink has changed
++ */
++void CommandControlStubDefault::fireSinkAvailabilityChangedEvent(const am_sinkID_t& sinkID, const am_Availability_s& availability) {
++ stubAdapter_->fireSinkAvailabilityChangedEvent(sinkID, availability);
++}
++/**
++ * this callback is called when the availability of source has changed.
++ */
++void CommandControlStubDefault::fireSourceAvailabilityChangedEvent(const am_sourceID_t& sourceID, const am_Availability_s& availability) {
++ stubAdapter_->fireSourceAvailabilityChangedEvent(sourceID, availability);
++}
++/**
++ * this callback indicates a volume change on the indicated sink
++ */
++void CommandControlStubDefault::fireVolumeChangedEvent(const am_sinkID_t& sinkID, const am_mainVolume_t& volume) {
++ stubAdapter_->fireVolumeChangedEvent(sinkID, volume);
++}
++/**
++ * this callback indicates a mute state change on a sink.
++ */
++void CommandControlStubDefault::fireSinkMuteStateChangedEvent(const am_sinkID_t& sinkID, const am_MuteState_e& muteState) {
++ stubAdapter_->fireSinkMuteStateChangedEvent(sinkID, muteState);
++}
++/**
++ * is fired if a systemProperty changed
++ */
++void CommandControlStubDefault::fireSystemPropertyChangedEvent(const am_SystemProperty_s& systemProperty) {
++ stubAdapter_->fireSystemPropertyChangedEvent(systemProperty);
++}
++/**
++ * This callback is fired if the timinginformation for a mainConnectionID changed
++ */
++void CommandControlStubDefault::fireTimingInformationChangedEvent(const am_mainConnectionID_t& mainConnectionID, const am_timeSync_t& time) {
++ stubAdapter_->fireTimingInformationChangedEvent(mainConnectionID, time);
++}
++/**
++ * This callback is called when a sink is updated.
++ */
++void CommandControlStubDefault::fireSinkUpdatedEvent(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_MainSoundProperty_L& listMainSoundProperties) {
++ stubAdapter_->fireSinkUpdatedEvent(sinkID, sinkClassID, listMainSoundProperties);
++}
++/**
++ * This callback is called when a source is updated.
++ */
++void CommandControlStubDefault::fireSourceUpdatedEvent(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_MainSoundProperty_L& listMainSoundProperties) {
++ stubAdapter_->fireSourceUpdatedEvent(sourceID, sourceClassID, listMainSoundProperties);
++}
++/**
++ * This callback is called when a notificated value of a sink changes.
++ */
++void CommandControlStubDefault::fireSinkNotificationEvent(const am_sinkID_t& sinkID, const am_NotificationPayload_s& notification) {
++ stubAdapter_->fireSinkNotificationEvent(sinkID, notification);
++}
++/**
++ * This callback is called when a notifcated value of a source changes.
++ */
++void CommandControlStubDefault::fireSourceNotificationEvent(const am_sourceID_t& sourceID, const am_NotificationPayload_s& notification) {
++ stubAdapter_->fireSourceNotificationEvent(sourceID, notification);
++}
++/**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++void CommandControlStubDefault::fireMainSinkNotificationConfigurationChangedEvent(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration) {
++ stubAdapter_->fireMainSinkNotificationConfigurationChangedEvent(sinkID, mainNotificationConfiguration);
++}
++/**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++void CommandControlStubDefault::fireMainSourceNotificationConfigurationChangedEvent(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration) {
++ stubAdapter_->fireMainSourceNotificationConfigurationChangedEvent(sourceID, mainNotificationConfiguration);
++}
++
++
++CommandControlStubDefault::RemoteEventHandler::RemoteEventHandler(CommandControlStubDefault* defaultStub):
++ defaultStub_(defaultStub) {
++}
++
++} // namespace am
++} // namespace genivi
++} // namespace org
+diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStubDefault.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStubDefault.h
+new file mode 100644
+index 0000000..a6d46f8
+--- /dev/null
++++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStubDefault.h
+@@ -0,0 +1,336 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * The interface towards the Controlling Instance (e.g HMI). It handles the
++ * communication towards the HMI and other system components who need to interact
++ * with the audiomanagement.
++There are two rules that have to be kept in mind
++ * when implementing against this interface:
++ * @author Christian Mueller
++ */
++#ifndef ORG_GENIVI_AM_Command_Control_STUB_DEFAULT_H_
++#define ORG_GENIVI_AM_Command_Control_STUB_DEFAULT_H_
++
++
++#include <org/genivi/am/CommandControlStub.h>
++#include <sstream>
++
++namespace org {
++namespace genivi {
++namespace am {
++
++/**
++ * Provides a default implementation for CommandControlStubRemoteEvent and
++ * CommandControlStub. Method callbacks have an empty implementation,
++ * remote set calls on attributes will always change the value of the attribute
++ * to the one received.
++ *
++ * Override this stub if you only want to provide a subset of the functionality
++ * that would be defined for this service, and/or if you do not need any non-default
++ * behaviour.
++ */
++class CommandControlStubDefault : public virtual CommandControlStub {
++public:
++ CommandControlStubDefault();
++
++ CommandControlStubRemoteEvent* initStubAdapter(const std::shared_ptr<CommandControlStubAdapter>& stubAdapter);
++
++ const CommonAPI::Version& getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> clientId);
++
++
++ /**
++ * connects a source to sink
++ (at)return E_OK on success, E_NOT_POSSIBLE on
++ * failure, E_ALREADY_EXISTS if the connection does already exists
++ */
++ virtual void connect(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_sinkID_t sinkID, am_mainConnectionID_t& mainConnectionID, am_Error_e& error);
++ virtual void connect(am_sourceID_t sourceID, am_sinkID_t sinkID, am_mainConnectionID_t& mainConnectionID, am_Error_e& error);
++
++ /**
++ * disconnects a mainConnection
++ (at)return E_OK on successes, E_NON_EXISTENT if
++ * the connection does not exist, E_NOT_POSSIBLE on error.
++ */
++ virtual void disconnect(const std::shared_ptr<CommonAPI::ClientId> clientId, am_mainConnectionID_t mainConnectionID, am_Error_e& error);
++ virtual void disconnect(am_mainConnectionID_t mainConnectionID, am_Error_e& error);
++
++ /**
++ * sets the volume for a sink
++ (at)return E_OK on success, E_UNKOWN on error,
++ * E_OUT_OF_RANGE in case the value is out of range
++ */
++ virtual void setVolume(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_mainVolume_t volume, am_Error_e& error);
++ virtual void setVolume(am_sinkID_t sinkID, am_mainVolume_t volume, am_Error_e& error);
++
++ /**
++ * This function is used to increment or decrement the current volume for a
++ * sink.
++ (at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the
++ * value is not in the given volume range.
++ */
++ virtual void volumeStep(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, int16_t volStep, am_Error_e& error);
++ virtual void volumeStep(am_sinkID_t sinkID, int16_t volStep, am_Error_e& error);
++
++ /**
++ * sets the mute state of a sink
++ (at)return E_OK on success, E_UNKNOWN on error.
++ * If the mute state is already the desired one, the Daemon will return E_OK.
++ */
++ virtual void setSinkMuteState(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MuteState_e muteState, am_Error_e& error);
++ virtual void setSinkMuteState(am_sinkID_t sinkID, am_MuteState_e muteState, am_Error_e& error);
++
++ /**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++ (at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++ virtual void setMainSinkSoundProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MainSoundProperty_s soundProperty, am_Error_e& error);
++ virtual void setMainSinkSoundProperty(am_sinkID_t sinkID, am_MainSoundProperty_s soundProperty, am_Error_e& error);
++
++ /**
++ * This method is used to set sound properties, e.g. Equalizer Values. Since the
++ * capabilities of the system can differ, the exact key value pairs can be
++ * extended in each product
++ (at)return E_OK on success, E_OUT_OF_RANGE if value
++ * exceeds range, E_UNKNOWN in case of an error
++ */
++ virtual void setMainSourceSoundProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_MainSoundProperty_s soundProperty, am_Error_e& error);
++ virtual void setMainSourceSoundProperty(am_sourceID_t sourceID, am_MainSoundProperty_s soundProperty, am_Error_e& error);
++
++ /**
++ * is used to set a specific system property.
++ (at)return E_OK on success,
++ * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error
++ */
++ virtual void setSystemProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SystemProperty_s property, am_Error_e& error);
++ virtual void setSystemProperty(am_SystemProperty_s property, am_Error_e& error);
++
++ /**
++ * returns the actual list of MainConnections
++ (at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++ virtual void getListMainConnections(const std::shared_ptr<CommonAPI::ClientId> clientId, am_MainConnection_L& listConnections, am_Error_e& error);
++ virtual void getListMainConnections(am_MainConnection_L& listConnections, am_Error_e& error);
++
++ /**
++ * returns the actual list of Sinks
++ (at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++ virtual void getListMainSinks(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SinkType_L& listMainSinks, am_Error_e& error);
++ virtual void getListMainSinks(am_SinkType_L& listMainSinks, am_Error_e& error);
++
++ /**
++ * returns the actual list of Sources
++ (at)return E_OK on success, E_DATABASE_ERROR
++ * on error
++ */
++ virtual void getListMainSources(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SourceType_L& listMainSources, am_Error_e& error);
++ virtual void getListMainSources(am_SourceType_L& listMainSources, am_Error_e& error);
++
++ /**
++ * This is used to retrieve all source sound properties related to a source.
++ * Returns a vector of the sound properties and values as pair
++ (at)return E_OK on
++ * success, E_DATABASE_ERROR on error
++ */
++ virtual void getListMainSinkSoundProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error);
++ virtual void getListMainSinkSoundProperties(am_sinkID_t sinkID, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error);
++
++ /**
++ * This is used to retrieve all source sound properties related to a
++ * source.
++ (at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++ virtual void getListMainSourceSoundProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error);
++ virtual void getListMainSourceSoundProperties(am_sourceID_t sourceID, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error);
++
++ /**
++ * This is used to retrieve SourceClass Information of all source classes
++ *
++ (at)return E_OK on success, E_DATABASE_ERROR on error
++ */
++ virtual void getListSourceClasses(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SourceClass_L& listSourceClasses, am_Error_e& error);
++ virtual void getListSourceClasses(am_SourceClass_L& listSourceClasses, am_Error_e& error);
++
++ /**
++ * This is used to retrieve SinkClass Information of all sink classes
++ (at)return
++ * E_OK on success, E_DATABASE_ERROR on error
++ */
++ virtual void getListSinkClasses(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SinkClass_L& listSinkClasses, am_Error_e& error);
++ virtual void getListSinkClasses(am_SinkClass_L& listSinkClasses, am_Error_e& error);
++
++ /**
++ * Retrieves a complete list of all systemProperties.
++ (at)return E_OK on success,
++ * E_DATABASE_ERROR on error
++ */
++ virtual void getListSystemProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SystemProperty_L& listSystemProperties, am_Error_e& error);
++ virtual void getListSystemProperties(am_SystemProperty_L& listSystemProperties, am_Error_e& error);
++
++ /**
++ * returns the delay in ms that the audiopath for the given mainConnection
++ * has
++ (at)return E_OK on success, E_NOT_POSSIBLE if timing information is not
++ * yet retrieved, E_DATABASE_ERROR on read error on the database
++ */
++ virtual void getTimingInformation(const std::shared_ptr<CommonAPI::ClientId> clientId, am_mainConnectionID_t mainConnectionID, am_timeSync_t& delay, am_Error_e& error);
++ virtual void getTimingInformation(am_mainConnectionID_t mainConnectionID, am_timeSync_t& delay, am_Error_e& error);
++
++ /**
++ * Retrieves the list of MainNotifications for a sink. Does not return the
++ * possible ones.
++ */
++ virtual void getListMainSinkNotificationConfigurations(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error);
++ virtual void getListMainSinkNotificationConfigurations(am_sinkID_t sinkID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error);
++
++ /**
++ * Retrieves the list of MainNotifications for a source. Does not return the
++ * possible ones.
++ */
++ virtual void getListMainSourceNotificationConfigurations(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error);
++ virtual void getListMainSourceNotificationConfigurations(am_sourceID_t sourceID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error);
++
++ /**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++ (at)return E_OK on
++ * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error
++ */
++ virtual void setMainSinkNotificationConfiguration(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error);
++ virtual void setMainSinkNotificationConfiguration(am_sinkID_t sinkID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error);
++
++ /**
++ * sets a MainNotificationConfiuration. This can be used to turn on an off
++ * notifications an to change the mode of the configuration.
++ (at)return E_OK on
++ * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error
++ */
++ virtual void setMainSourceNotificationConfiguration(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error);
++ virtual void setMainSourceNotificationConfiguration(am_sourceID_t sourceID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error);
++
++
++ /**
++ * Callback that is called when the number of connections change
++ */
++ virtual void fireNewMainConnectionEvent(const am_MainConnectionType_s& mainConnection);
++ /**
++ * Callback that is called when the number of connections change
++ */
++ virtual void fireRemovedMainConnectionEvent(const am_mainConnectionID_t& mainConnection);
++ /**
++ * Callback that is called when the number of sinks change
++ */
++ virtual void fireNewSinkEvent(const am_SinkType_s& sink);
++ /**
++ * Callback that is called when the number of sinks change
++ */
++ virtual void fireRemovedSinkEvent(const am_sinkID_t& sinkID);
++ /**
++ * Callback that is called when the number of sources change
++ */
++ virtual void fireNewSourceEvent(const am_SourceType_s& source);
++ /**
++ * Callback that is called when the number of sources change
++ */
++ virtual void fireRemovedSourceEvent(const am_sourceID_t& source);
++ /**
++ * this callback is fired if the number of sink classes changed
++ */
++ virtual void fireNumberOfSinkClassesChangedEvent();
++ /**
++ * this callback is fired if the number of source classes changed
++ */
++ virtual void fireNumberOfSourceClassesChangedEvent();
++ /**
++ * This callback is called when the ConnectionState of a connection changed.
++ */
++ virtual void fireMainConnectionStateChangedEvent(const am_mainConnectionID_t& connectionID, const am_ConnectionState_e& connectionState);
++ /**
++ * this callback indicates that a sinkSoundProperty has changed.
++ */
++ virtual void fireMainSinkSoundPropertyChangedEvent(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty);
++ /**
++ * this callback indicates that a sourceSoundProperty has changed.
++ */
++ virtual void fireMainSourceSoundPropertyChangedEvent(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty);
++ /**
++ * this callback is called when the availability of a sink has changed
++ */
++ virtual void fireSinkAvailabilityChangedEvent(const am_sinkID_t& sinkID, const am_Availability_s& availability);
++ /**
++ * this callback is called when the availability of source has changed.
++ */
++ virtual void fireSourceAvailabilityChangedEvent(const am_sourceID_t& sourceID, const am_Availability_s& availability);
++ /**
++ * this callback indicates a volume change on the indicated sink
++ */
++ virtual void fireVolumeChangedEvent(const am_sinkID_t& sinkID, const am_mainVolume_t& volume);
++ /**
++ * this callback indicates a mute state change on a sink.
++ */
++ virtual void fireSinkMuteStateChangedEvent(const am_sinkID_t& sinkID, const am_MuteState_e& muteState);
++ /**
++ * is fired if a systemProperty changed
++ */
++ virtual void fireSystemPropertyChangedEvent(const am_SystemProperty_s& systemProperty);
++ /**
++ * This callback is fired if the timinginformation for a mainConnectionID changed
++ */
++ virtual void fireTimingInformationChangedEvent(const am_mainConnectionID_t& mainConnectionID, const am_timeSync_t& time);
++ /**
++ * This callback is called when a sink is updated.
++ */
++ virtual void fireSinkUpdatedEvent(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_MainSoundProperty_L& listMainSoundProperties);
++ /**
++ * This callback is called when a source is updated.
++ */
++ virtual void fireSourceUpdatedEvent(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_MainSoundProperty_L& listMainSoundProperties);
++ /**
++ * This callback is called when a notificated value of a sink changes.
++ */
++ virtual void fireSinkNotificationEvent(const am_sinkID_t& sinkID, const am_NotificationPayload_s& notification);
++ /**
++ * This callback is called when a notifcated value of a source changes.
++ */
++ virtual void fireSourceNotificationEvent(const am_sourceID_t& sourceID, const am_NotificationPayload_s& notification);
++ /**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++ virtual void fireMainSinkNotificationConfigurationChangedEvent(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration);
++ /**
++ * This callback is triggered when a mainNotificationConfiguration is changed.
++ */
++ virtual void fireMainSourceNotificationConfigurationChangedEvent(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration);
++
++
++protected:
++ class RemoteEventHandler: public virtual CommandControlStubRemoteEvent {
++ public:
++ RemoteEventHandler(CommandControlStubDefault* defaultStub);
++
++
++ private:
++ CommandControlStubDefault* defaultStub_;
++ };
++private:
++ CommandControlStubDefault::RemoteEventHandler remoteEventHandler_;
++
++
++ CommonAPI::Version interfaceVersion_;
++};
++
++} // namespace am
++} // namespace genivi
++} // namespace org
++
++#endif // ORG_GENIVI_AM_Command_Control_STUB_DEFAULT_H_
+diff --git a/PluginRoutingInterfaceCAPI/src-gen/org/genivi/am.cpp b/PluginRoutingInterfaceCAPI/src-gen/org/genivi/am.cpp
+new file mode 100644
+index 0000000..8092420
+--- /dev/null
++++ b/PluginRoutingInterfaceCAPI/src-gen/org/genivi/am.cpp
+@@ -0,0 +1,1043 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#include "am.h"
++
++
++namespace org {
++namespace genivi {
++namespace am {
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++am_Route_s::am_Route_s(const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_RoutingElement_L& routeValue):
++ sourceID(sourceIDValue),
++ sinkID(sinkIDValue),
++ route(routeValue)
++{
++}
++
++
++bool operator==(const am_Route_s& lhs, const am_Route_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sourceID == rhs.sourceID &&
++ lhs.sinkID == rhs.sinkID &&
++ lhs.route == rhs.route
++ ;
++}
++
++void am_Route_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sourceID;
++ inputStream >> sinkID;
++ inputStream >> route;
++}
++
++void am_Route_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sourceID;
++ outputStream << sinkID;
++ outputStream << route;
++}
++
++am_Availability_s::am_Availability_s(const am_Availability_e& availabilityValue, const am_CustomAvailabilityReason_t& availabilityReasonValue):
++ availability(availabilityValue),
++ availabilityReason(availabilityReasonValue)
++{
++}
++
++
++bool operator==(const am_Availability_s& lhs, const am_Availability_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.availability == rhs.availability &&
++ lhs.availabilityReason == rhs.availabilityReason
++ ;
++}
++
++void am_Availability_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> availability;
++ inputStream >> availabilityReason;
++}
++
++void am_Availability_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << availability;
++ outputStream << availabilityReason;
++}
++
++am_ClassProperty_s::am_ClassProperty_s(const am_CustomClassProperty_t& classPropertyValue, const int16_t& valueValue):
++ classProperty(classPropertyValue),
++ value(valueValue)
++{
++}
++
++
++bool operator==(const am_ClassProperty_s& lhs, const am_ClassProperty_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.classProperty == rhs.classProperty &&
++ lhs.value == rhs.value
++ ;
++}
++
++void am_ClassProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> classProperty;
++ inputStream >> value;
++}
++
++void am_ClassProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << classProperty;
++ outputStream << value;
++}
++
++am_Crossfader_s::am_Crossfader_s(const am_crossfaderID_t& crossfaderIDValue, const std::string& nameValue, const am_sinkID_t& sinkID_AValue, const am_sinkID_t& sinkID_BValue, const am_sourceID_t& sourceIDValue, const am_HotSink_e& hotSinkValue):
++ crossfaderID(crossfaderIDValue),
++ name(nameValue),
++ sinkID_A(sinkID_AValue),
++ sinkID_B(sinkID_BValue),
++ sourceID(sourceIDValue),
++ hotSink(hotSinkValue)
++{
++}
++
++
++bool operator==(const am_Crossfader_s& lhs, const am_Crossfader_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.crossfaderID == rhs.crossfaderID &&
++ lhs.name == rhs.name &&
++ lhs.sinkID_A == rhs.sinkID_A &&
++ lhs.sinkID_B == rhs.sinkID_B &&
++ lhs.sourceID == rhs.sourceID &&
++ lhs.hotSink == rhs.hotSink
++ ;
++}
++
++void am_Crossfader_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> crossfaderID;
++ inputStream >> name;
++ inputStream >> sinkID_A;
++ inputStream >> sinkID_B;
++ inputStream >> sourceID;
++ inputStream >> hotSink;
++}
++
++void am_Crossfader_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << crossfaderID;
++ outputStream << name;
++ outputStream << sinkID_A;
++ outputStream << sinkID_B;
++ outputStream << sourceID;
++ outputStream << hotSink;
++}
++
++am_Gateway_s::am_Gateway_s(const am_gatewayID_t& gatewayIDValue, const std::string& nameValue, const am_sinkID_t& sinkIDValue, const am_sourceID_t& sourceIDValue, const am_domainID_t& domainSinkIDValue, const am_domainID_t& domainSourceIDValue, const am_domainID_t& controlDomainIDValue, const am_ConnectionFormat_L& listSourceFormatsValue, const am_ConnectionFormat_L& listSinkFormatsValue, const am_Convertion_L& convertionMatrixValue):
++ gatewayID(gatewayIDValue),
++ name(nameValue),
++ sinkID(sinkIDValue),
++ sourceID(sourceIDValue),
++ domainSinkID(domainSinkIDValue),
++ domainSourceID(domainSourceIDValue),
++ controlDomainID(controlDomainIDValue),
++ listSourceFormats(listSourceFormatsValue),
++ listSinkFormats(listSinkFormatsValue),
++ convertionMatrix(convertionMatrixValue)
++{
++}
++
++
++bool operator==(const am_Gateway_s& lhs, const am_Gateway_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.gatewayID == rhs.gatewayID &&
++ lhs.name == rhs.name &&
++ lhs.sinkID == rhs.sinkID &&
++ lhs.sourceID == rhs.sourceID &&
++ lhs.domainSinkID == rhs.domainSinkID &&
++ lhs.domainSourceID == rhs.domainSourceID &&
++ lhs.controlDomainID == rhs.controlDomainID &&
++ lhs.listSourceFormats == rhs.listSourceFormats &&
++ lhs.listSinkFormats == rhs.listSinkFormats &&
++ lhs.convertionMatrix == rhs.convertionMatrix
++ ;
++}
++
++void am_Gateway_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> gatewayID;
++ inputStream >> name;
++ inputStream >> sinkID;
++ inputStream >> sourceID;
++ inputStream >> domainSinkID;
++ inputStream >> domainSourceID;
++ inputStream >> controlDomainID;
++ inputStream >> listSourceFormats;
++ inputStream >> listSinkFormats;
++ inputStream >> convertionMatrix;
++}
++
++void am_Gateway_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << gatewayID;
++ outputStream << name;
++ outputStream << sinkID;
++ outputStream << sourceID;
++ outputStream << domainSinkID;
++ outputStream << domainSourceID;
++ outputStream << controlDomainID;
++ outputStream << listSourceFormats;
++ outputStream << listSinkFormats;
++ outputStream << convertionMatrix;
++}
++
++am_Converter_s::am_Converter_s(const am_converterID_t& converterIDValue, const std::string& nameValue, const am_sinkID_t& sinkIDValue, const am_sourceID_t& sourceIDValue, const am_domainID_t& domainIDValue, const am_ConnectionFormat_L& listSourceFormatsValue, const am_ConnectionFormat_L& listSinkFormatsValue, const am_Convertion_L& convertionMatrixValue):
++ converterID(converterIDValue),
++ name(nameValue),
++ sinkID(sinkIDValue),
++ sourceID(sourceIDValue),
++ domainID(domainIDValue),
++ listSourceFormats(listSourceFormatsValue),
++ listSinkFormats(listSinkFormatsValue),
++ convertionMatrix(convertionMatrixValue)
++{
++}
++
++
++bool operator==(const am_Converter_s& lhs, const am_Converter_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.converterID == rhs.converterID &&
++ lhs.name == rhs.name &&
++ lhs.sinkID == rhs.sinkID &&
++ lhs.sourceID == rhs.sourceID &&
++ lhs.domainID == rhs.domainID &&
++ lhs.listSourceFormats == rhs.listSourceFormats &&
++ lhs.listSinkFormats == rhs.listSinkFormats &&
++ lhs.convertionMatrix == rhs.convertionMatrix
++ ;
++}
++
++void am_Converter_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> converterID;
++ inputStream >> name;
++ inputStream >> sinkID;
++ inputStream >> sourceID;
++ inputStream >> domainID;
++ inputStream >> listSourceFormats;
++ inputStream >> listSinkFormats;
++ inputStream >> convertionMatrix;
++}
++
++void am_Converter_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << converterID;
++ outputStream << name;
++ outputStream << sinkID;
++ outputStream << sourceID;
++ outputStream << domainID;
++ outputStream << listSourceFormats;
++ outputStream << listSinkFormats;
++ outputStream << convertionMatrix;
++}
++
++am_RoutingElement_s::am_RoutingElement_s(const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_domainID_t& domainIDValue, const am_CustomConnectionFormat_t& connectionFormatValue):
++ sourceID(sourceIDValue),
++ sinkID(sinkIDValue),
++ domainID(domainIDValue),
++ connectionFormat(connectionFormatValue)
++{
++}
++
++
++bool operator==(const am_RoutingElement_s& lhs, const am_RoutingElement_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sourceID == rhs.sourceID &&
++ lhs.sinkID == rhs.sinkID &&
++ lhs.domainID == rhs.domainID &&
++ lhs.connectionFormat == rhs.connectionFormat
++ ;
++}
++
++void am_RoutingElement_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sourceID;
++ inputStream >> sinkID;
++ inputStream >> domainID;
++ inputStream >> connectionFormat;
++}
++
++void am_RoutingElement_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sourceID;
++ outputStream << sinkID;
++ outputStream << domainID;
++ outputStream << connectionFormat;
++}
++
++am_SoundProperty_s::am_SoundProperty_s(const am_CustomSoundPropertyType_t& typeValue, const int16_t& valueValue):
++ type(typeValue),
++ value(valueValue)
++{
++}
++
++
++bool operator==(const am_SoundProperty_s& lhs, const am_SoundProperty_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.type == rhs.type &&
++ lhs.value == rhs.value
++ ;
++}
++
++void am_SoundProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> type;
++ inputStream >> value;
++}
++
++void am_SoundProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << type;
++ outputStream << value;
++}
++
++am_SystemProperty_s::am_SystemProperty_s(const am_CustomSystemPropertyType_t& typeValue, const int16_t& valueValue):
++ type(typeValue),
++ value(valueValue)
++{
++}
++
++
++bool operator==(const am_SystemProperty_s& lhs, const am_SystemProperty_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.type == rhs.type &&
++ lhs.value == rhs.value
++ ;
++}
++
++void am_SystemProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> type;
++ inputStream >> value;
++}
++
++void am_SystemProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << type;
++ outputStream << value;
++}
++
++am_SinkClass_s::am_SinkClass_s(const am_sinkClass_t& sinkClassIDValue, const std::string& nameValue, const am_ClassProperty_L& listClassPropertiesValue):
++ sinkClassID(sinkClassIDValue),
++ name(nameValue),
++ listClassProperties(listClassPropertiesValue)
++{
++}
++
++
++bool operator==(const am_SinkClass_s& lhs, const am_SinkClass_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sinkClassID == rhs.sinkClassID &&
++ lhs.name == rhs.name &&
++ lhs.listClassProperties == rhs.listClassProperties
++ ;
++}
++
++void am_SinkClass_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sinkClassID;
++ inputStream >> name;
++ inputStream >> listClassProperties;
++}
++
++void am_SinkClass_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sinkClassID;
++ outputStream << name;
++ outputStream << listClassProperties;
++}
++
++am_SourceClass_s::am_SourceClass_s(const am_sourceClass_t& sourceClassIDValue, const std::string& nameValue, const am_ClassProperty_L& listClassPropertiesValue):
++ sourceClassID(sourceClassIDValue),
++ name(nameValue),
++ listClassProperties(listClassPropertiesValue)
++{
++}
++
++
++bool operator==(const am_SourceClass_s& lhs, const am_SourceClass_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sourceClassID == rhs.sourceClassID &&
++ lhs.name == rhs.name &&
++ lhs.listClassProperties == rhs.listClassProperties
++ ;
++}
++
++void am_SourceClass_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sourceClassID;
++ inputStream >> name;
++ inputStream >> listClassProperties;
++}
++
++void am_SourceClass_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sourceClassID;
++ outputStream << name;
++ outputStream << listClassProperties;
++}
++
++am_SourceType_s::am_SourceType_s(const am_sourceID_t& sourceIDValue, const std::string& nameValue, const am_Availability_s& availabilityValue, const am_sourceClass_t& sourceClassIDValue):
++ sourceID(sourceIDValue),
++ name(nameValue),
++ availability(availabilityValue),
++ sourceClassID(sourceClassIDValue)
++{
++}
++
++
++bool operator==(const am_SourceType_s& lhs, const am_SourceType_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sourceID == rhs.sourceID &&
++ lhs.name == rhs.name &&
++ lhs.availability == rhs.availability &&
++ lhs.sourceClassID == rhs.sourceClassID
++ ;
++}
++
++void am_SourceType_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sourceID;
++ inputStream >> name;
++ inputStream >> availability;
++ inputStream >> sourceClassID;
++}
++
++void am_SourceType_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sourceID;
++ outputStream << name;
++ outputStream << availability;
++ outputStream << sourceClassID;
++}
++
++am_SinkType_s::am_SinkType_s(const am_sinkID_t& sinkIDValue, const std::string& nameValue, const am_Availability_s& availabilityValue, const am_mainVolume_t& volumeValue, const am_MuteState_e& muteStateValue, const am_sinkClass_t& sinkClassIDValue):
++ sinkID(sinkIDValue),
++ name(nameValue),
++ availability(availabilityValue),
++ volume(volumeValue),
++ muteState(muteStateValue),
++ sinkClassID(sinkClassIDValue)
++{
++}
++
++
++bool operator==(const am_SinkType_s& lhs, const am_SinkType_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sinkID == rhs.sinkID &&
++ lhs.name == rhs.name &&
++ lhs.availability == rhs.availability &&
++ lhs.volume == rhs.volume &&
++ lhs.muteState == rhs.muteState &&
++ lhs.sinkClassID == rhs.sinkClassID
++ ;
++}
++
++void am_SinkType_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sinkID;
++ inputStream >> name;
++ inputStream >> availability;
++ inputStream >> volume;
++ inputStream >> muteState;
++ inputStream >> sinkClassID;
++}
++
++void am_SinkType_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sinkID;
++ outputStream << name;
++ outputStream << availability;
++ outputStream << volume;
++ outputStream << muteState;
++ outputStream << sinkClassID;
++}
++
++am_Handle_s::am_Handle_s(const am_Handle_e& handleTypeValue, const uint16_t& handleValue):
++ handleType(handleTypeValue),
++ handle(handleValue)
++{
++}
++
++
++bool operator==(const am_Handle_s& lhs, const am_Handle_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.handleType == rhs.handleType &&
++ lhs.handle == rhs.handle
++ ;
++}
++
++void am_Handle_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> handleType;
++ inputStream >> handle;
++}
++
++void am_Handle_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << handleType;
++ outputStream << handle;
++}
++
++am_MainSoundProperty_s::am_MainSoundProperty_s(const am_CustomMainSoundPropertyType_t& typeValue, const int16_t& valueValue):
++ type(typeValue),
++ value(valueValue)
++{
++}
++
++
++bool operator==(const am_MainSoundProperty_s& lhs, const am_MainSoundProperty_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.type == rhs.type &&
++ lhs.value == rhs.value
++ ;
++}
++
++void am_MainSoundProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> type;
++ inputStream >> value;
++}
++
++void am_MainSoundProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << type;
++ outputStream << value;
++}
++
++am_MainConnectionType_s::am_MainConnectionType_s(const am_mainConnectionID_t& mainConnectionIDValue, const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_timeSync_t& delayValue, const am_ConnectionState_e& connectionStateValue):
++ mainConnectionID(mainConnectionIDValue),
++ sourceID(sourceIDValue),
++ sinkID(sinkIDValue),
++ delay(delayValue),
++ connectionState(connectionStateValue)
++{
++}
++
++
++bool operator==(const am_MainConnectionType_s& lhs, const am_MainConnectionType_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.mainConnectionID == rhs.mainConnectionID &&
++ lhs.sourceID == rhs.sourceID &&
++ lhs.sinkID == rhs.sinkID &&
++ lhs.delay == rhs.delay &&
++ lhs.connectionState == rhs.connectionState
++ ;
++}
++
++void am_MainConnectionType_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> mainConnectionID;
++ inputStream >> sourceID;
++ inputStream >> sinkID;
++ inputStream >> delay;
++ inputStream >> connectionState;
++}
++
++void am_MainConnectionType_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << mainConnectionID;
++ outputStream << sourceID;
++ outputStream << sinkID;
++ outputStream << delay;
++ outputStream << connectionState;
++}
++
++am_MainConnection_s::am_MainConnection_s(const am_mainConnectionID_t& mainConnectionIDValue, const am_ConnectionState_e& connectionStateValue, const am_sinkID_t& sinkIDValue, const am_sourceID_t& sourceIDValue, const am_timeSync_t& delayValue, const am_ConnectionID_L& listConnectionIDValue):
++ mainConnectionID(mainConnectionIDValue),
++ connectionState(connectionStateValue),
++ sinkID(sinkIDValue),
++ sourceID(sourceIDValue),
++ delay(delayValue),
++ listConnectionID(listConnectionIDValue)
++{
++}
++
++
++bool operator==(const am_MainConnection_s& lhs, const am_MainConnection_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.mainConnectionID == rhs.mainConnectionID &&
++ lhs.connectionState == rhs.connectionState &&
++ lhs.sinkID == rhs.sinkID &&
++ lhs.sourceID == rhs.sourceID &&
++ lhs.delay == rhs.delay &&
++ lhs.listConnectionID == rhs.listConnectionID
++ ;
++}
++
++void am_MainConnection_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> mainConnectionID;
++ inputStream >> connectionState;
++ inputStream >> sinkID;
++ inputStream >> sourceID;
++ inputStream >> delay;
++ inputStream >> listConnectionID;
++}
++
++void am_MainConnection_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << mainConnectionID;
++ outputStream << connectionState;
++ outputStream << sinkID;
++ outputStream << sourceID;
++ outputStream << delay;
++ outputStream << listConnectionID;
++}
++
++am_NotificationPayload_s::am_NotificationPayload_s(const am_CustomNotificationType_t& typeValue, const int16_t& valueValue):
++ type(typeValue),
++ value(valueValue)
++{
++}
++
++
++bool operator==(const am_NotificationPayload_s& lhs, const am_NotificationPayload_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.type == rhs.type &&
++ lhs.value == rhs.value
++ ;
++}
++
++void am_NotificationPayload_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> type;
++ inputStream >> value;
++}
++
++void am_NotificationPayload_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << type;
++ outputStream << value;
++}
++
++am_NotificationConfiguration_s::am_NotificationConfiguration_s(const am_CustomNotificationType_t& typeValue, const am_NotificationStatus_e& statusValue, const int16_t& parameterValue):
++ type(typeValue),
++ status(statusValue),
++ parameter(parameterValue)
++{
++}
++
++
++bool operator==(const am_NotificationConfiguration_s& lhs, const am_NotificationConfiguration_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.type == rhs.type &&
++ lhs.status == rhs.status &&
++ lhs.parameter == rhs.parameter
++ ;
++}
++
++void am_NotificationConfiguration_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> type;
++ inputStream >> status;
++ inputStream >> parameter;
++}
++
++void am_NotificationConfiguration_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << type;
++ outputStream << status;
++ outputStream << parameter;
++}
++
++am_Sink_s::am_Sink_s(const am_sinkID_t& sinkIDValue, const std::string& nameValue, const am_domainID_t& domainIDValue, const am_sinkClass_t& sinkClassIDValue, const am_volume_t& volumeValue, const bool& visibleValue, const am_Availability_s& availableValue, const am_MuteState_e& muteStateValue, const am_mainVolume_t& mainVolumeValue, const am_SoundProperty_L& listSoundPropertiesValue, const am_ConnectionFormat_L& listConnectionFormatsValue, const am_MainSoundProperty_L& listMainSoundPropertiesValue, const am_NotificationConfiguration_L& listMainNotificationConfigurationsValue, const am_NotificationConfiguration_L& listNotificationConfigurationsValue):
++ sinkID(sinkIDValue),
++ name(nameValue),
++ domainID(domainIDValue),
++ sinkClassID(sinkClassIDValue),
++ volume(volumeValue),
++ visible(visibleValue),
++ available(availableValue),
++ muteState(muteStateValue),
++ mainVolume(mainVolumeValue),
++ listSoundProperties(listSoundPropertiesValue),
++ listConnectionFormats(listConnectionFormatsValue),
++ listMainSoundProperties(listMainSoundPropertiesValue),
++ listMainNotificationConfigurations(listMainNotificationConfigurationsValue),
++ listNotificationConfigurations(listNotificationConfigurationsValue)
++{
++}
++
++
++bool operator==(const am_Sink_s& lhs, const am_Sink_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sinkID == rhs.sinkID &&
++ lhs.name == rhs.name &&
++ lhs.domainID == rhs.domainID &&
++ lhs.sinkClassID == rhs.sinkClassID &&
++ lhs.volume == rhs.volume &&
++ lhs.visible == rhs.visible &&
++ lhs.available == rhs.available &&
++ lhs.muteState == rhs.muteState &&
++ lhs.mainVolume == rhs.mainVolume &&
++ lhs.listSoundProperties == rhs.listSoundProperties &&
++ lhs.listConnectionFormats == rhs.listConnectionFormats &&
++ lhs.listMainSoundProperties == rhs.listMainSoundProperties &&
++ lhs.listMainNotificationConfigurations == rhs.listMainNotificationConfigurations &&
++ lhs.listNotificationConfigurations == rhs.listNotificationConfigurations
++ ;
++}
++
++void am_Sink_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sinkID;
++ inputStream >> name;
++ inputStream >> domainID;
++ inputStream >> sinkClassID;
++ inputStream >> volume;
++ inputStream >> visible;
++ inputStream >> available;
++ inputStream >> muteState;
++ inputStream >> mainVolume;
++ inputStream >> listSoundProperties;
++ inputStream >> listConnectionFormats;
++ inputStream >> listMainSoundProperties;
++ inputStream >> listMainNotificationConfigurations;
++ inputStream >> listNotificationConfigurations;
++}
++
++void am_Sink_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sinkID;
++ outputStream << name;
++ outputStream << domainID;
++ outputStream << sinkClassID;
++ outputStream << volume;
++ outputStream << visible;
++ outputStream << available;
++ outputStream << muteState;
++ outputStream << mainVolume;
++ outputStream << listSoundProperties;
++ outputStream << listConnectionFormats;
++ outputStream << listMainSoundProperties;
++ outputStream << listMainNotificationConfigurations;
++ outputStream << listNotificationConfigurations;
++}
++
++am_Source_s::am_Source_s(const am_sourceID_t& sourceIDValue, const am_domainID_t& domainIDValue, const std::string& nameValue, const am_sourceClass_t& sourceClassIDValue, const am_SourceState_e& sourceStateValue, const am_volume_t& volumeValue, const bool& visibleValue, const am_Availability_s& availableValue, const am_InterruptState_e& interruptStateValue, const am_SoundProperty_L& listSoundPropertiesValue, const am_ConnectionFormat_L& listConnectionFormatsValue, const am_MainSoundProperty_L& listMainSoundPropertiesValue, const am_NotificationConfiguration_L& listMainNotificationConfigurationsValue, const am_NotificationConfiguration_L& listNotificationConfigurationsValue):
++ sourceID(sourceIDValue),
++ domainID(domainIDValue),
++ name(nameValue),
++ sourceClassID(sourceClassIDValue),
++ sourceState(sourceStateValue),
++ volume(volumeValue),
++ visible(visibleValue),
++ available(availableValue),
++ interruptState(interruptStateValue),
++ listSoundProperties(listSoundPropertiesValue),
++ listConnectionFormats(listConnectionFormatsValue),
++ listMainSoundProperties(listMainSoundPropertiesValue),
++ listMainNotificationConfigurations(listMainNotificationConfigurationsValue),
++ listNotificationConfigurations(listNotificationConfigurationsValue)
++{
++}
++
++
++bool operator==(const am_Source_s& lhs, const am_Source_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.sourceID == rhs.sourceID &&
++ lhs.domainID == rhs.domainID &&
++ lhs.name == rhs.name &&
++ lhs.sourceClassID == rhs.sourceClassID &&
++ lhs.sourceState == rhs.sourceState &&
++ lhs.volume == rhs.volume &&
++ lhs.visible == rhs.visible &&
++ lhs.available == rhs.available &&
++ lhs.interruptState == rhs.interruptState &&
++ lhs.listSoundProperties == rhs.listSoundProperties &&
++ lhs.listConnectionFormats == rhs.listConnectionFormats &&
++ lhs.listMainSoundProperties == rhs.listMainSoundProperties &&
++ lhs.listMainNotificationConfigurations == rhs.listMainNotificationConfigurations &&
++ lhs.listNotificationConfigurations == rhs.listNotificationConfigurations
++ ;
++}
++
++void am_Source_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> sourceID;
++ inputStream >> domainID;
++ inputStream >> name;
++ inputStream >> sourceClassID;
++ inputStream >> sourceState;
++ inputStream >> volume;
++ inputStream >> visible;
++ inputStream >> available;
++ inputStream >> interruptState;
++ inputStream >> listSoundProperties;
++ inputStream >> listConnectionFormats;
++ inputStream >> listMainSoundProperties;
++ inputStream >> listMainNotificationConfigurations;
++ inputStream >> listNotificationConfigurations;
++}
++
++void am_Source_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << sourceID;
++ outputStream << domainID;
++ outputStream << name;
++ outputStream << sourceClassID;
++ outputStream << sourceState;
++ outputStream << volume;
++ outputStream << visible;
++ outputStream << available;
++ outputStream << interruptState;
++ outputStream << listSoundProperties;
++ outputStream << listConnectionFormats;
++ outputStream << listMainSoundProperties;
++ outputStream << listMainNotificationConfigurations;
++ outputStream << listNotificationConfigurations;
++}
++
++am_Domain_s::am_Domain_s(const am_domainID_t& domainIDValue, const std::string& nameValue, const std::string& busnameValue, const std::string& nodenameValue, const bool& earlyValue, const bool& completeValue, const am_DomainState_e& stateValue):
++ domainID(domainIDValue),
++ name(nameValue),
++ busname(busnameValue),
++ nodename(nodenameValue),
++ early(earlyValue),
++ complete(completeValue),
++ state(stateValue)
++{
++}
++
++
++bool operator==(const am_Domain_s& lhs, const am_Domain_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.domainID == rhs.domainID &&
++ lhs.name == rhs.name &&
++ lhs.busname == rhs.busname &&
++ lhs.nodename == rhs.nodename &&
++ lhs.early == rhs.early &&
++ lhs.complete == rhs.complete &&
++ lhs.state == rhs.state
++ ;
++}
++
++void am_Domain_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> domainID;
++ inputStream >> name;
++ inputStream >> busname;
++ inputStream >> nodename;
++ inputStream >> early;
++ inputStream >> complete;
++ inputStream >> state;
++}
++
++void am_Domain_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << domainID;
++ outputStream << name;
++ outputStream << busname;
++ outputStream << nodename;
++ outputStream << early;
++ outputStream << complete;
++ outputStream << state;
++}
++
++am_EarlyData_s::am_EarlyData_s(const am_EarlyDataType_e& typeValue, const am_DataType_u& sinksourceValue, const am_EarlyData_u& dataValue):
++ type(typeValue),
++ sinksource(sinksourceValue),
++ data(dataValue)
++{
++}
++
++
++bool operator==(const am_EarlyData_s& lhs, const am_EarlyData_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.type == rhs.type &&
++ lhs.sinksource == rhs.sinksource &&
++ lhs.data == rhs.data
++ ;
++}
++
++void am_EarlyData_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> type;
++ inputStream >> sinksource;
++ inputStream >> data;
++}
++
++void am_EarlyData_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << type;
++ outputStream << sinksource;
++ outputStream << data;
++}
++
++am_Connection_s::am_Connection_s(const am_connectionID_t& connectionIDValue, const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_timeSync_t& delayValue, const am_CustomConnectionFormat_t& connectionFormatValue):
++ connectionID(connectionIDValue),
++ sourceID(sourceIDValue),
++ sinkID(sinkIDValue),
++ delay(delayValue),
++ connectionFormat(connectionFormatValue)
++{
++}
++
++
++bool operator==(const am_Connection_s& lhs, const am_Connection_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.connectionID == rhs.connectionID &&
++ lhs.sourceID == rhs.sourceID &&
++ lhs.sinkID == rhs.sinkID &&
++ lhs.delay == rhs.delay &&
++ lhs.connectionFormat == rhs.connectionFormat
++ ;
++}
++
++void am_Connection_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> connectionID;
++ inputStream >> sourceID;
++ inputStream >> sinkID;
++ inputStream >> delay;
++ inputStream >> connectionFormat;
++}
++
++void am_Connection_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << connectionID;
++ outputStream << sourceID;
++ outputStream << sinkID;
++ outputStream << delay;
++ outputStream << connectionFormat;
++}
++
++am_Volumes_s::am_Volumes_s(const am_VolumeType_e& volumeTypeValue, const am_DataType_u& volumeIDValue, const am_volume_t& volumeValue, const am_CustomRampType_t& rampValue, const am_time_t& timeValue):
++ volumeType(volumeTypeValue),
++ volumeID(volumeIDValue),
++ volume(volumeValue),
++ ramp(rampValue),
++ time(timeValue)
++{
++}
++
++
++bool operator==(const am_Volumes_s& lhs, const am_Volumes_s& rhs) {
++ if (&lhs == &rhs)
++ return true;
++
++ return
++ lhs.volumeType == rhs.volumeType &&
++ lhs.volumeID == rhs.volumeID &&
++ lhs.volume == rhs.volume &&
++ lhs.ramp == rhs.ramp &&
++ lhs.time == rhs.time
++ ;
++}
++
++void am_Volumes_s::readFromInputStream(CommonAPI::InputStream& inputStream) {
++ inputStream >> volumeType;
++ inputStream >> volumeID;
++ inputStream >> volume;
++ inputStream >> ramp;
++ inputStream >> time;
++}
++
++void am_Volumes_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
++ outputStream << volumeType;
++ outputStream << volumeID;
++ outputStream << volume;
++ outputStream << ramp;
++ outputStream << time;
++}
++
++
++
++} // namespace am
++} // namespace genivi
++} // namespace org
+diff --git a/PluginRoutingInterfaceCAPI/src-gen/org/genivi/am.h b/PluginRoutingInterfaceCAPI/src-gen/org/genivi/am.h
+new file mode 100644
+index 0000000..e75db5d
+--- /dev/null
++++ b/PluginRoutingInterfaceCAPI/src-gen/org/genivi/am.h
+@@ -0,0 +1,2551 @@
++/*
++* This file was generated by the CommonAPI Generators.
++* Used org.genivi.commonapi.core 2.1.6.v20150127.
++* Used org.franca.core 0.8.10.201309262002.
++*
++*
++*/
++/**
++ * @author Christian Linke
++ */
++#ifndef ORG_GENIVI_am_H_
++#define ORG_GENIVI_am_H_
++
++
++
++#if !defined (COMMONAPI_INTERNAL_COMPILATION)
++#define COMMONAPI_INTERNAL_COMPILATION
++#endif
++
++#include <CommonAPI/InputStream.h>
++#include <CommonAPI/OutputStream.h>
++#include <CommonAPI/SerializableStruct.h>
++#include <CommonAPI/SerializableVariant.h>
++#include <CommonAPI/types.h>
++#include <cstdint>
++#include <memory>
++#include <string>
++#include <vector>
++
++#undef COMMONAPI_INTERNAL_COMPILATION
++
++namespace org {
++namespace genivi {
++
++namespace am {
++ /**
++ * a source ID
++ */
++ /**
++ * a source ID
++ */
++ typedef uint16_t am_sourceID_t;
++ /**
++ * a mainConnection ID
++ */
++ /**
++ * a mainConnection ID
++ */
++ typedef uint16_t am_mainConnectionID_t;
++ /**
++ * offset time that is introduced in milli seconds.
++ */
++ /**
++ * offset time that is introduced in milli seconds.
++ */
++ typedef int16_t am_timeSync_t;
++ /**
++ * a sink ID
++ */
++ /**
++ * a sink ID
++ */
++ typedef uint16_t am_sinkID_t;
++ /**
++ * represents the connection state
++ */
++ enum class am_ConnectionState_e: int32_t {
++ CS_UNKNOWN = 0,
++ /**
++ * This means the connection is just building up
++ */
++ CS_CONNECTING = 1,
++ /**
++ * the connection is ready to be used
++ */
++ CS_CONNECTED = 2,
++ /**
++ * the connection is in the course to be knocked down
++ */
++ CS_DISCONNECTING = 3,
++ /**
++ * only relevant for connectionStatechanged. Is send after the connection was
++ * removed
++ */
++ CS_DISCONNECTED = 4,
++ /**
++ * this means the connection is still build up but unused at the moment
++ */
++ CS_SUSPENDED = 5,
++ CS_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_ConnectionState_eComparator;
++ /**
++ * this type holds all information of connections relevant to the HMI
++ */
++ /**
++ * this type holds all information of connections relevant to the HMI
++ */
++ struct am_MainConnectionType_s: CommonAPI::SerializableStruct {
++ /**
++ * the ID of the mainconnection
++ */
++ am_mainConnectionID_t mainConnectionID;
++ /**
++ * the sourceID where the connection starts
++ */
++ am_sourceID_t sourceID;
++ /**
++ * the sinkID where the connection ends
++ */
++ am_sinkID_t sinkID;
++ /**
++ * the delay of the mainconnection
++ */
++ am_timeSync_t delay;
++ /**
++ * the current connection state
++ */
++ am_ConnectionState_e connectionState;
++
++ am_MainConnectionType_s() = default;
++ am_MainConnectionType_s(const am_mainConnectionID_t& mainConnectionID, const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, const am_timeSync_t& delay, const am_ConnectionState_e& connectionState);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ typeOutputStream.writeInt32Type();
++ }
++ };
++ typedef std::vector<am_MainConnectionType_s> am_MainConnection_L;
++ /**
++ * product specific identifier of property
++ */
++ /**
++ * product specific identifier of property
++ */
++ typedef uint16_t am_CustomClassProperty_t;
++ /**
++ * describes class properties
++ */
++ /**
++ * describes class properties
++ */
++ struct am_ClassProperty_s: CommonAPI::SerializableStruct {
++ /**
++ * the property as enum
++ */
++ am_CustomClassProperty_t classProperty;
++ /**
++ * the value of the property
++ */
++ int16_t value;
++
++ am_ClassProperty_s() = default;
++ am_ClassProperty_s(const am_CustomClassProperty_t& classProperty, const int16_t& value);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ }
++ };
++ typedef std::vector<am_ClassProperty_s> am_ClassProperty_L;
++ typedef uint16_t am_sinkClass_t;
++ /**
++ * struct describing sinkclasses
++ */
++ /**
++ * struct describing sinkclasses
++ */
++ struct am_SinkClass_s: CommonAPI::SerializableStruct {
++ /**
++ * the ID of the sinkClass
++ */
++ am_sinkClass_t sinkClassID;
++ /**
++ * the name of the sinkClass - must be unique in the system
++ */
++ std::string name;
++ /**
++ * the list of the class properties. These are pairs of a project specific enum
++ * describing the type of the value and an integer holding the real value.
++ */
++ am_ClassProperty_L listClassProperties;
++
++ am_SinkClass_s() = default;
++ am_SinkClass_s(const am_sinkClass_t& sinkClassID, const std::string& name, const am_ClassProperty_L& listClassProperties);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ typedef std::vector<am_SinkClass_s> am_SinkClass_L;
++ /**
++ * This is the volume presented on the command interface. It is in the duty of the
++ * Controller to change the volumes given here into meaningful values on the
++ * routing interface.
++ The range of this type is customer specific.
++ */
++ /**
++ * This is the volume presented on the command interface. It is in the duty of the
++ * Controller to change the volumes given here into meaningful values on the
++ * routing interface.
++ The range of this type is customer specific.
++ */
++ typedef int16_t am_mainVolume_t;
++ /**
++ * This project specific value gives the information about reason for reason for
++ * Source/Sink change
++ */
++ /**
++ * This project specific value gives the information about reason for reason for
++ * Source/Sink change
++ */
++ typedef uint16_t am_CustomAvailabilityReason_t;
++ /**
++ * with the help of this enum, sinks and sources can report their availability
++ * state
++ */
++ enum class am_Availability_e: int32_t {
++ /**
++ * default
++ */
++ A_UNKNOWN = 0,
++ /**
++ * The source / sink is available
++ */
++ A_AVAILABLE = 1,
++ /**
++ * the source / sink is not available
++ */
++ A_UNAVAILABLE = 2,
++ A_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_Availability_eComparator;
++ enum class am_MuteState_e: int32_t {
++ /**
++ * default
++ */
++ MS_UNKNOWN = 0,
++ /**
++ * the source / sink is muted
++ */
++ MS_MUTED = 1,
++ /**
++ * the source / sink is unmuted
++ */
++ MS_UNMUTED = 2,
++ MS_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_MuteState_eComparator;
++ /**
++ * this describes the availability of a sink or a source together with the latest
++ * change
++ */
++ /**
++ * this describes the availability of a sink or a source together with the latest
++ * change
++ */
++ struct am_Availability_s: CommonAPI::SerializableStruct {
++ /**
++ * the current availability state
++ */
++ am_Availability_e availability;
++ /**
++ * the reason for the last change. This can be used to trigger events that deal
++ * with state changes.
++ */
++ am_CustomAvailabilityReason_t availabilityReason;
++
++ am_Availability_s() = default;
++ am_Availability_s(const am_Availability_e& availability, const am_CustomAvailabilityReason_t& availabilityReason);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeUInt16Type();
++ }
++ };
++ /**
++ * this type holds all information of sinks relevant to the HMI
++ */
++ /**
++ * this type holds all information of sinks relevant to the HMI
++ */
++ struct am_SinkType_s: CommonAPI::SerializableStruct {
++ /**
++ * This is the ID of the sink, it is unique in the system. There are 2 ways, ID
++ * can be created: either it is assigned during the registration process (in a
++ * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
++ * is a fixed (the project has to ensure the uniqueness of the ID).
++ */
++ am_sinkID_t sinkID;
++ /**
++ * The name of the sink. Must be unique in the whole system.
++ */
++ std::string name;
++ /**
++ * This attribute reflects the availability of the sink. There are several reasons
++ * why a sink could be not available for the moment: for example the shutdown of
++ * a sink because of overtemperature or over- &amp; undervoltage. The
++ * availability consists of two pieces of information:
++
++ Availablility: the
++ * status itself, can be A_AVAILABLE, A_UNAVAILABLE or A_UNKNOWN
++
++ * AvailabilityReason: this informs about the last reason for a change in
++ * availability. The reasons itself are product specific.
++ */
++ am_Availability_s availability;
++ /**
++ * This is the representation of the Volume for the commandInterface. It is used
++ * by the HMI to set the volume of a sink, the AudioManagerController has to
++ * transform this into real source and sink volumes.
++ */
++ am_mainVolume_t volume;
++ am_MuteState_e muteState;
++ /**
++ * The sinkClassID references to a sinkClass. With the help of classification,
++ * rules can be setup to define the system behaviour.
++ */
++ am_sinkClass_t sinkClassID;
++
++ am_SinkType_s() = default;
++ am_SinkType_s(const am_sinkID_t& sinkID, const std::string& name, const am_Availability_s& availability, const am_mainVolume_t& volume, const am_MuteState_e& muteState, const am_sinkClass_t& sinkClassID);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.writeInt16Type();
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeUInt16Type();
++ }
++ };
++ typedef std::vector<am_SinkType_s> am_SinkType_L;
++ typedef uint16_t am_sourceClass_t;
++ /**
++ * struct describing source classes
++ */
++ /**
++ * struct describing source classes
++ */
++ struct am_SourceClass_s: CommonAPI::SerializableStruct {
++ /**
++ * the source ID
++ */
++ am_sourceClass_t sourceClassID;
++ /**
++ * the name of the sourceClass - must be unique in the system
++ */
++ std::string name;
++ /**
++ * the list of the class properties. These are pairs of a project specific enum
++ * describing the type of the value and an integer holding the real value.
++ */
++ am_ClassProperty_L listClassProperties;
++
++ am_SourceClass_s() = default;
++ am_SourceClass_s(const am_sourceClass_t& sourceClassID, const std::string& name, const am_ClassProperty_L& listClassProperties);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ typedef std::vector<am_SourceClass_s> am_SourceClass_L;
++ /**
++ * this type holds all information of sources relevant to the HMI
++ */
++ /**
++ * this type holds all information of sources relevant to the HMI
++ */
++ struct am_SourceType_s: CommonAPI::SerializableStruct {
++ /**
++ * This is the ID of the source, it is unique in the system. There are 2 ways, ID
++ * can be created: either it is assigned during the registration process (in a
++ * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
++ * is a fixed (the project has to ensure the uniqueness of the ID).
++ */
++ am_sourceID_t sourceID;
++ /**
++ * The name of the source. Must be unique in the whole system.
++ */
++ std::string name;
++ /**
++ * the availability of the source
++ */
++ am_Availability_s availability;
++ /**
++ * the sourceClassID, indicates the class the source is in. This information can
++ * be used by the Controller to implement different behaviour for different
++ * classes.
++ */
++ am_sourceClass_t sourceClassID;
++
++ am_SourceType_s() = default;
++ am_SourceType_s(const am_sourceID_t& sourceID, const std::string& name, const am_Availability_s& availability, const am_sourceClass_t& sourceClassID);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.writeUInt16Type();
++ }
++ };
++ typedef std::vector<am_SourceType_s> am_SourceType_L;
++ /**
++ * describes the different system properties. Project specific
++ */
++ /**
++ * describes the different system properties. Project specific
++ */
++ typedef uint16_t am_CustomSystemPropertyType_t;
++ /**
++ * struct describing system properties
++ */
++ /**
++ * struct describing system properties
++ */
++ struct am_SystemProperty_s: CommonAPI::SerializableStruct {
++ /**
++ * the type that is set
++ */
++ am_CustomSystemPropertyType_t type;
++ /**
++ * the value
++ */
++ int16_t value;
++
++ am_SystemProperty_s() = default;
++ am_SystemProperty_s(const am_CustomSystemPropertyType_t& type, const int16_t& value);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ }
++ };
++ typedef std::vector<am_SystemProperty_s> am_SystemProperty_L;
++ /**
++ * a connection ID
++ */
++ /**
++ * a connection ID
++ */
++ typedef uint16_t am_connectionID_t;
++ typedef std::vector<am_connectionID_t> am_ConnectionID_L;
++ /**
++ * The unit is 0.1 db steps,The smallest value -3000 (=AM_MUTE). The minimum and
++ * maximum can be limited by actual project.
++ */
++ /**
++ * The unit is 0.1 db steps,The smallest value -3000 (=AM_MUTE). The minimum and
++ * maximum can be limited by actual project.
++ */
++ typedef int16_t am_volume_t;
++ /**
++ * Project specific sound properties.
++ */
++ /**
++ * Project specific sound properties.
++ */
++ typedef uint16_t am_CustomSoundPropertyType_t;
++ /**
++ * This enum characterizes the data of the EarlyData_t
++ */
++ enum class am_EarlyDataType_e: int32_t {
++ /**
++ * default
++ */
++ ES_UNKNOWN = 0,
++ /**
++ * the source volume
++ */
++ ED_SOURCE_VOLUME = 1,
++ /**
++ * the sink volume
++ */
++ ED_SINK_VOLUME = 2,
++ /**
++ * a source property
++ */
++ ED_SOURCE_PROPERTY = 3,
++ /**
++ * a sink property
++ */
++ ED_SINK_PROPERTY = 4,
++ ED_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_EarlyDataType_eComparator;
++ /**
++ * struct describing the sound property
++ */
++ /**
++ * struct describing the sound property
++ */
++ struct am_SoundProperty_s: CommonAPI::SerializableStruct {
++ /**
++ * the type of the property - a project specific enum
++ */
++ am_CustomSoundPropertyType_t type;
++ /**
++ * the actual value of the property
++ */
++ int16_t value;
++
++ am_SoundProperty_s() = default;
++ am_SoundProperty_s(const am_CustomSoundPropertyType_t& type, const int16_t& value);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ }
++ };
++ /**
++ * data type depends of am_EarlyDataType_e:
++ volume_t in case of ED_SOURCE_VOLUME,
++ * ED_SINK_VOLUME
++ soundProperty_t in case of ED_SOURCE_PROPERTY,
++ * ED_SINK_PROPERTY
++ */
++ /**
++ * data type depends of am_EarlyDataType_e:
++ volume_t in case of ED_SOURCE_VOLUME,
++ * ED_SINK_VOLUME
++ soundProperty_t in case of ED_SOURCE_PROPERTY,
++ * ED_SINK_PROPERTY
++ */
++ typedef CommonAPI::Variant<am_volume_t, am_SoundProperty_s> am_EarlyData_u;
++ /**
++ * data type depends of am_EarlyDataType_e:
++ sourceID in case of ED_SOURCE_VOLUME,
++ * ED_SOURCE_PROPERTY
++ sinkID in case of ED_SINK_VOLUME, ED_SINK_PROPERTY
++ */
++ /**
++ * data type depends of am_EarlyDataType_e:
++ sourceID in case of ED_SOURCE_VOLUME,
++ * ED_SOURCE_PROPERTY
++ sinkID in case of ED_SINK_VOLUME, ED_SINK_PROPERTY
++ */
++ typedef CommonAPI::Variant<am_sinkID_t, am_sourceID_t> am_DataType_u;
++ struct am_EarlyData_s: CommonAPI::SerializableStruct {
++ am_EarlyDataType_e type;
++ am_DataType_u sinksource;
++ am_EarlyData_u data;
++
++ am_EarlyData_s() = default;
++ am_EarlyData_s(const am_EarlyDataType_e& type, const am_DataType_u& sinksource, const am_EarlyData_u& data);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeVariantType();
++ typeOutputStream.writeVariantType();
++ }
++ };
++ typedef std::vector<am_EarlyData_s> am_EarlyData_L;
++ /**
++ * Here are all SoundProperties that can be set via the CommandInterface. Product
++ * specific
++ */
++ /**
++ * Here are all SoundProperties that can be set via the CommandInterface. Product
++ * specific
++ */
++ typedef uint16_t am_CustomMainSoundPropertyType_t;
++ /**
++ * struct describung mainsound property
++ */
++ /**
++ * struct describung mainsound property
++ */
++ struct am_MainSoundProperty_s: CommonAPI::SerializableStruct {
++ /**
++ * the type of the property
++ */
++ am_CustomMainSoundPropertyType_t type;
++ /**
++ * the actual value
++ */
++ int16_t value;
++
++ am_MainSoundProperty_s() = default;
++ am_MainSoundProperty_s(const am_CustomMainSoundPropertyType_t& type, const int16_t& value);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ }
++ };
++ typedef std::vector<am_MainSoundProperty_s> am_MainSoundProperty_L;
++ /**
++ * gives the type of the Notification.
++ */
++ /**
++ * gives the type of the Notification.
++ */
++ typedef uint16_t am_CustomNotificationType_t;
++ enum class am_NotificationStatus_e: int32_t {
++ NS_UNKNOWN = 0,
++ /**
++ * No notification, the function is turned off
++ */
++ NS_OFF = 1,
++ /**
++ * Periodic notifications are sent out. The period in ms is given by
++ * am_NotificationParameter
++ */
++ NS_PERIODIC = 2,
++ /**
++ * The notification is sent out when the minimum given by am_NotificationParameter
++ * is reached.
++ */
++ NS_MINIMUM = 3,
++ /**
++ * The notification is sent out when the maximum given by am_NotificationParameter
++ * is reached.
++ */
++ NS_MAXIMUM = 4,
++ /**
++ * The notification is sent out when a change happened. The Resolution of the
++ * change is defined by am_NotificationParameter.
++ */
++ NS_CHANGE_ = 5,
++ NS_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_NotificationStatus_eComparator;
++ /**
++ * This struct holds information about the configuration for notifications
++ */
++ /**
++ * This struct holds information about the configuration for notifications
++ */
++ struct am_NotificationConfiguration_s: CommonAPI::SerializableStruct {
++ /**
++ * The notification type of the notification
++ */
++ am_CustomNotificationType_t type;
++ /**
++ * The Notification status. This can be periodic, min/max value based or even off
++ * for example
++ */
++ am_NotificationStatus_e status;
++ /**
++ * This gives additional information to the notification status.
++ Relation between
++ * notification status and the value:
++ NS_PERIODIC - the period in ms
++ NS_MINIMUM
++ * - the minimum value that triggers the notification
++ NS_MAXIMUM - the maximum
++ * value that triggers the notifcation
++ NS_CHANGE - the resolution of the change
++ * value
++ */
++ int16_t parameter;
++
++ am_NotificationConfiguration_s() = default;
++ am_NotificationConfiguration_s(const am_CustomNotificationType_t& type, const am_NotificationStatus_e& status, const int16_t& parameter);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeInt16Type();
++ }
++ };
++ typedef std::vector<am_NotificationConfiguration_s> am_NotificationConfiguration_L;
++ /**
++ * a domain ID
++ */
++ /**
++ * a domain ID
++ */
++ typedef uint16_t am_domainID_t;
++ /**
++ * This project specific value classifies the format in which data is exchanged
++ * within a connection.
++ */
++ /**
++ * This project specific value classifies the format in which data is exchanged
++ * within a connection.
++ */
++ typedef uint16_t am_CustomConnectionFormat_t;
++ /**
++ * This represents one "hopp" in a route
++ */
++ /**
++ * This represents one "hopp" in a route
++ */
++ struct am_RoutingElement_s: CommonAPI::SerializableStruct {
++ /**
++ * the source ID
++ */
++ am_sourceID_t sourceID;
++ /**
++ * the sinkID
++ */
++ am_sinkID_t sinkID;
++ /**
++ * the domainID the routeElement is in
++ */
++ am_domainID_t domainID;
++ /**
++ * the connectionformat that is used for the route
++ */
++ am_CustomConnectionFormat_t connectionFormat;
++
++ am_RoutingElement_s() = default;
++ am_RoutingElement_s(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, const am_domainID_t& domainID, const am_CustomConnectionFormat_t& connectionFormat);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ }
++ };
++ typedef std::vector<am_RoutingElement_s> am_RoutingElement_L;
++ typedef std::vector<am_SoundProperty_s> am_SoundProperty_L;
++ /**
++ * time in ms!
++ */
++ /**
++ * time in ms!
++ */
++ typedef int16_t am_time_t;
++ /**
++ * For products, different ramp types can be defined here.
++ It is in the
++ * responsibility of the product to make sure that the routing plugins are aware
++ * of the ramp types used.
++ */
++ /**
++ * For products, different ramp types can be defined here.
++ It is in the
++ * responsibility of the product to make sure that the routing plugins are aware
++ * of the ramp types used.
++ */
++ typedef uint16_t am_CustomRampType_t;
++ /**
++ * This datatype determines if a sourceID or a sinkID is used in the union
++ * following
++ */
++ enum class am_VolumeType_e: int32_t {
++ VT_UNKNOWN = 0,
++ /**
++ * the following type is a sink
++ */
++ VT_SINK = 1,
++ /**
++ * the following type is a source
++ */
++ VT_SOURCE = 2,
++ VT_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_VolumeType_eComparator;
++ /**
++ * This types describe a mixed description for source and sinks volumes.
++ */
++ /**
++ * This types describe a mixed description for source and sinks volumes.
++ */
++ struct am_Volumes_s: CommonAPI::SerializableStruct {
++ /**
++ * describes the type of the volume: source or sink.
++ */
++ am_VolumeType_e volumeType;
++ /**
++ * either sourceID or sinkID
++ */
++ am_DataType_u volumeID;
++ /**
++ * The volume
++ */
++ am_volume_t volume;
++ /**
++ * the ramp that shall be driven
++ */
++ am_CustomRampType_t ramp;
++ /**
++ * the time for the ramp
++ */
++ am_time_t time;
++
++ am_Volumes_s() = default;
++ am_Volumes_s(const am_VolumeType_e& volumeType, const am_DataType_u& volumeID, const am_volume_t& volume, const am_CustomRampType_t& ramp, const am_time_t& time);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeVariantType();
++ typeOutputStream.writeInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ }
++ };
++ typedef std::vector<am_Volumes_s> am_Volumes_L;
++ typedef std::vector<am_CustomConnectionFormat_t> am_ConnectionFormat_L;
++ typedef bool am_bool_t;
++ typedef std::vector<am_bool_t> am_Convertion_L;
++ /**
++ * a gateway ID
++ */
++ /**
++ * a gateway ID
++ */
++ typedef uint16_t am_gatewayID_t;
++ /**
++ * a converter ID
++ */
++ /**
++ * a converter ID
++ */
++ typedef uint16_t am_converterID_t;
++ /**
++ * a crossfader ID
++ */
++ /**
++ * a crossfader ID
++ */
++ typedef uint16_t am_crossfaderID_t;
++ /**
++ * speed
++ */
++ /**
++ * speed
++ */
++ typedef uint16_t am_speed_t;
++ /**
++ * describes the active sink of a crossfader.
++ */
++ enum class am_HotSink_e: int32_t {
++ /**
++ * default
++ */
++ HS_UNKNOWN = 0,
++ /**
++ * sinkA is active
++ */
++ HS_SINKA = 1,
++ /**
++ * sinkB is active
++ */
++ HS_SINKB = 2,
++ /**
++ * the crossfader is in the transition state
++ */
++ HS_INTERMEDIATE = 3,
++ HS_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_HotSink_eComparator;
++ enum class am_DomainState_e: int32_t {
++ /**
++ * default
++ */
++ DS_UNKNOWN = 0,
++ /**
++ * the domain is controlled by the daemon
++ */
++ DS_CONTROLLED = 1,
++ /**
++ * the domain is independent starting up
++ */
++ DS_INDEPENDENT_STARTUP = 1,
++ /**
++ * the domain is independent running down
++ */
++ DS_INDEPENDENT_RUNDOWN = 2,
++ DS_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_DomainState_eComparator;
++ /**
++ * the errors of the audiomanager. All possible errors are in here. This enum is
++ * used widely as return parameter.
++ */
++ enum class am_Error_e: int32_t {
++ /**
++ * no error - positive reply
++ */
++ E_OK = 0,
++ /**
++ * default
++ */
++ E_UNKNOWN = 1,
++ /**
++ * value out of range
++ */
++ E_OUT_OF_RANGE = 2,
++ /**
++ * not used
++ */
++ E_NOT_USED = 3,
++ /**
++ * a database error occurred
++ */
++ E_DATABASE_ERROR = 4,
++ /**
++ * the desired object already exists
++ */
++ E_ALREADY_EXISTS = 5,
++ /**
++ * there is no change
++ */
++ E_NO_CHANGE = 6,
++ /**
++ * the desired action is not possible
++ */
++ E_NOT_POSSIBLE = 7,
++ /**
++ * the desired object is non existent
++ */
++ E_NON_EXISTENT = 8,
++ /**
++ * the asynchronous action was aborted
++ */
++ E_ABORTED = 9,
++ /**
++ * This error is returned in case a connect is issued with a connectionFormat that
++ * cannot be selected for the connection. This could be either due to the
++ * capabilities of a source or a sink or gateway compatibilities for example
++ */
++ E_WRONG_FORMAT = 10,
++ E_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_Error_eComparator;
++ enum class am_InterruptState_e: int32_t {
++ /**
++ * default
++ */
++ IS_UNKNOWN = 0,
++ /**
++ * the interrupt state is off - no interrupt
++ */
++ IS_OFF = 1,
++ /**
++ * the interrupt state is interrupted - the interrupt is active
++ */
++ IS_INTERRUPTED = 2,
++ IS_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_InterruptState_eComparator;
++ /**
++ * This enumeration is used to define the type of the action that is correlated to
++ * a handle.
++ */
++ enum class am_Handle_e: int32_t {
++ H_UNKNOWN = 0,
++ H_CONNECT = 1,
++ H_DISCONNECT = 2,
++ H_SETSOURCESTATE = 3,
++ H_SETSINKVOLUME = 4,
++ H_SETSOURCEVOLUME = 5,
++ H_SETSINKSOUNDPROPERTY = 6,
++ H_SETSOURCESOUNDPROPERTY = 7,
++ H_SETSINKSOUNDPROPERTIES = 8,
++ H_SETSOURCESOUNDPROPERTIES = 9,
++ H_CROSSFADE = 10,
++ H_SETVOLUMES = 11,
++ H_SETSINKNOTIFICATION = 12,
++ H_SETSOURCENOTIFICATION = 13,
++ H_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_Handle_eComparator;
++ /**
++ * The source state reflects the state of the source
++ */
++ enum class am_SourceState_e: int32_t {
++ SS_UNKNNOWN = 0,
++ /**
++ * The source can be activly heared
++ */
++ SS_ON = 1,
++ /**
++ * The source cannot be heared
++ */
++ SS_OFF = 2,
++ /**
++ * The source is paused. Meaning it cannot be heared but should be prepared to
++ * play again soon.
++ */
++ SS_PAUSED = 3,
++ SS_MAX
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_SourceState_eComparator;
++ /**
++ * This enum describes the ready state of the routing part
++ */
++ enum class am_RoutingReady_e: int32_t {
++ RR_UNKNOWN = 0,
++ RR_READY = 1,
++ RR_RUNDOWN = 2
++ };
++
++ // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
++ struct am_RoutingReady_eComparator;
++ /**
++ * a list of routing elements that lead from source to sink
++ */
++ /**
++ * a list of routing elements that lead from source to sink
++ */
++ struct am_Route_s: CommonAPI::SerializableStruct {
++ /**
++ * the sourceID where the route starts
++ */
++ am_sourceID_t sourceID;
++ /**
++ * the sinkID where the route ends
++ */
++ am_sinkID_t sinkID;
++ /**
++ * the actual route as list of routing elements
++ */
++ am_RoutingElement_L route;
++
++ am_Route_s() = default;
++ am_Route_s(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, const am_RoutingElement_L& route);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeUInt16Type();typeOutputStream.writeUInt16Type();typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ /**
++ * This struct describes the attribiutes of a crossfader.
++ */
++ /**
++ * This struct describes the attribiutes of a crossfader.
++ */
++ struct am_Crossfader_s: CommonAPI::SerializableStruct {
++ /**
++ * This is the ID of the crossfader, it is unique in the system. There are 2 ways,
++ * ID can be created: either it is assigned during the registration process (in a
++ * dynamic context, uniqueness will be ensured by the AudioManager daemon), or it
++ * is a fixed (the project has to ensure the uniqueness of the ID).
++ */
++ am_crossfaderID_t crossfaderID;
++ /**
++ * The name of the crossfader. Must be unique in the whole system.
++ */
++ std::string name;
++ /**
++ * The sinkID of the SinkA. Sinks shall be registered before registering the
++ * crossfader.
++ */
++ am_sinkID_t sinkID_A;
++ /**
++ * The sinkID of the SinkB. Sinks shall be registered before registering the
++ * crossfader.
++ */
++ am_sinkID_t sinkID_B;
++ /**
++ * The sourceID of the crossfader source. The source shall be registered before
++ * the crossfader.
++ */
++ am_sourceID_t sourceID;
++ /**
++ * This enum can have 3 states:
++
++ HS_SINKA sinkA is the current hot one, sinkB
++ * is not audible
++ HS_SINKB sinkB is the current hot one, sinkB is not
++ * audible
++ HS_INTERMEDIATE the fader is stuck in between a cross-fading
++ * action. This could be due to an abort or an error. Before using the
++ * crossfader, it must be set to either HS_SINKA or HS_SINKB.
++ */
++ am_HotSink_e hotSink;
++
++ am_Crossfader_s() = default;
++ am_Crossfader_s(const am_crossfaderID_t& crossfaderID, const std::string& name, const am_sinkID_t& sinkID_A, const am_sinkID_t& sinkID_B, const am_sourceID_t& sourceID, const am_HotSink_e& hotSink);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt32Type();
++ }
++ };
++ /**
++ * This struct describes the attributes of a gateway.
++ */
++ /**
++ * This struct describes the attributes of a gateway.
++ */
++ struct am_Gateway_s: CommonAPI::SerializableStruct {
++ /**
++ * This is the ID of the gateway, it is unique in the system. There are 2 ways, ID
++ * can be created: either it is assigned during the registration process (in a
++ * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
++ * is a fixed (the project has to ensure the uniqueness of the ID).
++ */
++ am_gatewayID_t gatewayID;
++ /**
++ * The name of the gateway. Must be unique in the whole system.
++ */
++ std::string name;
++ /**
++ * The sinkID of the gateway sink-end. The sink is a full blown sink with
++ * connectionFormats, sinkClassIDs etc... It makes sense to register the sinks of
++ * a gateway as non-visible. Care needs to be taken that the connectionsFormats
++ * match with the ones in the conversionMatrix. If the sink is located in the
++ * controllingDomain, the ID needs to be retrieved by registering the sink before
++ * registering the gateway. In case the sink is in a different domain, the ID
++ * needs to be retrieved via peeking.
++ */
++ am_sinkID_t sinkID;
++ /**
++ * The sourceID of the gateway sink-end. The sink is a full blown source with
++ * connectionFormats, sinkClassIDs etc... It makes sense to register the sources
++ * of a gateway as non-visible. Care needs to be taken that the
++ * connectionsFormats match with the ones in the conversionMatrix. If the source
++ * is located in the controllingDomain, the ID needs to be retrieved by
++ * registering the source before registering the gateway. In case the source is
++ * in a different domain, the ID needs to be retrieved via peeking.
++ */
++ am_sourceID_t sourceID;
++ /**
++ * The ID of the sink. If the domain is the same like the controlling domain, the
++ * ID is known due to registration. If the domain is different, the ID needs to
++ * be retrieved via peeking.
++ */
++ am_domainID_t domainSinkID;
++ /**
++ * The ID of the source. If the domain is the same like the controlling domain,
++ * the ID is known due to registration. If the domain is different, the ID needs
++ * to be retrieved via peeking.
++ */
++ am_domainID_t domainSourceID;
++ /**
++ * This is the ID of the domain that registers the gateway.
++ */
++ am_domainID_t controlDomainID;
++ /**
++ * This is the list of available formats on the source side of the gateway. It is
++ * not defined during the gateway registration but copied from the source
++ * registration.
++ */
++ am_ConnectionFormat_L listSourceFormats;
++ /**
++ * This is the list of available formats on the sink side of the gateway. It is
++ * not defined during the gateway registration but copied from the sink
++ * registration.
++ */
++ am_ConnectionFormat_L listSinkFormats;
++ /**
++ * This is matrix holding information about the conversion capability of the
++ * gateway, it's length is defined by the length(listSinkFormats) x
++ * length(listSourceFormats).
++ If a SinkFormat can be converted into a
++ * SourceFormat, the vector will hold a 1, if no conversion is possible, a
++ * 0.
++ The data is stored row orientated, where the rows are related to the
++ * sinksFormats and the columns to the sourceFormats. The first value will hold
++ * the conversion information from the first sourceFormat to the first sinkFormat
++ * for example and the seventh value the information about the 3rd sinkFormat to
++ * the 1st sourceFormat in case we would have 3 sourceFormats.
++ */
++ am_Convertion_L convertionMatrix;
++
++ am_Gateway_s() = default;
++ am_Gateway_s(const am_gatewayID_t& gatewayID, const std::string& name, const am_sinkID_t& sinkID, const am_sourceID_t& sourceID, const am_domainID_t& domainSinkID, const am_domainID_t& domainSourceID, const am_domainID_t& controlDomainID, const am_ConnectionFormat_L& listSourceFormats, const am_ConnectionFormat_L& listSinkFormats, const am_Convertion_L& convertionMatrix);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeBoolType();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ /**
++ * This struct describes the attributes of a gateway.
++ */
++ /**
++ * This struct describes the attributes of a gateway.
++ */
++ struct am_Converter_s: CommonAPI::SerializableStruct {
++ /**
++ * This is the ID of the gateway, it is unique in the system. There are 2 ways, ID
++ * can be created: either it is assigned during the registration process (in a
++ * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
++ * is a fixed (the project has to ensure the uniqueness of the ID).
++ */
++ am_converterID_t converterID;
++ /**
++ * The name of the gateway. Must be unique in the whole system.
++ */
++ std::string name;
++ /**
++ * The sinkID of the gateway sink-end. The sink is a full blown sink with
++ * connectionFormats, sinkClassIDs etc... It makes sense to register the sinks of
++ * a gateway as non-visible. Care needs to be taken that the connectionsFormats
++ * match with the ones in the conversionMatrix. If the sink is located in the
++ * controllingDomain, the ID needs to be retrieved by registering the sink before
++ * registering the gateway. In case the sink is in a different domain, the ID
++ * needs to be retrieved via peeking.
++ */
++ am_sinkID_t sinkID;
++ /**
++ * The sourceID of the gateway sink-end. The sink is a full blown source with
++ * connectionFormats, sinkClassIDs etc... It makes sense to register the sources
++ * of a gateway as non-visible. Care needs to be taken that the
++ * connectionsFormats match with the ones in the conversionMatrix. If the source
++ * is located in the controllingDomain, the ID needs to be retrieved by
++ * registering the source before registering the gateway. In case the source is
++ * in a different domain, the ID needs to be retrieved via peeking.
++ */
++ am_sourceID_t sourceID;
++ /**
++ * The ID of the sink. If the domain is the same like the controlling domain, the
++ * ID is known due to registration. If the domain is different, the ID needs to
++ * be retrieved via peeking.
++ */
++ am_domainID_t domainID;
++ /**
++ * This is the list of available formats on the source side of the gateway. It is
++ * not defined during the gateway registration but copied from the source
++ * registration.
++ */
++ am_ConnectionFormat_L listSourceFormats;
++ /**
++ * This is the list of available formats on the sink side of the gateway. It is
++ * not defined during the gateway registration but copied from the sink
++ * registration.
++ */
++ am_ConnectionFormat_L listSinkFormats;
++ /**
++ * This is matrix holding information about the conversion capability of the
++ * gateway, it's length is defined by the length(listSinkFormats) x
++ * length(listSourceFormats).
++ If a SinkFormat can be converted into a
++ * SourceFormat, the vector will hold a 1, if no conversion is possible, a
++ * 0.
++ The data is stored row orientated, where the rows are related to the
++ * sinksFormats and the columns to the sourceFormats. The first value will hold
++ * the conversion information from the first sourceFormat to the first sinkFormat
++ * for example and the seventh value the information about the 3rd sinkFormat to
++ * the 1st sourceFormat in case we would have 3 sourceFormats.
++ */
++ am_Convertion_L convertionMatrix;
++
++ am_Converter_s() = default;
++ am_Converter_s(const am_converterID_t& converterID, const std::string& name, const am_sinkID_t& sinkID, const am_sourceID_t& sourceID, const am_domainID_t& domainID, const am_ConnectionFormat_L& listSourceFormats, const am_ConnectionFormat_L& listSinkFormats, const am_Convertion_L& convertionMatrix);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeBoolType();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ /**
++ * a handle is used for asynchronous operations and is uniquely assigned for each
++ * of this operations
++ */
++ /**
++ * a handle is used for asynchronous operations and is uniquely assigned for each
++ * of this operations
++ */
++ struct am_Handle_s: CommonAPI::SerializableStruct {
++ /**
++ * the handletype
++ */
++ am_Handle_e handleType;
++ /**
++ * the handle as value
++ */
++ uint16_t handle;
++
++ am_Handle_s() = default;
++ am_Handle_s(const am_Handle_e& handleType, const uint16_t& handle);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeUInt16Type();
++ }
++ };
++ /**
++ * struct that holds attribiutes of a mainconnection
++ */
++ /**
++ * struct that holds attribiutes of a mainconnection
++ */
++ struct am_MainConnection_s: CommonAPI::SerializableStruct {
++ /**
++ * the assigned ID
++ */
++ am_mainConnectionID_t mainConnectionID;
++ /**
++ * the current connection state
++ */
++ am_ConnectionState_e connectionState;
++ /**
++ * the sinkID
++ */
++ am_sinkID_t sinkID;
++ /**
++ * the sourceID
++ */
++ am_sourceID_t sourceID;
++ /**
++ * the delay of the connection
++ */
++ am_timeSync_t delay;
++ /**
++ * the list of sub connection IDs the mainconnection consists of
++ */
++ am_ConnectionID_L listConnectionID;
++
++ am_MainConnection_s() = default;
++ am_MainConnection_s(const am_mainConnectionID_t& mainConnectionID, const am_ConnectionState_e& connectionState, const am_sinkID_t& sinkID, const am_sourceID_t& sourceID, const am_timeSync_t& delay, const am_ConnectionID_L& listConnectionID);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ /**
++ * This struct holds the payload of a notification.
++ */
++ /**
++ * This struct holds the payload of a notification.
++ */
++ struct am_NotificationPayload_s: CommonAPI::SerializableStruct {
++ /**
++ * This defines the notification type
++ */
++ am_CustomNotificationType_t type;
++ /**
++ * This is finally the value of the notification. It's meaning depends on the
++ * notificationType
++ */
++ int16_t value;
++
++ am_NotificationPayload_s() = default;
++ am_NotificationPayload_s(const am_CustomNotificationType_t& type, const int16_t& value);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ }
++ };
++ /**
++ * This struct describes the attribiutes of a sink
++ */
++ /**
++ * This struct describes the attribiutes of a sink
++ */
++ struct am_Sink_s: CommonAPI::SerializableStruct {
++ /**
++ * This is the ID of the sink, it is unique in the system. There are 2 ways, ID
++ * can be created: either it is assigned during the registration process (in a
++ * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
++ * is a fixed (the project has to ensure the uniqueness of the ID).
++ */
++ am_sinkID_t sinkID;
++ /**
++ * The name of the sink. Must be unique in the whole system.
++ */
++ std::string name;
++ /**
++ * The domainID is the domain the sink belongs to. A sink can only be in one
++ * domain.
++ */
++ am_domainID_t domainID;
++ /**
++ * The sinkClassID references to a sinkClass. With the help of classification,
++ * rules can be setup to define the system behaviour.
++ */
++ am_sinkClass_t sinkClassID;
++ /**
++ * This is the volume of the sink. It is set by the AudioManagerController.
++ */
++ am_volume_t volume;
++ /**
++ * This Boolean flag indicates whether a sink is visible to the commandInterface
++ * or not. If the User must have the possibility to choose the source in the HMI,
++ * it must be visible. But there are also good reasons for invisible sinks, for
++ * example if the sink is part of a crossfader or gateway. HMI relevant changes
++ * in visible sinks will be automatically reported by the daemon to the
++ * commandInterface.
++ */
++ bool visible;
++ /**
++ * This attribute reflects the availability of the sink. There are several reasons
++ * why a sink could be not available for the moment: for example the shutdown of
++ * a sink because of overtemperature or over- &amp; undervoltage. The
++ * availability consists of two pieces of information:
++
++ Availablility: the
++ * status itself, can be A_AVAILABLE, A_UNAVAILABLE or A_UNKNOWN
++
++ * AvailabilityReason: this informs about the last reason for a change in
++ * availability. The reasons itself are product specific.
++ */
++ am_Availability_s available;
++ /**
++ * This attribute reflects the muteState of the sink. The information is not the
++ * "real" state of the sink, but the HMI representation for he commandInterface
++ * controlled by the AudioManagerController.
++ */
++ am_MuteState_e muteState;
++ /**
++ * This is the representation of the Volume for the commandInterface. It is used
++ * by the HMI to set the volume of a sink, the AudioManagerController has to
++ * transform this into real source and sink volumes.
++ */
++ am_mainVolume_t mainVolume;
++ /**
++ * This is the list of soundProperties, that the sink is capable of. The
++ * soundProperties itself are project specific. For sinks, a possible
++ * soundProperty could be for example settings.
++ */
++ am_SoundProperty_L listSoundProperties;
++ /**
++ * This list holds information about the formats that the Source is capable of
++ * supporting when delivering audio.
++ */
++ am_ConnectionFormat_L listConnectionFormats;
++ /**
++ * This is the list of the available mainSoundProperties. The principle is the
++ * same than with soundProperties, but they are only visible to the
++ * CommandInterface.
++ */
++ am_MainSoundProperty_L listMainSoundProperties;
++ /**
++ * This is the list of the MainNotificationConfigurations. These notifications
++ * work on the level of command interface.
++ */
++ am_NotificationConfiguration_L listMainNotificationConfigurations;
++ /**
++ * This is the list of the NotificationConfigurations. These notifications work on
++ * the level of RoutingPlugins.
++ */
++ am_NotificationConfiguration_L listNotificationConfigurations;
++
++ am_Sink_s() = default;
++ am_Sink_s(const am_sinkID_t& sinkID, const std::string& name, const am_domainID_t& domainID, const am_sinkClass_t& sinkClassID, const am_volume_t& volume, const bool& visible, const am_Availability_s& available, const am_MuteState_e& muteState, const am_mainVolume_t& mainVolume, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, const am_NotificationConfiguration_L& listMainNotificationConfigurations, const am_NotificationConfiguration_L& listNotificationConfigurations);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt16Type();
++ typeOutputStream.writeBoolType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeInt16Type();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ /**
++ * This struct describes the attribiutes of a source
++ */
++ /**
++ * This struct describes the attribiutes of a source
++ */
++ struct am_Source_s: CommonAPI::SerializableStruct {
++ /**
++ * This is the ID of the source, it is unique in the system. There are 2 ways, ID
++ * can be created: either it is assigned during the registration process (in a
++ * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it
++ * is a fixed (the project has to ensure the uniqueness of the ID).
++ */
++ am_sourceID_t sourceID;
++ /**
++ * The domainID is the domain the source belongs to. A source can only be in one
++ * domain.
++ */
++ am_domainID_t domainID;
++ /**
++ * The name of the source. Must be unique in the whole system.
++ */
++ std::string name;
++ /**
++ * the sourceClassID, indicates the class the source is in. This information can
++ * be used by the Controller to implement different behaviour for different
++ * classes.
++ */
++ am_sourceClass_t sourceClassID;
++ /**
++ * The source state is an indication towards the source if it is actively heard or
++ * not. The source can use this information to implement features like automatic
++ * spin down of CD's in case the CD is not the active source or AF following of a
++ * tuner that is not actively heard. The source state is set by the
++ * AudioManagerController.There are 3 possible states:
++
++ SS_ON: the source is
++ * active
++ SS_OFF: the source is off
++ SS_PAUSED: the source is paused and
++ * not active.
++ */
++ am_SourceState_e sourceState;
++ /**
++ * This is the volume of the source. It is set by the AudioManagerController. It
++ * is used to adopt different audiolevels in a system and mixing of sources (e.g.
++ * navigation hints &amp; music).
++ */
++ am_volume_t volume;
++ /**
++ * This Boolean flag indicates whether a source is visible to the commandInterface
++ * or not. If the User must have the possibility to choose the source in the HMI,
++ * it must be visible. But there are also good reasons for invisible sources, for
++ * example if the source is part of a crossfader or gateway. HMI relevant changes
++ * in visible sources will be automatically reported by the daemon to the
++ * commandInterface.
++ */
++ bool visible;
++ /**
++ * This attribute reflects the availability of the source. There are several
++ * reasons why a source could be not available for the moment. For example a CD
++ * player which has no CD entered in the slot can be unavailable, or a USB player
++ * with no or unreadable stick attached. Other scenarios involve the shutdown of
++ * a source because of overtemperature or over- &amp; undervoltage. The
++ * availability consists of two informations:
++
++ Availablility: the status
++ * itself, can be A_AVAILABLE, A_UNAVAILABLE or A_UNKNOWN
++
++ * AvailabilityReason: this informs about the last reason for a change in
++ * availability. The reasons itself are product specific.
++ */
++ am_Availability_s available;
++ /**
++ * Some special sources can have special behaviors, the are so called "Low Level
++ * Interrupts". Here the current status is documented. The information can be
++ * used by the AudioManagerController to react to the changes by for example
++ * lowering the volume of the mainSources. The two states are
++
++ IS_OFF: the
++ * interrupt is not active at the moment
++ IS_INTERRUPTED: the interrupt is
++ * playing at the moment.
++ */
++ am_InterruptState_e interruptState;
++ /**
++ * This is the list of soundProperties, that the source is capable of. The
++ * soundProperties itself are project specific. For sources, a possible
++ * soundProperty could be navigation volume offset, for example.
++ */
++ am_SoundProperty_L listSoundProperties;
++ /**
++ * This list holds information about the formats that the Source is capable of
++ * supporting when delivering audio.
++ */
++ am_ConnectionFormat_L listConnectionFormats;
++ /**
++ * This is the list of the available mainSoundProperties. The principle is the
++ * same than with soundProperties, but they are only visible to the
++ * CommandInterface.
++ */
++ am_MainSoundProperty_L listMainSoundProperties;
++ /**
++ * The list of MainNotificationConfigurations. These notifications work on the
++ * level of CommandInterface.
++ */
++ am_NotificationConfiguration_L listMainNotificationConfigurations;
++ /**
++ * The list of MainNotificationConfigurations. These notifications work on the
++ * level of RoutingInterface.
++ */
++ am_NotificationConfiguration_L listNotificationConfigurations;
++
++ am_Source_s() = default;
++ am_Source_s(const am_sourceID_t& sourceID, const am_domainID_t& domainID, const std::string& name, const am_sourceClass_t& sourceClassID, const am_SourceState_e& sourceState, const am_volume_t& volume, const bool& visible, const am_Availability_s& available, const am_InterruptState_e& interruptState, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, const am_NotificationConfiguration_L& listMainNotificationConfigurations, const am_NotificationConfiguration_L& listNotificationConfigurations);
++
++
++ virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
++ virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
++
++ static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeStringType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.writeInt16Type();
++ typeOutputStream.writeBoolType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.writeInt32Type();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.writeUInt16Type();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ typeOutputStream.beginWriteVectorType();
++ typeOutputStream.beginWriteStructType();
++ typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type();
++ typeOutputStream.endWriteStructType();
++ typeOutputStream.endWriteVectorType();
++ }
++ };
++ /**
++ * This struct describes the attribiutes of a domain
++ */
++ /**
++ * This struct describes the attribiutes of a domain
++ */
++ struct am_Domain_s: CommonAPI::SerializableStruct {
++ /**
++ * the domain ID
++ */
++ am_domainID_t domainID;
++ /**<