* some adoptins in the routinginterface

Signed-off-by: Christian Linke <christian.linke@bmw.de>

diff --git a/PluginRoutingInterfaceDbus/include/CAmDbusMessageHandler.h b/PluginRoutingInterfaceDbus/include/CAmDbusMessageHandler.h
index 62ad421..71b3078 100644 (file)
--- a/PluginRoutingInterfaceDbus/include/CAmDbusMessageHandler.h
+++ b/PluginRoutingInterfaceDbus/include/CAmDbusMessageHandler.h
@@ -79,6 +79,8 @@ public:
     dbus_uint16_t getUInt(DBusMessageIter& iter, bool next);
     dbus_int16_t getInt();
     dbus_int16_t getInt(DBusMessageIter& iter, bool next);
+    dbus_int32_t getInt32();
+    dbus_int32_t getInt32(DBusMessageIter& iter, bool next);
     dbus_bool_t getBool();
     dbus_bool_t getBool(DBusMessageIter& iter, bool next);
     char getByte();
@@ -87,14 +89,22 @@ public:
     double getDouble(DBusMessageIter& iter, bool next);
     char* getString();
     char* getString(DBusMessageIter& iter, bool next);
-    am::am_Availability_s getAvailability();
+    am_Availability_s getAvailability();
     std::vector<am::am_EarlyData_s> getEarlyData();
     am_Domain_s getDomainData();
     am_Source_s getSourceData();
     am_Sink_s getSinkData();
     am_Gateway_s getGatewayData();
     am_Crossfader_s getCrossfaderData();
+    am_SoundProperty_s getSoundProperty();
     am_MainSoundProperty_s getMainSoundProperty();
+    std::vector<am_ConnectionFormat_e> getListconnectionFormats();
+    std::vector<bool> getListBool();
+    std::vector<am_SoundProperty_s> getListSoundProperties();
+    std::vector<am_MainSoundProperty_s> getListMainSoundProperties();
+    am_NotificationPayload_s getNotificationPayload();
+
+
 
     /**
      * the overloaded append function appends different datatypes to the dbusmessage

diff --git a/PluginRoutingInterfaceDbus/include/CAmDbusSend.h b/PluginRoutingInterfaceDbus/include/CAmDbusSend.h
index 3f8f0a5..b95c227 100644 (file)
--- a/PluginRoutingInterfaceDbus/include/CAmDbusSend.h
+++ b/PluginRoutingInterfaceDbus/include/CAmDbusSend.h
@@ -37,15 +37,18 @@ public:
     void append(std::string string);
     void append(uint16_t integer);
     void append(int16_t integer);
+    void append(int integer);
     void append(std::vector<am_SoundProperty_s> listSoundProperties);
     void append(am_SoundProperty_s soundProperty);
     am_Error_e send();
+    am_Error_e sendAsync();
 
 private:
     DBusMessage* mpDbusMessage;
     DBusConnection* mpDbusConnection;
     DBusMessageIter mDbusMessageIter;
     DBusError mDBusError;
+    dbus_uint32_t mSerial;
 };
 }
 

diff --git a/PluginRoutingInterfaceDbus/include/IAmRoutingReceiverShadow.h b/PluginRoutingInterfaceDbus/include/IAmRoutingReceiverShadow.h
index 642ab6f..bc0cb5e 100644 (file)
--- a/PluginRoutingInterfaceDbus/include/IAmRoutingReceiverShadow.h
+++ b/PluginRoutingInterfaceDbus/include/IAmRoutingReceiverShadow.h
@@ -74,6 +74,14 @@ public:
     void sendChangedData(DBusConnection *conn, DBusMessage *msg);
     void confirmRoutingReady(DBusConnection *conn, DBusMessage *msg);
     void confirmRoutingRundown(DBusConnection *conn, DBusMessage *msg);
+    void updateGateway(DBusConnection *conn, DBusMessage *msg);
+    void updateSink(DBusConnection *conn, DBusMessage *msg);
+    void updateSource(DBusConnection *conn, DBusMessage *msg);
+    void ackSetVolumes(DBusConnection *conn, DBusMessage *msg);
+    void ackSinkNotificationConfiguration(DBusConnection *conn, DBusMessage *msg);
+    void ackSourceNotificationConfiguration(DBusConnection *conn, DBusMessage *msg);
+    void hookSinkNotificationDataChange(DBusConnection *conn, DBusMessage *msg);
+    void hookSourceNotificationDataChange(DBusConnection *conn, DBusMessage *msg);
 
     /**
      * sets the pointer to the CommandReceiveInterface and registers Callback

diff --git a/PluginRoutingInterfaceDbus/include/RoutingReceiver.xml b/PluginRoutingInterfaceDbus/include/RoutingReceiver.xml
index 5fb390a..f8799c6 100644 (file)
--- a/PluginRoutingInterfaceDbus/include/RoutingReceiver.xml
+++ b/PluginRoutingInterfaceDbus/include/RoutingReceiver.xml
@@ -66,19 +66,21 @@
                <arg name="error" type="q" direction="out" />
        </method>
        <method name="registerDomain">
-               <arg name="domaindata" type="(qsssbbq)" direction="in" /> <!-- am_domainID_t domainID; std::string name; std::string busname; std::string nodename; bool early; bool complete; am_DomainState_e state; -->
+               <arg name="domaindata" type="(qsssbbn)" direction="in" /> <!-- am_domainID_t domainID; std::string name; std::string busname; std::string nodename; bool early; bool complete; am_DomainState_e state; -->
                <arg name="returnBusname" type="s" direction="in" /> <!-- the busname for all communication to this domain -->
                <arg name="returnPath" type="s" direction="in" /> <!-- the path for all communication to this domain -->
                <arg name="returnInterface" type="s" direction="in" />  <!-- the interface for all communication to this domain -->
                <arg name="domainid" type="q" direction="out" />
                <arg name="error" type="q" direction="out" />
        </method>
-       <method name="deregisterDomain">
+       <method name="deregisterDomain">                
+               <arg name="handle" type="q" direction="in" />
+               <arg name="error" type="q" direction="in" />
                <arg name="domainid" type="q" direction="in" />
                <arg name="error" type="q" direction="out" />
        </method>
        <method name="registerGateway">
-               <arg name="gatewayData" type="(qsqqqqqa(q)a(q)a(b))" direction="in" /> <!-- am_gatewayID_t gatewayID; std::string name; am_sinkID_t sinkID; am_sourceID_t sourceID; am_domainID_t domainSinkID; am_domainID_t domainSourceID; am_domainID_t controlDomainID; std::vector<am_ConnectionFormat_e> listSourceFormats; std::vector<am_ConnectionFormat_e> listSinkFormats; std::vector<bool> convertionMatrix; -->
+               <arg name="gatewayData" type="(qsqqqqqaiaiab)" direction="in" /> <!-- am_gatewayID_t gatewayID; std::string name; am_sinkID_t sinkID; am_sourceID_t sourceID; am_domainID_t domainSinkID; am_domainID_t domainSourceID; am_domainID_t controlDomainID; std::vector<am_ConnectionFormat_e> listSourceFormats; std::vector<am_ConnectionFormat_e> listSinkFormats; std::vector<bool> convertionMatrix; -->
                <arg name="gatewayID" type="q" direction="out" />
                <arg name="error" type="q" direction="out" />
        </method>
@@ -92,7 +94,7 @@
            <arg name="error" type="q" direction="out" />
        </method>
        <method name="registerSink">      
-               <arg name="sinkData" type="(qsqqnb(nn)nna(nn)ana(nn))" direction="in" /> <!-- am_sinkID_t sinkID; std::string name; am_domainID_t domainID; am_sinkClass_t sinkClassID; am_volume_t volume; bool visible; am_Availability_s available; am_MuteState_e muteState;am_mainVolume_t mainVolume; std::vector<am_SoundProperty_s> listSoundProperties; std::vector<am_ConnectionFormat_e> listConnectionFormats;  std::vector<am_MainSoundProperty_s> listMainSoundProperties; -->     
+               <arg name="sinkData" type="(qsqinb(ii)nna(in)aia(in)a(iin)a(iin))" direction="in" /> <!-- am_sinkID_t sinkID; std::string name; am_domainID_t domainID; am_sinkClass_t sinkClassID; am_volume_t volume; bool visible; am_Availability_s available; am_MuteState_e muteState;am_mainVolume_t mainVolume; std::vector<am_SoundProperty_s> listSoundProperties; std::vector<am_ConnectionFormat_e> listConnectionFormats;  std::vector<am_MainSoundProperty_s> listMainSoundProperties; -->     
                <arg name="sinkID" type="q" direction="out" /> 
                <arg name="error" type="q" direction="out" />
        </method>
@@ -106,7 +108,7 @@
                <arg name="error" type="i" direction="out" />           
        </method>
        <method name="registerSource">      
-               <arg name="sourceData" type="(qqsqqnb(nn)qa(nn)ana(nn))" direction="in" />  <!-- am_sourceID_t sourceID; am_domainID_t domainID; std::string name; am_sourceClass_t sourceClassID; am_SourceState_e sourceState; am_volume_t volume; bool visible; am_Availability_s available; am_InterruptState_e interruptState; std::vector<am_SoundProperty_s> listSoundProperties; std::vector<am_ConnectionFormat_e> listConnectionFormats; std::vector<am_MainSoundProperty_s> listMainSoundProperties; -->    
+               <arg name="sourceData" type="(qqsqinb(ii)qa(in)aia(in)a(iin)a(iin))" direction="in" />  <!-- am_sourceID_t sourceID; am_domainID_t domainID; std::string name; am_sourceClass_t sourceClassID; am_SourceState_e sourceState; am_volume_t volume; bool visible; am_Availability_s available; am_InterruptState_e interruptState; std::vector<am_SoundProperty_s> listSoundProperties; std::vector<am_ConnectionFormat_e> listConnectionFormats; std::vector<am_MainSoundProperty_s> listMainSoundProperties; -->    
                <arg name="sourceID" type="q" direction="out" /> 
                <arg name="error" type="i" direction="out" />
        </method>
@@ -166,6 +168,48 @@
        <method name="confirmRoutingRundown"> 
                <arg name="domainID" type="q" direction="in" />
        </method>
+       <method name="updateGateway"> 
+               <arg name="gatewayID" type="q" direction="in" />
+               <arg name="listSourceFormats" type="a(q)" direction="in" />
+               <arg name="listSinkFormats" type="a(q)" direction="in" />
+               <arg name="conversionMatrix" type="a(b)" direction="in" /> 
+       </method>
+       <method name="updateSink"> 
+               <arg name="sinkID" type="q" direction="in" />
+               <arg name="sinkClassID" type="q" direction="in" />
+               <arg name="listSoundProperties" type="a(nn)" direction="in" />
+               <arg name="listConnectionFormats" type="a(q)" direction="in" />                 
+               <arg name="listMainSoundProperties" type="a(nn)" direction="in" />
+       </method>       
+       <method name="updateSource"> 
+               <arg name="sourceID" type="q" direction="in" />
+               <arg name="sourceClassID" type="q" direction="in" />
+               <arg name="listSoundProperties" type="a(nn)" direction="in" />
+               <arg name="listConnectionFormats" type="a(q)" direction="in" />                 
+               <arg name="listMainSoundProperties" type="a(nn)" direction="in" />
+       </method>               
+       <method name="ackSetVolumes"> 
+               <arg name="handle" type="q" direction="in" />
+               <arg name="listvolumes" type="a(nqqnq)" direction="in" />
+               <arg name="error" type="q" direction="in" /> 
+       </method>               
+       <method name="ackSinkNotificationConfiguration"> 
+               <arg name="handle" type="q" direction="in" />
+               <arg name="error" type="q" direction="in" />
+       </method>               
+       <method name="ackSourceNotificationConfiguration"> 
+               <arg name="handle" type="q" direction="in" />
+               <arg name="error" type="q" direction="in" />
+       </method>               
+       <method name="hookSinkNotificationDataChange"> 
+               <arg name="sinkID" type="q" direction="in" />  
+               <arg name="payload" type="(nn)" direction="in" />
+       </method>               
+       <method name="hookSourceNotificationDataChange"> 
+               <arg name="sourceID" type="q" direction="in" />  
+               <arg name="payload" type="(nn)" direction="in" />
+       </method>                 
+
        <signal name="setRoutingReady">
        </signal>       
        <signal name="setRoutingRundown">

diff --git a/PluginRoutingInterfaceDbus/include/RoutingSender.xml b/PluginRoutingInterfaceDbus/include/RoutingSender.xml
index d6fb2ea..adfc5ad 100644 (file)
--- a/PluginRoutingInterfaceDbus/include/RoutingSender.xml
+++ b/PluginRoutingInterfaceDbus/include/RoutingSender.xml
@@ -14,72 +14,62 @@
                <arg name='connectionID' type='q' direction='in' />     
                <arg name='sourceID' type='q' direction='in' />                                 
                <arg name='sinkID' type='q' direction='in' /> 
-               <arg name='connectionFormat' type='n' direction='in' /> 
-               <arg name='error' type='n' direction='out' />                                                                           
+               <arg name='connectionFormat' type='i' direction='in' />                                                                         
        </method>                                                                                       
        <method name='asyncDisconnect'> 
                <arg name='handle' type='q' direction='in' />  
-               <arg name='connectionID' type='q' direction='in' />             
-               <arg name='error' type='n' direction='out' />                                                                                           
+               <arg name='connectionID' type='q' direction='in' />                                                                                                     
        </method>                                                                                       
        <method name='asyncSetSinkVolume'>                                                                      
                <arg name='handle' type='q' direction='in' />                                   
                <arg name='sinkID' type='q' direction='in' />           
                <arg name='volume' type='n' direction='in' />                                                                   
                <arg name='ramp' type='n' direction='in' />                                     
-               <arg name='time' type='q' direction='in' />     
-               <arg name='error' type='n' direction='out' />                                   
+               <arg name='time' type='q' direction='in' />                                     
        </method>                                                                                       
        <method name='asyncSetSourceVolume'>                                                            
                <arg name='handle' type='q' direction='in' />                                   
                <arg name='sourceID' type='q' direction='in' />         
                <arg name='volume' type='n' direction='in' />                                                                   
                <arg name='ramp' type='n' direction='in' />                                     
-               <arg name='time' type='q' direction='in' />     
-               <arg name='error' type='n' direction='out' />                                   
+               <arg name='time' type='q' direction='in' />                                     
        </method>               
        <method name='asyncSetSourceState'>     
                <arg name='handle' type='q' direction='in' />  
                <arg name='sourceID' type='q' direction='in' /> 
-               <arg name='sourceState' type='n' direction='in' />      
-               <arg name='error' type='n' direction='out' />                                                                                           
+               <arg name='sourceState' type='i' direction='in' />                                                                                                      
        </method>                                               
        <method name='asyncSetSinkSoundProperties'>                                                             
                <arg name='handle' type='q' direction='in' />                                   
                <arg name='sinkID' type='q' direction='in' />                           
-               <arg name='listSoundProperties' type='a(nn)' direction='in' />                          
-               <arg name='error' type='n' direction='out' />                           
+               <arg name='listSoundProperties' type='a(nn)' direction='in' />                                          
        </method>       
                <method name='asyncSetSinkSoundProperty'>                                                               
                <arg name='handle' type='q' direction='in' />                                   
                <arg name='sinkID' type='q' direction='in' />                           
-               <arg name='soundProperty' type='(nn)' direction='in' />                         
-               <arg name='error' type='n' direction='out' />                           
+               <arg name='soundProperty' type='(nn)' direction='in' />                                                 
        </method>       
        <method name='asyncSetSourceSoundProperty'>                                                             
                <arg name='handle' type='q' direction='in' />                                   
                <arg name='sourceID' type='q' direction='in' />                         
-               <arg name='soundProperty' type='(nn)' direction='in' />                         
-               <arg name='error' type='n' direction='out' />                           
+               <arg name='soundProperty' type='(nn)' direction='in' />                                         
        </method>       
        <method name='asyncSetSourceSoundProperties'>                                                           
                <arg name='handle' type='q' direction='in' />                                   
                <arg name='sourceID' type='q' direction='in' />                         
-               <arg name='listSoundProperties' type='a(nn)' direction='in' />                          
-               <arg name='error' type='n' direction='out' />                           
+               <arg name='listSoundProperties' type='a(nn)' direction='in' />                                                  
        </method>       
        <method name='asyncCrossFade'>                                                          
                <arg name='handle' type='q' direction='in' />                                   
                <arg name='crossfaderID' type='q' direction='in' />                             
                <arg name='hotSink' type='q' direction='in' />                  
                <arg name='rampType' type='q' direction='in' />         
-               <arg name='time' type='q' direction='in' />             
-               <arg name='error' type='n' direction='out' />                           
+               <arg name='time' type='q' direction='in' />                             
        </method>               
        <method name='setDomainState'>                                                          
                <arg name='domainID' type='q' direction='in' />                         
                <arg name='domainState' type='q' direction='in' />                      
-               <arg name='error' type='n' direction='out' />                           
+               <arg name='error' type='i' direction='out' />                           
        </method>                                                                                               
        </interface>                                                                                                                                                                                    
 </node>

diff --git a/PluginRoutingInterfaceDbus/include/configRoutingDbus.h b/PluginRoutingInterfaceDbus/include/configRoutingDbus.h
index 2420184..aa95328 100644 (file)
--- a/PluginRoutingInterfaceDbus/include/configRoutingDbus.h
+++ b/PluginRoutingInterfaceDbus/include/configRoutingDbus.h
@@ -1,6 +1,6 @@
 #ifndef _ROUTINGDBUS_CONFIG_H
 #define _ROUTINGDBUS_CONFIG_H
 
-#define ROUTING_DBUS_INTROSPECTION_FILE "/home/christian/workspace/AudioManager/bin/RoutingReceiver.xml"
+#define ROUTING_DBUS_INTROSPECTION_FILE "/home/genius/workspace/workspace/AudioManager/bin/RoutingReceiver.xml"
 
 #endif /* _ROUTINGDBUS_CONFIG_H */

diff --git a/PluginRoutingInterfaceDbus/src/CAmDbusMessageHandler.cpp b/PluginRoutingInterfaceDbus/src/CAmDbusMessageHandler.cpp
index 2591012..096dfbf 100644 (file)
--- a/PluginRoutingInterfaceDbus/src/CAmDbusMessageHandler.cpp
+++ b/PluginRoutingInterfaceDbus/src/CAmDbusMessageHandler.cpp
@@ -262,7 +262,7 @@ double CAmRoutingDbusMessageHandler::getDouble()
     return (getDouble(mDBusMessageIter, true));
 }
 
-am::am_Availability_s CAmRoutingDbusMessageHandler::getAvailability()
+am_Availability_s CAmRoutingDbusMessageHandler::getAvailability()
 {
     am::am_Availability_s availability;
     availability.availability=A_UNKNOWN;
@@ -352,7 +352,7 @@ am_Domain_s CAmRoutingDbusMessageHandler::getDomainData()
        domainData.nodename = getString(domainDataIter, true);
        domainData.early = getBool(domainDataIter, true);
        domainData.complete = getBool(domainDataIter, true);
-       domainData.state = static_cast<am_DomainState_e>(getUInt(domainDataIter, false));
+       domainData.state = static_cast<am_DomainState_e>(getInt32(domainDataIter, false));
         dbus_message_iter_next(&mDBusMessageIter);
     }
     return (domainData);
@@ -365,6 +365,8 @@ am_Source_s CAmRoutingDbusMessageHandler::getSourceData()
     am_SoundProperty_s soundProperty;
     am_ConnectionFormat_e connectionFormat;
     am_MainSoundProperty_s mainSoundProperty;
+    am_NotificationConfiguration_s notificationConfiguration;
+    am_NotificationConfiguration_s MainnotificationConfiguration;
 
     if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
     {
@@ -379,19 +381,19 @@ am_Source_s CAmRoutingDbusMessageHandler::getSourceData()
        sourceData.domainID = static_cast<am_domainID_t>(getUInt(sourceDataIter, true));
        sourceData.name = getString(sourceDataIter, true);
        sourceData.sourceClassID = static_cast<am_sourceClass_t>(getUInt(sourceDataIter, true));
-       sourceData.sourceState = static_cast<am_SourceState_e>(getUInt(sourceDataIter, true));
+       sourceData.sourceState = static_cast<am_SourceState_e>(getInt32(sourceDataIter, true));
        sourceData.volume = static_cast<am_volume_t>(getInt(sourceDataIter, true));
        sourceData.visible = getBool(sourceDataIter, true);
        dbus_message_iter_recurse(&sourceDataIter, &availIter);
-       sourceData.available.availability = static_cast<am_Availability_e>(getInt(availIter, true));
-       sourceData.available.availabilityReason = static_cast<am_AvailabilityReason_e>(getInt(availIter, false));
+       sourceData.available.availability = static_cast<am_Availability_e>(getInt32(availIter, true));
+       sourceData.available.availabilityReason = static_cast<am_AvailabilityReason_e>(getInt32(availIter, false));
        dbus_message_iter_next(&sourceDataIter);
-       sourceData.interruptState = static_cast<am_InterruptState_e>(getUInt(sourceDataIter, true));
+       sourceData.interruptState = static_cast<am_InterruptState_e>(getInt32(sourceDataIter, true));
        dbus_message_iter_recurse(&sourceDataIter, &arrayIter);
        do
        {
            dbus_message_iter_recurse(&arrayIter, &structIter);
-           soundProperty.type = static_cast<am_SoundPropertyType_e>(getInt(structIter, true));
+           soundProperty.type = static_cast<am_SoundPropertyType_e>(getInt32(structIter, true));
            soundProperty.value = static_cast<int16_t>(getInt(structIter, false));
            sourceData.listSoundProperties.push_back(soundProperty);
        } while (dbus_message_iter_next(&arrayIter));
@@ -399,7 +401,7 @@ am_Source_s CAmRoutingDbusMessageHandler::getSourceData()
        dbus_message_iter_recurse(&sourceDataIter, &arrayIter);
        do
        {
-           connectionFormat = static_cast<am_ConnectionFormat_e>(getInt(arrayIter, false));
+           connectionFormat = static_cast<am_ConnectionFormat_e>(getInt32(arrayIter, false));
            sourceData.listConnectionFormats.push_back(connectionFormat);
        } while (dbus_message_iter_next(&arrayIter));
        dbus_message_iter_next(&sourceDataIter);
@@ -408,10 +410,32 @@ am_Source_s CAmRoutingDbusMessageHandler::getSourceData()
        do
        {
            dbus_message_iter_recurse(&arrayIter, &structIter);
-           mainSoundProperty.type = static_cast<am_MainSoundPropertyType_e>(getInt(structIter, true));
+           mainSoundProperty.type = static_cast<am_MainSoundPropertyType_e>(getInt32(structIter, true));
            mainSoundProperty.value = static_cast<int16_t>(getInt(structIter, false));
            sourceData.listMainSoundProperties.push_back(mainSoundProperty);
        } while (dbus_message_iter_next(&arrayIter));
+        dbus_message_iter_next(&sourceDataIter);
+
+    dbus_message_iter_recurse(&sourceDataIter, &arrayIter);
+    do
+    {
+        dbus_message_iter_recurse(&arrayIter, &structIter);
+        MainnotificationConfiguration.type = static_cast<am_NotificationType_e>(getInt32(structIter, true));
+        MainnotificationConfiguration.parameter = static_cast<int16_t>(getInt(structIter, false));
+        MainnotificationConfiguration.status = static_cast<am_NotificationStatus_e>(getInt32(structIter, true));
+        sourceData.listMainNotificationConfigurations.push_back(MainnotificationConfiguration);
+    } while (dbus_message_iter_next(&arrayIter));
+        dbus_message_iter_next(&sourceDataIter);
+
+    dbus_message_iter_recurse(&sourceDataIter, &arrayIter);
+    do
+    {
+        dbus_message_iter_recurse(&arrayIter, &structIter);
+        notificationConfiguration.type = static_cast<am_NotificationType_e>(getInt32(structIter, true));
+        notificationConfiguration.parameter = static_cast<int16_t>(getInt(structIter, false));
+        notificationConfiguration.status = static_cast<am_NotificationStatus_e>(getInt32(structIter, true));
+        sourceData.listNotificationConfigurations.push_back(notificationConfiguration);
+    } while (dbus_message_iter_next(&arrayIter));
         dbus_message_iter_next(&mDBusMessageIter);
     }
     return (sourceData);
@@ -424,6 +448,8 @@ am_Sink_s CAmRoutingDbusMessageHandler::getSinkData()
     am_SoundProperty_s soundProperty;
     am_ConnectionFormat_e connectionFormat;
     am_MainSoundProperty_s mainSoundProperty;
+    am_NotificationConfiguration_s notificationConfiguration;
+    am_NotificationConfiguration_s MainnotificationConfiguration;
 
     if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
     {
@@ -441,17 +467,17 @@ am_Sink_s CAmRoutingDbusMessageHandler::getSinkData()
        sinkData.volume = static_cast<am_volume_t>(getInt(sinkDataIter, true));
        sinkData.visible = getBool(sinkDataIter, true);
        dbus_message_iter_recurse(&sinkDataIter, &availIter);
-       sinkData.available.availability = static_cast<am_Availability_e>(getInt(availIter, true));
-       sinkData.available.availabilityReason = static_cast<am_AvailabilityReason_e>(getInt(availIter, false));
+       sinkData.available.availability = static_cast<am_Availability_e>(getInt32(availIter, true));
+       sinkData.available.availabilityReason = static_cast<am_AvailabilityReason_e>(getInt32(availIter, false));
        dbus_message_iter_next(&sinkDataIter);
-       sinkData.muteState = static_cast<am_MuteState_e>(getInt(sinkDataIter, true));
+       sinkData.muteState = static_cast<am_MuteState_e>(getInt32(sinkDataIter, true));
        sinkData.mainVolume = static_cast<am_mainVolume_t>(getInt(sinkDataIter, true));
 
        dbus_message_iter_recurse(&sinkDataIter, &arrayIter);
        do
        {
            dbus_message_iter_recurse(&arrayIter, &structIter);
-           soundProperty.type = static_cast<am_SoundPropertyType_e>(getInt(structIter, true));
+           soundProperty.type = static_cast<am_SoundPropertyType_e>(getInt32(structIter, true));
            soundProperty.value = static_cast<int16_t>(getInt(structIter, false));
            sinkData.listSoundProperties.push_back(soundProperty);
        } while (dbus_message_iter_next(&arrayIter));
@@ -461,19 +487,41 @@ am_Sink_s CAmRoutingDbusMessageHandler::getSinkData()
        dbus_message_iter_recurse(&sinkDataIter, &arrayIter);
        do
        {
-           connectionFormat = static_cast<am_ConnectionFormat_e>(getInt(arrayIter, false));
+           connectionFormat = static_cast<am_ConnectionFormat_e>(getInt32(arrayIter, false));
            sinkData.listConnectionFormats.push_back(connectionFormat);
        } while (dbus_message_iter_next(&arrayIter));
        dbus_message_iter_next(&sinkDataIter);
 
-       dbus_message_iter_recurse(&sinkDataIter, &arrayIter);
-       do
-       {
-           dbus_message_iter_recurse(&arrayIter, &structIter);
-           mainSoundProperty.type = static_cast<am_MainSoundPropertyType_e>(getInt(structIter, true));
-           mainSoundProperty.value = static_cast<int16_t>(getInt(structIter, false));
-           sinkData.listMainSoundProperties.push_back(mainSoundProperty);
-       } while (dbus_message_iter_next(&arrayIter));
+    dbus_message_iter_recurse(&sinkDataIter, &arrayIter);
+    do
+    {
+        dbus_message_iter_recurse(&arrayIter, &structIter);
+        mainSoundProperty.type = static_cast<am_MainSoundPropertyType_e>(getInt32(structIter, true));
+        mainSoundProperty.value = static_cast<int16_t>(getInt(structIter, false));
+        sinkData.listMainSoundProperties.push_back(mainSoundProperty);
+    } while (dbus_message_iter_next(&arrayIter));
+        dbus_message_iter_next(&sinkDataIter);
+
+    dbus_message_iter_recurse(&sinkDataIter, &arrayIter);
+    do
+    {
+        dbus_message_iter_recurse(&arrayIter, &structIter);
+        MainnotificationConfiguration.type = static_cast<am_NotificationType_e>(getInt32(structIter, true));
+        MainnotificationConfiguration.parameter = static_cast<int16_t>(getInt(structIter, false));
+        MainnotificationConfiguration.status = static_cast<am_NotificationStatus_e>(getInt32(structIter, true));
+        sinkData.listMainNotificationConfigurations.push_back(MainnotificationConfiguration);
+    } while (dbus_message_iter_next(&arrayIter));
+        dbus_message_iter_next(&sinkDataIter);
+
+    dbus_message_iter_recurse(&sinkDataIter, &arrayIter);
+    do
+    {
+        dbus_message_iter_recurse(&arrayIter, &structIter);
+        notificationConfiguration.type = static_cast<am_NotificationType_e>(getInt32(structIter, true));
+        notificationConfiguration.parameter = static_cast<int16_t>(getInt(structIter, false));
+        notificationConfiguration.status = static_cast<am_NotificationStatus_e>(getInt32(structIter, true));
+        sinkData.listNotificationConfigurations.push_back(notificationConfiguration);
+    } while (dbus_message_iter_next(&arrayIter));
         dbus_message_iter_next(&mDBusMessageIter);
     }
     return (sinkData);
@@ -504,14 +552,14 @@ am_Gateway_s CAmRoutingDbusMessageHandler::getGatewayData()
        do
        {
            dbus_message_iter_recurse(&gatewayDataIter, &arrayIter);
-           connectionFormat = static_cast<am_ConnectionFormat_e>(getUInt(arrayIter, false));
+           connectionFormat = static_cast<am_ConnectionFormat_e>(getInt32(arrayIter, false));
            gatewayData.listSourceFormats.push_back(connectionFormat);
        } while (dbus_message_iter_next(&arrayIter));
        dbus_message_iter_next(&gatewayDataIter);
        do
        {
            dbus_message_iter_recurse(&gatewayDataIter, &arrayIter);
-           connectionFormat = static_cast<am_ConnectionFormat_e>(getUInt(arrayIter, false));
+           connectionFormat = static_cast<am_ConnectionFormat_e>(getInt32(arrayIter, false));
            gatewayData.listSinkFormats.push_back(connectionFormat);
        } while (dbus_message_iter_next(&arrayIter));
        dbus_message_iter_next(&gatewayDataIter);
@@ -898,6 +946,160 @@ void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SinkClass_s>&
     }
 }
 
+std::vector<am_ConnectionFormat_e> CAmRoutingDbusMessageHandler::getListconnectionFormats()
+{
+    DBusMessageIter arrayIter;
+    std::vector<am_ConnectionFormat_e> listConnectionFormats;
+    if (DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&mDBusMessageIter))
+       {
+           log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusMessageHandler::getListconnectionFormats DBUS handler argument is no array!");
+           mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
+           mErrorMsg = "DBus argument is no array";
+       }
+   else
+   {
+       do
+       {
+           dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
+           am_ConnectionFormat_e connectionformat(static_cast<am_ConnectionFormat_e>(getUInt(arrayIter, false)));
+           listConnectionFormats.push_back(connectionformat);
+       } while (dbus_message_iter_next(&arrayIter));
+       dbus_message_iter_next(&mDBusMessageIter);
+   }
+   return (listConnectionFormats);
+
+}
+
+std::vector<bool> CAmRoutingDbusMessageHandler::getListBool()
+{
+    DBusMessageIter arrayIter;
+    std::vector<bool> listBools;
+    if (DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&mDBusMessageIter))
+       {
+           log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusMessageHandler::getListBool DBUS handler argument is no array!");
+           mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
+           mErrorMsg = "DBus argument is no array";
+       }
+   else
+   {
+       do
+       {
+           dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
+           bool myBool(static_cast<bool>(getBool(arrayIter, false)));
+           listBools.push_back(myBool);
+       } while (dbus_message_iter_next(&arrayIter));
+       dbus_message_iter_next(&mDBusMessageIter);
+   }
+   return (listBools);
+}
+
+am_SoundProperty_s CAmRoutingDbusMessageHandler::getSoundProperty()
+{
+    am_SoundProperty_s soundProperty;
+    DBusMessageIter structIter;
+
+    dbus_message_iter_recurse(&mDBusMessageIter, &structIter);
+    soundProperty.type = static_cast<am_SoundPropertyType_e>(getInt(structIter, true));
+    soundProperty.value = static_cast<int16_t>(getInt(structIter, false));
+    dbus_message_iter_next(&mDBusMessageIter);
+
+    return(soundProperty);
+}
+
+std::vector<am_SoundProperty_s> CAmRoutingDbusMessageHandler::getListSoundProperties()
+{
+    DBusMessageIter arrayIter;
+    DBusMessageIter structIter;
+    am_SoundProperty_s soundProperty;
+    std::vector<am_SoundProperty_s> listSoundProperties;
+    if (DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&mDBusMessageIter))
+       {
+           log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusMessageHandler::getListSoundProperties DBUS handler argument is no array!");
+           mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
+           mErrorMsg = "DBus argument is no array";
+       }
+   else
+   {
+       do
+       {
+           dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
+           dbus_message_iter_recurse(&arrayIter, &structIter);
+           soundProperty.type = static_cast<am_SoundPropertyType_e>(getInt(structIter, true));
+           soundProperty.value = static_cast<int16_t>(getInt(structIter, false));
+           listSoundProperties.push_back(soundProperty);
+       } while (dbus_message_iter_next(&arrayIter));
+       dbus_message_iter_next(&structIter);
+   }
+   return (listSoundProperties);
+}
+
+std::vector<am_MainSoundProperty_s> CAmRoutingDbusMessageHandler::getListMainSoundProperties()
+{
+    DBusMessageIter arrayIter;
+    DBusMessageIter structIter;
+    am_MainSoundProperty_s soundProperty;
+    std::vector<am_MainSoundProperty_s> listSoundProperties;
+    if (DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&mDBusMessageIter))
+       {
+           log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusMessageHandler::getListSoundProperties DBUS handler argument is no array!");
+           mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
+           mErrorMsg = "DBus argument is no array";
+       }
+   else
+   {
+       do
+       {
+           dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
+           dbus_message_iter_recurse(&arrayIter, &structIter);
+           soundProperty.type = static_cast<am_MainSoundPropertyType_e>(getInt(structIter, true));
+           soundProperty.value = static_cast<int16_t>(getInt(structIter, false));
+           listSoundProperties.push_back(soundProperty);
+       } while (dbus_message_iter_next(&arrayIter));
+       dbus_message_iter_next(&structIter);
+   }
+   return (listSoundProperties);
+}
+
+am_NotificationPayload_s CAmRoutingDbusMessageHandler::getNotificationPayload()
+{
+    am_NotificationPayload_s notificationPayload;
+    DBusMessageIter structIter;
+
+    dbus_message_iter_recurse(&mDBusMessageIter, &structIter);
+    notificationPayload.type = static_cast<am_NotificationType_e>(getInt(structIter, true));
+    notificationPayload.value = static_cast<int16_t>(getInt(structIter, false));
+    dbus_message_iter_next(&mDBusMessageIter);
+
+    return (notificationPayload);
+}
+
+dbus_int32_t CAmRoutingDbusMessageHandler::getInt32()
+{
+    return (getInt32(mDBusMessageIter, true));
+}
+
+dbus_int32_t CAmRoutingDbusMessageHandler::getInt32(DBusMessageIter& iter, bool next)
+{
+    dbus_int32_t param(0);
+  #ifdef GLIB_DBUS_TYPES_TOLERANT
+      if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&iter) && DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&iter))
+  #else
+      if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&iter))
+  #endif
+      {
+          log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getInt DBUS handler argument is no int32_t!");
+          mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
+          mErrorMsg = "DBus argument is no int32_t";
+      }
+      else
+      {
+          dbus_message_iter_get_basic(&iter, &param);
+          if (next)
+              dbus_message_iter_next(&iter);
+      }
+      return (param);
+}
+
 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SystemProperty_s>& listSystemProperties)
 {
     DBusMessageIter arrayIter;
@@ -923,7 +1125,7 @@ void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SystemPropert
 
 void CAmRoutingDbusMessageHandler::append(const am::am_Error_e error)
 {
-    if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT16, &error))
+    if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_INT32, &error))
     {
         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);

diff --git a/PluginRoutingInterfaceDbus/src/CAmDbusSend.cpp b/PluginRoutingInterfaceDbus/src/CAmDbusSend.cpp
index 765bc1d..e3bb371 100644 (file)
--- a/PluginRoutingInterfaceDbus/src/CAmDbusSend.cpp
+++ b/PluginRoutingInterfaceDbus/src/CAmDbusSend.cpp
@@ -29,7 +29,8 @@ CAmRoutingDbusSend::CAmRoutingDbusSend(DBusConnection* conn, std::string bus_nam
         mpDbusMessage(NULL), //
         mpDbusConnection(conn), //
         mDbusMessageIter(), //
-        mDBusError()
+        mDBusError(), //
+        mSerial(1)
 {
     dbus_error_init(&mDBusError);
     mpDbusMessage = dbus_message_new_method_call(bus_name.c_str(), path.c_str(), interface.c_str(), method.c_str());
@@ -113,10 +114,20 @@ void CAmRoutingDbusSend::append(am_SoundProperty_s soundProperty)
     }
 }
 
+void CAmRoutingDbusSend::append(int integer)
+{
+    dbus_message_iter_init_append(mpDbusMessage, &mDbusMessageIter);
+    if (!dbus_message_iter_append_basic(&mDbusMessageIter, DBUS_TYPE_INT32, &integer))
+    {
+        log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusSend::append no more memory");
+        this->~CAmRoutingDbusSend();
+    }
+}
+
 am_Error_e CAmRoutingDbusSend::send()
 {
 
-    int16_t error;
+    int32_t error;
     DBusMessage* reply(dbus_connection_send_with_reply_and_block(mpDbusConnection, mpDbusMessage, -1, &mDBusError));
     if (!reply)
     {
@@ -124,10 +135,20 @@ am_Error_e CAmRoutingDbusSend::send()
         return (E_UNKNOWN);
     }
     if(!dbus_message_get_args(reply, &mDBusError, //
-            DBUS_TYPE_INT16, &error, //
+            DBUS_TYPE_INT32, &error, //
             DBUS_TYPE_INVALID))
         return (E_UNKNOWN);
     dbus_message_unref(reply);
     return (static_cast<am_Error_e>(error));
 }
+
+am_Error_e CAmRoutingDbusSend::sendAsync()
+{
+
+    dbus_connection_send(mpDbusConnection, mpDbusMessage, &mSerial);
+    mSerial++;
+    return (E_OK);
+
+}
+
 }

diff --git a/PluginRoutingInterfaceDbus/src/CAmRoutingSenderDbus.cpp b/PluginRoutingInterfaceDbus/src/CAmRoutingSenderDbus.cpp
index 078f47a..706cbd6 100644 (file)
--- a/PluginRoutingInterfaceDbus/src/CAmRoutingSenderDbus.cpp
+++ b/PluginRoutingInterfaceDbus/src/CAmRoutingSenderDbus.cpp
@@ -116,10 +116,10 @@ am_Error_e CAmRoutingSenderDbus::asyncConnect(const am_Handle_s handle, const am
         send.append(connectionID);
         send.append(sourceID);
         send.append(sinkID);
-        send.append(static_cast<int16_t>(connectionFormat));
+        send.append(static_cast<int32_t>(connectionFormat));
         mMapConnections.insert(std::make_pair(connectionID, (iter->second)));
         mMapHandles.insert(std::make_pair(+handle.handle, iter->second));
-        return (send.send());
+        return (send.sendAsync());
     }
     log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingSenderDbus::asyncConnect could not find interface");
     return (E_UNKNOWN);
@@ -136,7 +136,7 @@ am_Error_e CAmRoutingSenderDbus::asyncDisconnect(const am_Handle_s handle, const
         send.append(handle.handle);
         send.append(connectionID);
         mMapHandles.insert(std::make_pair(+handle.handle, iter->second));
-        return (send.send());
+        return (send.sendAsync());
     }
     log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingSenderDbus::asyncDisconnect could not find interface");
     return (E_UNKNOWN);
@@ -153,7 +153,7 @@ am_Error_e CAmRoutingSenderDbus::asyncSetSinkVolume(const am_Handle_s handle, co
         send.append(handle.handle);
         send.append(sinkID);
         send.append(volume);
-        send.append(static_cast<int16_t>(ramp));
+        send.append(static_cast<int32_t>(ramp));
         send.append(time);
         mMapHandles.insert(std::make_pair(+handle.handle, iter->second));
         return (send.send());
@@ -192,9 +192,9 @@ am_Error_e CAmRoutingSenderDbus::asyncSetSourceState(const am_Handle_s handle, c
         CAmRoutingDbusSend send(mpDBusConnection, iter->second.busname, iter->second.path, iter->second.interface, "asyncSetSourceState");
         send.append(handle.handle);
         send.append(sourceID);
-        send.append(static_cast<int16_t>(state));
+        send.append(static_cast<int32_t>(state));
         mMapHandles.insert(std::make_pair(+handle.handle, iter->second));
-        return (send.send());
+        return (send.sendAsync());
     }
     log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingSenderDbus::asyncSetSourceState could not find interface");
     return (E_UNKNOWN);
@@ -292,7 +292,7 @@ am_Error_e CAmRoutingSenderDbus::setDomainState(const am_domainID_t domainID, co
     {
         CAmRoutingDbusSend send(mpDBusConnection, iter->second.busname, iter->second.path, iter->second.interface, "setDomainState");
         send.append(domainID);
-        send.append(static_cast<int16_t>(domainState));
+        send.append(static_cast<int>(domainState));
         return (send.send());
     }
     log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingSenderDbus::setDomainState could not find interface");

diff --git a/PluginRoutingInterfaceDbus/src/IAmRoutingReceiverShadow.cpp b/PluginRoutingInterfaceDbus/src/IAmRoutingReceiverShadow.cpp
index 5ba1c34..5f600be 100644 (file)
--- a/PluginRoutingInterfaceDbus/src/IAmRoutingReceiverShadow.cpp
+++ b/PluginRoutingInterfaceDbus/src/IAmRoutingReceiverShadow.cpp
@@ -704,7 +704,12 @@ void IAmRoutingReceiverShadowDbus::confirmRoutingRundown(DBusConnection* conn, D
 
     mNumberDomains--;
     if(mNumberDomains==0)
-        mRoutingReceiveInterface->confirmRoutingReady(mHandle,E_OK);
+    {
+        logInfo("sending out");
+        mRoutingReceiveInterface->confirmRoutingRundown(mHandle,E_OK);
+    }
+    mDBUSMessageHandler.initReply(msg);
+    mDBUSMessageHandler.sendMessage();
 }
 
 void IAmRoutingReceiverShadowDbus::gotReady(int16_t numberDomains, uint16_t handle)
@@ -718,6 +723,142 @@ void IAmRoutingReceiverShadowDbus::gotRundown(int16_t numberDomains, uint16_t ha
     mHandle=handle;
 }
 
+void IAmRoutingReceiverShadowDbus::updateGateway(DBusConnection* conn, DBusMessage* msg)
+{
+    (void) ((conn));
+    assert(mRoutingReceiveInterface != NULL);
+    mDBUSMessageHandler.initReceive(msg);
+    am_gatewayID_t gatewayID(mDBUSMessageHandler.getInt());
+    std::vector<am_ConnectionFormat_e> listSourceConnectionFormats(mDBUSMessageHandler.getListconnectionFormats());
+    std::vector<am_ConnectionFormat_e> listSinkConnectionFormats(mDBUSMessageHandler.getListconnectionFormats());
+    std::vector<bool> convertionMatrix(mDBUSMessageHandler.getListBool());
+
+    am_Error_e returnCode = mRoutingReceiveInterface->updateGateway(gatewayID,listSourceConnectionFormats,listSinkConnectionFormats,convertionMatrix);
+    mDBUSMessageHandler.initReply(msg);
+    mDBUSMessageHandler.append(returnCode);
+    mDBUSMessageHandler.sendMessage();
+    if (returnCode != E_OK)
+    {
+        log(&routingDbus, DLT_LOG_INFO, "error updateGateway");
+        return;
+    }
+}
+
+void IAmRoutingReceiverShadowDbus::updateSink(DBusConnection* conn, DBusMessage* msg)
+{
+    (void) ((conn));
+    assert(mRoutingReceiveInterface != NULL);
+    mDBUSMessageHandler.initReceive(msg);
+    am_sinkID_t sinkID(mDBUSMessageHandler.getInt());
+    am_sinkClass_t sinkClassID(mDBUSMessageHandler.getInt());
+    std::vector<am_SoundProperty_s> listSoundProperties(mDBUSMessageHandler.getListSoundProperties());
+    std::vector<am_ConnectionFormat_e> listSinkConnectionFormats(mDBUSMessageHandler.getListconnectionFormats());
+    std::vector<am_MainSoundProperty_s> listMainSoundProperties(mDBUSMessageHandler.getListMainSoundProperties());
+
+    am_Error_e returnCode = mRoutingReceiveInterface->updateSink(sinkID,sinkClassID,listSoundProperties,listSinkConnectionFormats,listMainSoundProperties);
+    mDBUSMessageHandler.initReply(msg);
+    mDBUSMessageHandler.append(returnCode);
+    mDBUSMessageHandler.sendMessage();
+    if (returnCode != E_OK)
+    {
+        log(&routingDbus, DLT_LOG_INFO, "error updateSink");
+        return;
+    }
+}
+
+void IAmRoutingReceiverShadowDbus::updateSource(DBusConnection* conn, DBusMessage* msg)
+{
+    (void) ((conn));
+    assert(mRoutingReceiveInterface != NULL);
+    mDBUSMessageHandler.initReceive(msg);
+    am_sourceID_t sourceID(mDBUSMessageHandler.getInt());
+    am_sourceClass_t sourceClassID(mDBUSMessageHandler.getInt());
+    std::vector<am_SoundProperty_s> listSoundProperties(mDBUSMessageHandler.getListSoundProperties());
+    std::vector<am_ConnectionFormat_e> listSinkConnectionFormats(mDBUSMessageHandler.getListconnectionFormats());
+    std::vector<am_MainSoundProperty_s> listMainSoundProperties(mDBUSMessageHandler.getListMainSoundProperties());
+
+    am_Error_e returnCode = mRoutingReceiveInterface->updateSource(sourceID,sourceClassID,listSoundProperties,listSinkConnectionFormats,listMainSoundProperties);
+    mDBUSMessageHandler.initReply(msg);
+    mDBUSMessageHandler.append(returnCode);
+    mDBUSMessageHandler.sendMessage();
+    if (returnCode != E_OK)
+    {
+        log(&routingDbus, DLT_LOG_INFO, "error updateSink");
+        return;
+    }
+}
+
+void IAmRoutingReceiverShadowDbus::ackSetVolumes(DBusConnection* conn, DBusMessage* msg)
+{
+    (void) ((conn));
+    am_Error_e returnCode(am_Error_e::E_NOT_USED);
+    mDBUSMessageHandler.initReply(msg);
+    mDBUSMessageHandler.append(returnCode);
+    mDBUSMessageHandler.sendMessage();
+    log(&routingDbus, DLT_LOG_INFO, "error ackSetVolumes was called - not implemented yet");
+    return;
+}
+
+void IAmRoutingReceiverShadowDbus::ackSinkNotificationConfiguration(DBusConnection* conn, DBusMessage* msg)
+{
+    (void) ((conn));
+    assert(mRoutingReceiveInterface != NULL);
+    mDBUSMessageHandler.initReceive(msg);
+    uint16_t handle(mDBUSMessageHandler.getUInt());
+    am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt())));
+    log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSinkNotificationConfiguration called, handle", handle, "error", error);
+    am_Handle_s myhandle;
+    myhandle.handleType = H_CONNECT;
+    myhandle.handle = handle;
+    mRoutingReceiveInterface->ackSinkNotificationConfiguration(myhandle, error);
+    mpRoutingSenderDbus->removeHandle(handle);
+    mDBUSMessageHandler.initReply(msg);
+    mDBUSMessageHandler.sendMessage();
+}
+
+void IAmRoutingReceiverShadowDbus::ackSourceNotificationConfiguration(DBusConnection* conn, DBusMessage* msg)
+{
+    (void) ((conn));
+    assert(mRoutingReceiveInterface != NULL);
+    mDBUSMessageHandler.initReceive(msg);
+    uint16_t handle(mDBUSMessageHandler.getUInt());
+    am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt())));
+    log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSourceNotificationConfiguration called, handle", handle, "error", error);
+    am_Handle_s myhandle;
+    myhandle.handleType = H_CONNECT;
+    myhandle.handle = handle;
+    mRoutingReceiveInterface->ackSourceNotificationConfiguration(myhandle, error);
+    mpRoutingSenderDbus->removeHandle(handle);
+    mDBUSMessageHandler.initReply(msg);
+    mDBUSMessageHandler.sendMessage();
+}
+
+void IAmRoutingReceiverShadowDbus::hookSinkNotificationDataChange(DBusConnection* conn, DBusMessage* msg)
+{
+    (void) ((conn));
+    assert(mRoutingReceiveInterface != NULL);
+    mDBUSMessageHandler.initReceive(msg);
+    am_sinkID_t sinkID(mDBUSMessageHandler.getUInt());
+    am_NotificationPayload_s payload(mDBUSMessageHandler.getNotificationPayload());
+    log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookSinkNotificationDataChange called, sinkID", sinkID);
+    mRoutingReceiveInterface->hookSinkNotificationDataChange(sinkID, payload);
+    mDBUSMessageHandler.initReply(msg);
+    mDBUSMessageHandler.sendMessage();
+}
+
+void IAmRoutingReceiverShadowDbus::hookSourceNotificationDataChange(DBusConnection* conn, DBusMessage* msg)
+{
+    (void) ((conn));
+    assert(mRoutingReceiveInterface != NULL);
+    mDBUSMessageHandler.initReceive(msg);
+    am_sourceID_t sourceID(mDBUSMessageHandler.getUInt());
+    am_NotificationPayload_s payload(mDBUSMessageHandler.getNotificationPayload());
+    log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookSourceNotificationDataChange called, sourceID", sourceID);
+    mRoutingReceiveInterface->hookSourceNotificationDataChange(sourceID, payload);
+    mDBUSMessageHandler.initReply(msg);
+    mDBUSMessageHandler.sendMessage();
+}
+
 IAmRoutingReceiverShadowDbus::functionMap_t IAmRoutingReceiverShadowDbus::createMap()
 {
     functionMap_t m;
@@ -757,6 +898,11 @@ IAmRoutingReceiverShadowDbus::functionMap_t IAmRoutingReceiverShadowDbus::create
     m["sendChangedData"] = &IAmRoutingReceiverShadowDbus::sendChangedData;
     m["confirmRoutingReady"] =  &IAmRoutingReceiverShadowDbus::confirmRoutingReady;
     m["confirmRoutingRundown"] =  &IAmRoutingReceiverShadowDbus::confirmRoutingRundown;
+    m["ackSetVolumes"] = &IAmRoutingReceiverShadowDbus::ackSetVolumes;
+    m["ackSinkNotificationConfiguration"] = &IAmRoutingReceiverShadowDbus::ackSinkNotificationConfiguration;
+    m["ackSourceNotificationConfiguration"] = &IAmRoutingReceiverShadowDbus::ackSourceNotificationConfiguration;
+    m["hookSinkNotificationDataChange"] = &IAmRoutingReceiverShadowDbus::hookSinkNotificationDataChange;
+    m["hookSourceNotificationDataChange"] = &IAmRoutingReceiverShadowDbus::hookSourceNotificationDataChange;
     return (m);
 }
 }