adding a pulseaudio plugin to genivi audiomanager implements dbus methods for registering domain, source and sinks implements dbus signals and methods for receiving information from pulseaudio calls dbus methods in pulseaudio

Signed-off-by: Sampreeth Ramavana <sampreeth.ramavana@aricent.com>

9 files changed, 1706 insertions, 28 deletions

diff --git a/PluginRoutingInterfaceDbus/include/CAmDbusMessageHandler.h b/PluginRoutingInterfaceDbus/include/CAmDbusMessageHandler.h
new file mode 100644
index 0000000..69f5d34
--- /dev/null
+++ b/PluginRoutingInterfaceDbus/include/CAmDbusMessageHandler.h
@@ -0,0 +1,123 @@
+/**
+ *  Copyright (c) copyright 2011-2012 Aricent® Group  and its licensors
+ *
+ *  \author: Sampreeth Ramavana
+ *
+ *  \copyright
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ *  including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+ *  subject to the following conditions:
+ *  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ *  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ *  THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *  For further information see http://www.genivi.org/.
+ */
+
+#ifndef _CAMSDBUSMESSAGEHANDLER_H_
+#define _CAMSDBUSMESSAGEHANDLER_H_
+
+
+#include <audiomanagertypes.h>
+#include <dbus/dbus.h>
+#include <dlt/dlt.h>
+#include <vector>
+#include <sstream>
+#include <string>
+#include <list>
+
+namespace am {
+
+
+/**
+ * handles DBus Messages, is used to extract & append parameters and send messages
+ */
+class CAmDbusMessageHandler
+{
+public:
+        CAmDbusMessageHandler();
+    ~CAmDbusMessageHandler();
+
+    /**
+     * sets the DBus Connection
+     * @param connection pointer to the DBus Connection
+     */
+    void setDBusConnection(DBusConnection*& connection);
+
+    /**
+     * is called to initiate the receiving of a message
+     * @param msg pointer to the message to be received
+     */
+    void initReceive(DBusMessage* msg);
+
+    /**
+     *  is called to initiate the reply to a message
+     * @param msg pointer to the message the reply is for
+     */
+    void initReply(DBusMessage* msg);
+
+    /**
+     * inits a signal to be sent via dbus
+     * parameters can be added before sending the signal
+     * @param path the path
+     * @param signalName the signal name
+     */
+    void initSignal(std::string path, std::string signalName);
+
+    /**
+     * sends out the message
+     */
+    void sendMessage();
+
+    /**
+     * the get functions return a value from the received dbus message
+     * @return
+     */
+    dbus_uint16_t getUInt();
+    dbus_int16_t getInt();
+    dbus_uint32_t getUInt32();
+    dbus_int32_t getInt32();
+    dbus_bool_t getBool();
+    char getByte();
+    double getDouble();
+    char* getString();
+    void getProperty(dbus_int16_t& type, dbus_int16_t& value);
+
+    /**
+     * the overloaded append function appends different datatypes to the dbusmessage
+     */
+    void append(dbus_int16_t toAppend);
+    void append(dbus_uint16_t toAppend);
+    void append(dbus_uint32_t toAppend);
+    void append(char toAppend);
+    void append(bool toAppend);
+    void append(double toAppend);
+    void append(const am::am_SinkType_s& sinkType);
+    void append(const am::am_SourceType_s& sourceType);
+    void append(const am::am_MainSoundProperty_s mainSoundProperty);
+    void append(const am::am_Availability_s & availability);
+    void append(const am::am_SystemProperty_s & SystemProperty);
+    void append(const std::vector<am::am_MainConnectionType_s>& listMainConnections);
+    void append(const std::vector<am::am_SinkType_s>& listMainSinks);
+    void append(const std::vector<am::am_SourceType_s>& listMainSources);
+    void append(const std::vector<am::am_MainSoundProperty_s>& listMainSoundProperties);
+    void append(const std::vector<am::am_SourceClass_s>& listSourceClasses);
+    void append(const std::vector<am::am_SinkClass_s>& listSinkClasses);
+    void append(const std::vector<am::am_SystemProperty_s>& listSystemProperties);
+
+private:
+
+    DBusMessageIter mDBusMessageIter;
+    DBusError mDBusError;
+    dbus_uint32_t mSerial;
+    std::string mErrorName;
+    std::string mErrorMsg;
+    DBusMessage* mDbusMessage;
+    DBusMessage* mReveiveMessage;
+    DBusConnection* mDBusConnection;
+};
+
+}
+
+#endif // _CAMSDBUSMESSAGEHANDLER_H_
diff --git a/PluginRoutingInterfaceDbus/include/CAmDbusSend.h b/PluginRoutingInterfaceDbus/include/CAmDbusSend.h
new file mode 100644
index 0000000..65fe0bd
--- /dev/null
+++ b/PluginRoutingInterfaceDbus/include/CAmDbusSend.h
@@ -0,0 +1,44 @@
+/**
+ *  Copyright (c) copyright 2011-2012 Aricent® Group  and its licensors
+ *
+ *  \author: Sampreeth Ramavana
+ *
+ *  \copyright
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ *  including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+ *  subject to the following conditions:
+ *  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ *  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ *  THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *  For further information see http://www.genivi.org/.
+ */
+
+#ifndef _CAMDBUSSEND_H_
+#define _CAMDBUSSEND_H_
+
+//#include "headers.h"
+#include <dbus/dbus.h>
+
+class CAmDbusSend {
+public:
+        CAmDbusSend(DBusConnection* conn, const char* bus_name,const char* path, const char* interface, const char* method);
+        virtual ~CAmDbusSend();
+	void appendString(char* string);
+	void appendInteger(int integer);
+	void sendReply(bool* reply);
+	void sendReply(int* reply);
+        void sendReply(void);
+        void Replyint32(int *reply);
+
+private:
+	DBusMessage* m_msg;
+	DBusMessageIter m_args;
+	DBusConnection* m_conn;
+        DBusMessage* replymsg;
+        //DBusMessageIter args;
+        DBusMessageIter mDBusMessageIter;
+};
+
+#endif /* _CAMDBUSSEND_H_ */
diff --git a/PluginRoutingInterfaceDbus/include/CAmRoutingSenderDbus.h b/PluginRoutingInterfaceDbus/include/CAmRoutingSenderDbus.h
index 5a63395..fb727a3 100644
--- a/PluginRoutingInterfaceDbus/include/CAmRoutingSenderDbus.h
+++ b/PluginRoutingInterfaceDbus/include/CAmRoutingSenderDbus.h
@@ -19,9 +19,16 @@
 #define ROUTINGSENDER_H_
 
 #include "routing/IAmRoutingSend.h"
+#include <dbus/dbus.h>
+#include <map>
+#include "CAmDbusMessageHandler.h"
+#include "IAmRoutingReceiverShadow.h"
+#include "shared/CAmDbusWrapper.h"
 
 using namespace am;
 
+const char ROUTING_NODE[]="RoutingReceiver";
+
 class CAmRoutingSenderDbus: public IAmRoutingSend
 {
 public:
@@ -44,6 +51,16 @@ public:
     am_Error_e setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState) ;
     am_Error_e returnBusName(std::string& BusName) const ;
     void getInterfaceVersion(std::string& version) const ;
+
+private:
+        CAmDbusMessageHandler mDBusMessageHandler;
+        IAmRoutingReceiverShadow mRoutingReceiverShadow;
+
+        CAmDbusWrapper* mDBusWrapper;
+        IAmRoutingReceive *mRoutingReceiveInterface;
+
+
+        DBusConnection* connection;
 };
 
 #endif /* ROUTINGSENDER_H_ */
diff --git a/PluginRoutingInterfaceDbus/include/IAmRoutingReceiverShadow.h b/PluginRoutingInterfaceDbus/include/IAmRoutingReceiverShadow.h
new file mode 100644
index 0000000..4cd1b2d
--- /dev/null
+++ b/PluginRoutingInterfaceDbus/include/IAmRoutingReceiverShadow.h
@@ -0,0 +1,98 @@
+/**
+ *  Copyright (c) copyright 2011-2012 Aricent® Group  and its licensors
+ *
+ *  \author: Sampreeth Ramavana
+ *
+ *  \copyright
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ *  including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+ *  subject to the following conditions:
+ *  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ *  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ *  THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *  For further information see http://www.genivi.org/.
+ */
+
+#ifndef _IAMROUTINGRECEIVERSHADOW_H_
+#define _IAMROUTINGRECEIVERSHADOW_H_
+
+#include "routing/IAmRoutingSend.h"
+#include <dbus/dbus.h>
+#include <dlt/dlt.h>
+#include <map>
+#include "shared/CAmDbusWrapper.h"
+#include "CAmDbusMessageHandler.h"
+
+namespace am {
+
+class IAmRoutingReceiverShadow;
+
+typedef void (IAmRoutingReceiverShadow::*CallBackMethod)(DBusConnection *connection, DBusMessage *message);
+
+/**
+ * receives the DBus Callbacks, marhsalls and demarshalls the parameters and calls CommandReceive
+ */
+class IAmRoutingReceiverShadow {
+public:
+        IAmRoutingReceiverShadow();
+        virtual ~IAmRoutingReceiverShadow();
+        void ackConnect(DBusConnection *conn, DBusMessage *msg) ;
+        void ackDisconnect(DBusConnection *conn, DBusMessage *msg) ;
+        void ackSetSinkVolume(DBusConnection *conn, DBusMessage *msg);
+        void ackSetSourceVolume(DBusConnection *conn, DBusMessage *msg);
+        void ackSinkVolumeTick(DBusConnection *conn, DBusMessage *msg);
+        void ackSourceVolumeTick(DBusConnection *conn, DBusMessage *msg);
+        void ackSetSinkSoundProperty(DBusConnection *conn, DBusMessage *msg);
+        void ackSetSourceSoundProperty(DBusConnection *conn, DBusMessage *msg);
+
+        void registerDomain(DBusConnection *conn, DBusMessage *msg) ;
+        void registerSource(DBusConnection *conn, DBusMessage *msg) ;
+        void registerSink(DBusConnection *conn, DBusMessage *msg) ;
+        void registerGateway(DBusConnection *conn, DBusMessage *msg) ;
+        void hookDomainRegistrationComplete(DBusConnection *conn, DBusMessage *msg);
+
+	/**
+	 * sets the pointer to the CommandReceiveInterface and registers Callback
+	 * @param receiver
+	 */
+        void setRoutingReceiver(IAmRoutingReceive*& receiver);
+private:
+        IAmRoutingReceive* mRoutingReceiveInterface;
+        CAmDbusWrapper* mDBusWrapper;
+	typedef std::map<std::string,CallBackMethod> functionMap_t;
+	functionMap_t mFunctionMap;
+        CAmDbusMessageHandler mDBUSMessageHandler;
+
+	/**
+	 * receives a callback whenever the path of the plugin is called
+	 */
+	static DBusHandlerResult receiveCallback(DBusConnection *conn, DBusMessage *msg, void *user_data);
+
+	/**
+	 * dynamic delegate that handles the Callback of the static receiveCallback
+	 * @param conn DBus connection
+	 * @param msg DBus message
+         * @param user_data pointer to instance of IAmRoutingReceiverShadow
+	 * @return
+	 */
+	DBusHandlerResult receiveCallbackDelegate(DBusConnection *conn, DBusMessage *msg);
+
+	/**
+	 * sends out introspectiondata read from an xml file.
+	 * @param conn
+	 * @param msg
+	 */
+	void sendIntrospection(DBusConnection* conn, DBusMessage* msg) ;
+
+	/**
+	 * creates the function map needed to combine DBus messages and function adresses
+	 * @return the map
+	 */
+	functionMap_t createMap();
+};
+
+}
+
+#endif /* _IAMROUTINGRECEIVERSHADOW_H_ */
diff --git a/PluginRoutingInterfaceDbus/include/RoutingReceiver.xml b/PluginRoutingInterfaceDbus/include/RoutingReceiver.xml
new file mode 100644
index 0000000..78e06e3
--- /dev/null
+++ b/PluginRoutingInterfaceDbus/include/RoutingReceiver.xml
@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE node PUBLIC
+  "-//freedesktop//DTD D-Bus Object Introspection 1.0//EN"
+  "http://standards.freedesktop.org/dbus/1.0/introspect.dtd">
+
+<node>  
+	<interface name="org.genivi.audiomanager.RoutingReceiver">          
+
+	<method name="ackConnect">      
+		<arg name="handle" type="i" direction="in" />      
+		<arg name="connectionID" type="i" direction="in" /> 
+		<arg name="error" type="i" direction="in" />
+	</method>
+        <method name="ackDisconnect">
+                <arg name="handle" type="i" direction="in" />
+                <arg name="connectionID" type="i" direction="in" />
+                <arg name="error" type="i" direction="in" />
+        </method>
+        <method name="ackSetSinkVolumeChange">
+                <arg name="handle" type="i" direction="in" />
+                <arg name="volume" type="i" direction="in" />
+                <arg name="error" type="i" direction="in" />
+        </method>
+        <method name="ackSetSourceVolumeChange">
+                <arg name="handle" type="i" direction="in" />
+                <arg name="connectionID" type="i" direction="in" />
+                <arg name="error" type="i" direction="in" />
+        </method>
+        <method name="ackSetSourceState">
+                <arg name="handle" type="u" direction="in" />
+                <arg name="error" type="n" direction="in" />
+        </method>
+        <method name="ackSetSinkSoundProperty">
+                <arg name="handle" type="u" direction="in" />
+                <arg name="error" type="n" direction="in" />
+        </method>
+        <method name="ackSetSourceSoundProperty">
+                <arg name="handle" type="u" direction="in" />
+                <arg name="error" type="n" direction="in" />
+        </method>
+        <method name="ackCrossFading">
+                <arg name="handle" type="u" direction="in" />
+                <arg name="hotsink" type="q" direction="in" />
+                <arg name="error" type="n" direction="in" />
+        </method>
+        <method name="ackSourceVolumeTick">
+                <arg name="handle" type="u" direction="in" />
+                <arg name="source" type="q" direction="in" />
+                <arg name="volume" type="n" direction="in" />
+        </method>
+        <method name="ackSinkVolumeTick">
+                <arg name="handle" type="u" direction="in" />
+                <arg name="sink" type="q" direction="in" />
+                <arg name="volume" type="n" direction="in" />
+        </method>
+
+
+        <method name="peekDomain">
+                <arg name="name" type="s" direction="in" />
+                <arg name="domainid" type="q" direction="in" />
+        </method>
+        <method name="registerDomain">
+                <arg name="domaindata" type="(qsssbbq)" direction="in" />
+                <arg name="domainid" type="q" direction="in" />
+        </method>
+        <method name="deregisterDomain">
+                <arg name="domainid" type="q" direction="in" />
+        </method>
+
+
+	<method name="registerSource">      
+		<arg name="soucedata" type="(qqsqqnb(qq)q)" direction="in" />      
+		<arg name="sourceid" type="q" direction="in" /> 
+	</method>
+
+        <method name="deregisterSource">
+                <arg name="sourceid" type="q" direction="in" />  
+        </method>
+
+	<signal name="signal_systemReady">
+        </signal>
+
+	</interface>
+</node>
diff --git a/PluginRoutingInterfaceDbus/src/CAmDbusMessageHandler.cpp b/PluginRoutingInterfaceDbus/src/CAmDbusMessageHandler.cpp
new file mode 100644
index 0000000..2e6817d
--- /dev/null
+++ b/PluginRoutingInterfaceDbus/src/CAmDbusMessageHandler.cpp
@@ -0,0 +1,642 @@
+/**
+ *  Copyright (c) copyright 2011-2012 Aricent® Group  and its licensors
+ *
+ *  \author: Sampreeth Ramavana
+ *
+ *  \copyright
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ *  including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+ *  subject to the following conditions:
+ *  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ *  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ *  THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *  For further information see http://www.genivi.org/.
+ */
+
+#include "CAmDbusMessageHandler.h"
+#include "CAmRoutingSenderDbus.h"
+#include "config.h"
+
+#include <stdlib.h>
+#include <assert.h>
+#include <vector>
+
+using namespace am;
+
+DLT_IMPORT_CONTEXT(DLT_CONTEXT)
+
+CAmDbusMessageHandler::CAmDbusMessageHandler()
+: 	mDBusMessageIter(),
+  	mDBusError(),
+  	mSerial(0),
+  	mErrorName(""),
+  	mErrorMsg(""),
+  	mDbusMessage(NULL),
+  	mReveiveMessage(NULL),
+  	mDBusConnection(NULL)
+{
+}
+
+CAmDbusMessageHandler::~CAmDbusMessageHandler()
+{
+}
+
+void CAmDbusMessageHandler::initReceive(DBusMessage* msg)
+{
+	assert(msg!=NULL);
+	mReveiveMessage=msg;
+    if (!dbus_message_iter_init(msg, &mDBusMessageIter))
+    {
+    	mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
+    	mErrorMsg="DBUS Message has no arguments!";
+    }
+}
+
+void CAmDbusMessageHandler::initReply(DBusMessage* msg)
+{
+	assert(msg!=NULL);
+    mDbusMessage = dbus_message_new_method_return(msg);
+    if (mDbusMessage==NULL) {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+    dbus_message_iter_init_append(mDbusMessage, &mDBusMessageIter);
+}
+
+void CAmDbusMessageHandler::initSignal(std::string path, std::string signalName)
+{
+	assert(!path.empty());
+	assert(!signalName.empty());
+	std::string completePath=std::string(DBUS_SERVICE_OBJECT_PATH)+"/"+path;
+        std::string objectpath=std::string(DBUS_SERVICE_PREFIX)+"."+path;
+        mDbusMessage=dbus_message_new_signal(completePath.c_str(),objectpath.c_str(),signalName.c_str());
+
+
+    dbus_message_iter_init_append(mDbusMessage, &mDBusMessageIter);
+}
+
+void CAmDbusMessageHandler::sendMessage()
+{
+	assert(mDBusConnection!=NULL);
+	if(mReveiveMessage!=0)
+	{
+		mSerial=dbus_message_get_serial(mReveiveMessage);
+	}
+	else
+	{
+		mSerial=1;
+	}
+	if (!mErrorName.empty()) {
+		mDbusMessage = dbus_message_new_error(mReveiveMessage, mErrorName.c_str(), mErrorMsg.c_str());
+	}
+    if (!dbus_connection_send(mDBusConnection, mDbusMessage, &mSerial))
+    {
+	;
+    }
+    dbus_connection_flush(mDBusConnection);
+    dbus_message_unref(mDbusMessage);
+    mDbusMessage = NULL;
+}
+
+char* CAmDbusMessageHandler::getString()
+{
+    char* param=NULL;
+
+    if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&mDBusMessageIter))
+    {
+    	mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
+    	mErrorMsg="DBus argument is no string";
+    }
+    else
+    {
+        dbus_message_iter_get_basic(&mDBusMessageIter, &param);
+        dbus_message_iter_next(&mDBusMessageIter);
+    }
+    return (param);
+}
+
+dbus_bool_t CAmDbusMessageHandler::getBool()
+{
+    dbus_bool_t boolparam=false;
+
+    if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&mDBusMessageIter))
+    {
+    	mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
+    	mErrorMsg="DBus argument is no bool";
+    }
+    else
+    {
+        dbus_message_iter_get_basic(&mDBusMessageIter, &boolparam);
+        dbus_message_iter_next(&mDBusMessageIter);
+    }
+    return (boolparam);
+}
+
+char CAmDbusMessageHandler::getByte()
+{
+    char param;
+
+    if (DBUS_TYPE_BYTE != dbus_message_iter_get_arg_type(&mDBusMessageIter))
+    {
+    	mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
+    	mErrorMsg="DBus argument is no byte";
+    }
+    else
+    {
+        dbus_message_iter_get_basic(&mDBusMessageIter, &param);
+        dbus_message_iter_next(&mDBusMessageIter);
+    }
+    return (param);
+}
+
+dbus_uint16_t CAmDbusMessageHandler::getUInt()
+{
+    dbus_uint16_t param;
+
+    if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
+    {
+    	mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
+    	mErrorMsg="DBus argument is no uint16_t";
+    }
+    else
+    {
+        dbus_message_iter_get_basic(&mDBusMessageIter, &param);
+        dbus_message_iter_next(&mDBusMessageIter);
+    }
+    return (param);
+}
+
+dbus_int16_t CAmDbusMessageHandler::getInt()
+{
+    dbus_int16_t param;
+
+    if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
+    {
+    	mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
+        mErrorMsg="DBus argument is no int16_t";
+    }
+    else
+    {
+        dbus_message_iter_get_basic(&mDBusMessageIter, &param);
+        dbus_message_iter_next(&mDBusMessageIter);
+    }
+    return (param);
+}
+
+dbus_uint32_t CAmDbusMessageHandler::getUInt32()
+{
+    dbus_uint16_t param;
+
+    if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
+    {
+        mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
+        mErrorMsg="DBus argument is no uint32_t";
+    }
+    else
+    {
+        dbus_message_iter_get_basic(&mDBusMessageIter, &param);
+        dbus_message_iter_next(&mDBusMessageIter);
+    }
+    return (param);
+}
+
+dbus_int32_t CAmDbusMessageHandler::getInt32()
+{
+    dbus_int32_t param;
+
+    if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
+    {
+        mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
+        mErrorMsg="DBus argument is no int32_t";
+    }
+    else
+    {
+        dbus_message_iter_get_basic(&mDBusMessageIter, &param);
+        dbus_message_iter_next(&mDBusMessageIter);
+    }
+    return (param);
+}
+
+double CAmDbusMessageHandler::getDouble()
+{
+    double param;
+    if (DBUS_TYPE_DOUBLE != dbus_message_iter_get_arg_type(&mDBusMessageIter))
+    {
+    	mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
+    	mErrorMsg="DBus argument is no double";
+    }
+    else
+    {
+        dbus_message_iter_get_basic(&mDBusMessageIter, &param);
+        dbus_message_iter_next(&mDBusMessageIter);
+    }
+    return (param);
+}
+
+void CAmDbusMessageHandler::getProperty(dbus_int16_t & type, dbus_int16_t & value)
+{
+	DBusMessageIter arrayIter;
+    if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
+    {
+    	mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
+    	mErrorMsg="DBus argument is no array";
+    }
+    else
+    {
+        dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
+        dbus_message_iter_get_basic(&arrayIter, &type);
+        dbus_message_iter_next(&arrayIter);
+        dbus_message_iter_get_basic(&arrayIter, &value);
+        dbus_message_iter_next(&mDBusMessageIter);
+    }
+}
+
+void CAmDbusMessageHandler::append(bool toAppend)
+{
+	dbus_bool_t mybool=toAppend;
+    if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BOOLEAN, &mybool))
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+
+void CAmDbusMessageHandler::append(double toAppend)
+{
+    if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_DOUBLE, &toAppend))
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+void CAmDbusMessageHandler::append(char toAppend)
+{
+    if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BYTE, &toAppend))
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+
+void CAmDbusMessageHandler::append(dbus_int16_t toAppend)
+{
+    if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_INT16, &toAppend))
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+void CAmDbusMessageHandler::append(dbus_uint16_t toAppend)
+{
+    if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT16, &toAppend))
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+void CAmDbusMessageHandler::append(dbus_uint32_t toAppend)
+{
+    if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT32, &toAppend))
+    {
+        mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+        mErrorMsg="Cannot create reply!";
+    }
+}
+
+void CAmDbusMessageHandler::setDBusConnection(DBusConnection *& connection)
+{
+	assert(connection!=NULL);
+        mDBusConnection=connection;
+}
+
+void CAmDbusMessageHandler::append(const am::am_SinkType_s& sinkType)
+{
+    DBusMessageIter structIter;
+    DBusMessageIter structAvailIter;
+    dbus_bool_t success=true;
+    success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
+    success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkID);
+    success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sinkType.name);
+
+    success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
+    success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availability);
+    success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availabilityReason);
+    success=success && dbus_message_iter_close_container(&structIter, &structAvailIter);
+
+    success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.volume);
+    success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.muteState);
+    success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkClassID);
+    success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
+
+    if (!success)
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+void CAmDbusMessageHandler::append(const am::am_SourceType_s & sourceType)
+{
+    DBusMessageIter structIter;
+    DBusMessageIter structAvailIter;
+    dbus_bool_t success=true;
+    success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
+    success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceID);
+    success=success &&  dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sourceType.name);
+
+    success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
+    success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availability);
+    success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availabilityReason);
+    success=success && dbus_message_iter_close_container(&structIter, &structAvailIter);
+
+    success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceClassID);
+    success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
+
+    if (!success)
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+void CAmDbusMessageHandler::append(const am::am_MainSoundProperty_s mainSoundProperty)
+{
+	DBusMessageIter structIter;
+    dbus_bool_t success=true;
+    success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
+    success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.type);
+    success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.value);
+    success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
+
+    if (!success)
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+void CAmDbusMessageHandler::append(const am::am_Availability_s & availability)
+{
+    DBusMessageIter structAvailIter;
+    dbus_bool_t success=true;
+    success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT,NULL, &structAvailIter);
+    success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availability);
+    success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availabilityReason);
+    success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structAvailIter);
+
+    if (!success)
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+void CAmDbusMessageHandler::append(const am::am_SystemProperty_s & SystemProperty)
+{
+    DBusMessageIter structIter;
+    dbus_bool_t success=true;
+    success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
+    success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.type);
+    success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.value);
+    success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
+
+    if (!success)
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+void CAmDbusMessageHandler::append(const std::vector<am::am_MainConnectionType_s>& listMainConnections)
+{
+    DBusMessageIter arrayIter;
+    DBusMessageIter structIter;
+    std::vector<am::am_MainConnectionType_s>::const_iterator listIterator=listMainConnections.begin();
+    dbus_bool_t success=true;
+
+    success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qqqnn)", &arrayIter);
+    for(;listIterator<listMainConnections.end();++listIterator)
+    {
+        success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->mainConnectionID);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->delay);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->connectionState);
+        success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
+    }
+    success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
+
+    if (!success)
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+void CAmDbusMessageHandler::append(const std::vector<am::am_SinkType_s> & listMainSinks)
+{
+    DBusMessageIter arrayIter;
+    DBusMessageIter structIter;
+    DBusMessageIter availIter;
+    std::vector<am::am_SinkType_s>::const_iterator listIterator=listMainSinks.begin();
+    dbus_bool_t success=true;
+
+    success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)nnq)", &arrayIter);
+    for(;listIterator<listMainSinks.end();++listIterator)
+    {
+        success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
+        success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
+        success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
+        success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
+        success=success && dbus_message_iter_close_container(&structIter, &availIter);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->volume);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->muteState);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
+        success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
+    }
+    success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
+
+    if (!success)
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+
+
+void CAmDbusMessageHandler::append(const std::vector<am::am_SourceType_s> & listMainSources)
+{
+    DBusMessageIter arrayIter;
+    DBusMessageIter structIter;
+    DBusMessageIter availIter;
+    std::vector<am::am_SourceType_s>::const_iterator listIterator=listMainSources.begin();
+    dbus_bool_t success=true;
+
+    success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)q)", &arrayIter);
+    for(;listIterator<listMainSources.end();++listIterator)
+    {
+        success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
+        success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
+        success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
+        success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
+        success=success && dbus_message_iter_close_container(&structIter, &availIter);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
+        success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
+    }
+    success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
+
+    if (!success)
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+void CAmDbusMessageHandler::append(const std::vector<am::am_MainSoundProperty_s> & listMainSoundProperties)
+{
+    DBusMessageIter arrayIter;
+    DBusMessageIter structIter;
+    std::vector<am::am_MainSoundProperty_s>::const_iterator listIterator=listMainSoundProperties.begin();
+    dbus_bool_t success=true;
+
+    success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
+    for(;listIterator<listMainSoundProperties.end();++listIterator)
+    {
+        success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
+        success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
+    }
+    success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
+
+    if (!success)
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+void CAmDbusMessageHandler::append(const std::vector<am::am_SourceClass_s> & listSourceClasses)
+{
+    DBusMessageIter arrayIter;
+    DBusMessageIter structIter;
+    DBusMessageIter propIter;
+    DBusMessageIter innerIter;
+    std::vector<am::am_SourceClass_s>::const_iterator listIterator=listSourceClasses.begin();
+    dbus_bool_t success=true;
+
+    success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
+    for(;listIterator<listSourceClasses.end();++listIterator)
+    {
+        success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
+    	success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
+        success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
+
+        std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator=listIterator->listClassProperties.begin();
+        for(;listInnerIterator<listIterator->listClassProperties.end();++listInnerIterator)
+        {
+            success=success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
+            success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
+            success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
+            success=success && dbus_message_iter_close_container(&innerIter, &propIter);
+        }
+        success=success && dbus_message_iter_close_container(&structIter, &innerIter);
+        success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
+    }
+    success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
+
+    if (!success)
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+void CAmDbusMessageHandler::append(const std::vector<am::am_SinkClass_s> & listSinkClasses)
+{
+    DBusMessageIter arrayIter;
+    DBusMessageIter structIter;
+    DBusMessageIter propIter;
+    DBusMessageIter innerIter;
+    std::vector<am::am_SinkClass_s>::const_iterator listIterator=listSinkClasses.begin();
+    dbus_bool_t success=true;
+
+    success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
+    for(;listIterator<listSinkClasses.end();++listIterator)
+    {
+        success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
+    	success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
+        success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
+
+        std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator=listIterator->listClassProperties.begin();
+        for(;listInnerIterator<listIterator->listClassProperties.end();++listInnerIterator)
+        {
+            success=success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
+            success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
+            success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
+            success=success && dbus_message_iter_close_container(&innerIter, &propIter);
+        }
+        success=success && dbus_message_iter_close_container(&structIter, &innerIter);
+        success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
+    }
+    success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
+
+    if (!success)
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+void CAmDbusMessageHandler::append(const std::vector<am::am_SystemProperty_s> & listSystemProperties)
+{
+    DBusMessageIter arrayIter;
+    DBusMessageIter structIter;
+    std::vector<am::am_SystemProperty_s>::const_iterator listIterator=listSystemProperties.begin();
+    dbus_bool_t success=true;
+
+    success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
+    for(;listIterator<listSystemProperties.end();++listIterator)
+    {
+        success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
+        success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
+        success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
+    }
+    success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
+
+    if (!success)
+    {
+    	mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
+    	mErrorMsg="Cannot create reply!";
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/PluginRoutingInterfaceDbus/src/CAmDbusSend.cpp b/PluginRoutingInterfaceDbus/src/CAmDbusSend.cpp
new file mode 100644
index 0000000..16a42ca
--- /dev/null
+++ b/PluginRoutingInterfaceDbus/src/CAmDbusSend.cpp
@@ -0,0 +1,133 @@
+/**
+ *  Copyright (c) copyright 2011-2012 Aricent® Group  and its licensors
+ *
+ *  \author: Sampreeth Ramavana
+ *
+ *  \copyright
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ *  including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+ *  subject to the following conditions:
+ *  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ *  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ *  THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *  For further information see http://www.genivi.org/.
+ */
+
+#include "CAmDbusSend.h"
+#include <dlt/dlt.h>
+
+DLT_IMPORT_CONTEXT(DLT_CONTEXT)
+
+CAmDbusSend::CAmDbusSend (DBusConnection* conn, const char* bus_name,const char* path, const char* interface, const char* method) : m_conn(conn) {
+	m_msg=dbus_message_new_method_call(bus_name,path,interface,method);
+	if (NULL == m_msg) {
+              this->~CAmDbusSend();
+	}
+}
+
+CAmDbusSend::~CAmDbusSend() {
+        if(replymsg)
+        dbus_message_unref(replymsg);
+}
+
+void CAmDbusSend::appendString(char* string) {
+	dbus_message_iter_init_append(m_msg, &m_args);
+	if (!dbus_message_iter_append_basic(&m_args, DBUS_TYPE_STRING, string)) {
+                this->~CAmDbusSend();
+	}
+}
+
+void CAmDbusSend::appendInteger(int integer) {
+	dbus_message_iter_init_append(m_msg, &m_args);
+	if (!dbus_message_iter_append_basic(&m_args, DBUS_TYPE_INT32, &integer)) {
+                this->~CAmDbusSend();
+	}
+
+}
+
+void CAmDbusSend::sendReply(bool* reply) {
+
+	DBusPendingCall* pending;
+	DBusMessageIter args;
+	if (!dbus_connection_send_with_reply (m_conn, m_msg, &pending, -1)) { // -1 is default timeout
+                this->~CAmDbusSend();
+	}
+
+	if (NULL == pending) {
+                this->~CAmDbusSend();
+	}
+	dbus_connection_flush(m_conn);
+	dbus_message_unref(m_msg);
+    dbus_pending_call_block(pending);
+
+    DBusMessage* msg=dbus_pending_call_steal_reply(pending);
+
+	if (NULL == msg) {
+                this->~CAmDbusSend();
+	}
+
+	dbus_pending_call_unref(pending);
+
+    if (!dbus_message_iter_init(msg, &args)) {
+    } else if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&args)) {
+	} else {
+		dbus_message_iter_get_basic(&args, reply);
+	}
+
+    dbus_message_unref(msg);
+}
+
+void CAmDbusSend::sendReply(int* reply) {
+
+	DBusPendingCall* pending;
+	DBusMessageIter args;
+	if (!dbus_connection_send_with_reply (m_conn, m_msg, &pending, -1)) { // -1 is default timeout
+                this->~CAmDbusSend();
+	}
+
+	if (NULL == pending) {
+                this->~CAmDbusSend();
+	}
+	dbus_connection_flush(m_conn);
+	dbus_message_unref(m_msg);
+    dbus_pending_call_block(pending);
+
+    DBusMessage* msg=dbus_pending_call_steal_reply(pending);
+
+	if (NULL == msg) {
+                this->~CAmDbusSend();
+	}
+
+	dbus_pending_call_unref(pending);
+
+    if (!dbus_message_iter_init(msg, &args)) {
+    } else if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args)) {
+	} else {
+		dbus_message_iter_get_basic(&args, reply);
+	}
+
+    dbus_message_unref(msg);
+}
+
+void CAmDbusSend::sendReply(void) {
+
+        if (!dbus_connection_send(m_conn, m_msg, NULL))
+        {
+                this->~CAmDbusSend();
+        }
+        replymsg = NULL;
+
+}
+void CAmDbusSend::Replyint32(int *reply)
+{
+    if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
+    {
+    }
+    else
+    {
+                dbus_message_iter_get_basic(&mDBusMessageIter, reply);
+    }
+    dbus_message_iter_next(&mDBusMessageIter);
+}
diff --git a/PluginRoutingInterfaceDbus/src/CAmRoutingSenderDbus.cpp b/PluginRoutingInterfaceDbus/src/CAmRoutingSenderDbus.cpp
index 894ed87..8306911 100644
--- a/PluginRoutingInterfaceDbus/src/CAmRoutingSenderDbus.cpp
+++ b/PluginRoutingInterfaceDbus/src/CAmRoutingSenderDbus.cpp
@@ -15,7 +15,16 @@
  *  For further information see http://www.genivi.org/.
  */
 
+#include "shared/CAmDltWrapper.h"
+#include "shared/CAmDbusWrapper.h"
 #include "CAmRoutingSenderDbus.h"
+#include "CAmDbusSend.h"
+
+#define PULSE_INTERFACE_TARGET "org.genivi.pulse"
+#define PULSE_REGISTER_PATH "/pulse"
+#define PULSE_INTERFACE_NAME "org.genivi.pulse"
+
+DLT_DECLARE_CONTEXT(routingDbus)
 
 extern "C" IAmRoutingSend* PluginRoutingInterfaceDbusFactory()
 {
@@ -28,54 +37,77 @@ extern "C" void destroyRoutingPluginInterfaceDbus(IAmRoutingSend* routingSendInt
 }
 
 CAmRoutingSenderDbus::CAmRoutingSenderDbus()
+    : 	mDBusMessageHandler(),
+        mRoutingReceiverShadow(),
+        mDBusWrapper(NULL),
+        mRoutingReceiveInterface(NULL)
 {
+    CAmDltWrapper::instance()->registerContext(routingDbus, "DRS", "DBus Plugin");
+    log(&routingDbus, DLT_LOG_INFO, "RoutingSender constructed");
 }
 
 CAmRoutingSenderDbus::~CAmRoutingSenderDbus()
 {
+    log(&routingDbus, DLT_LOG_INFO, "RoutingSender destructed");
+    CAmDltWrapper::instance()->unregisterContext(routingDbus);
 }
 
 am_Error_e CAmRoutingSenderDbus::asyncAbort(const am_Handle_s handle)
 {
-    (void) handle;
-    return (E_NOT_USED);
+    CAmDbusSend send = CAmDbusSend(connection,PULSE_INTERFACE_TARGET,PULSE_REGISTER_PATH, PULSE_INTERFACE_NAME, "abort");
+    send.appendInteger(handle.handleType);
+    send.appendInteger(handle.handle);
+    send.sendReply();
+    return (E_OK);
 }
 
 am_Error_e CAmRoutingSenderDbus::asyncConnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_ConnectionFormat_e connectionFormat)
 {
-    (void) handle;
-    (void) connectionID;
-    (void) sourceID;
-    (void) sinkID;
     (void) connectionFormat;
-    return (E_NOT_USED);
+    log(&routingDbus, DLT_LOG_INFO, "pulse async connect");
+    CAmDbusSend send = CAmDbusSend(connection,PULSE_INTERFACE_TARGET,PULSE_REGISTER_PATH, PULSE_INTERFACE_NAME, "connect");
+    send.appendInteger(handle.handle);
+    send.appendInteger(connectionID);
+    send.appendInteger(sourceID);
+    send.appendInteger(sinkID);
+    send.sendReply();
+    return (E_OK);
 }
 
 am_Error_e CAmRoutingSenderDbus::asyncDisconnect(const am_Handle_s handle, const am_connectionID_t connectionID)
 {
-    (void) handle;
-    (void) connectionID;
-    return (E_NOT_USED);
+    log(&routingDbus, DLT_LOG_INFO, "pulse async disconnect");
+    CAmDbusSend send = CAmDbusSend(connection,PULSE_INTERFACE_TARGET,PULSE_REGISTER_PATH, PULSE_INTERFACE_NAME, "disconnect");
+    send.appendInteger(handle.handle);
+    send.appendInteger(connectionID);
+    send.sendReply();
+    return (E_OK);
 }
 
 am_Error_e CAmRoutingSenderDbus::asyncSetSinkVolume(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time)
 {
-    (void) handle;
-    (void) sinkID;
-    (void) volume;
-    (void) ramp;
-    (void) time;
-    return (E_NOT_USED);
+    log(&routingDbus, DLT_LOG_INFO, "pulse set sink volume");
+    CAmDbusSend send = CAmDbusSend(connection,PULSE_INTERFACE_TARGET,PULSE_REGISTER_PATH, PULSE_INTERFACE_NAME, "setSinkVolume");
+    send.appendInteger(handle.handle);
+    send.appendInteger(sinkID);
+    send.appendInteger(volume);
+    send.appendInteger(ramp);
+    send.appendInteger(time);
+    send.sendReply();
+    return (E_OK);
 }
 
 am_Error_e CAmRoutingSenderDbus::asyncSetSourceVolume(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time)
 {
-    (void) handle;
-    (void) sourceID;
-    (void) volume;
-    (void) ramp;
-    (void) time;
-    return (E_NOT_USED);
+    log(&routingDbus, DLT_LOG_INFO, "pulse set source volume");
+    CAmDbusSend send = CAmDbusSend(connection,PULSE_INTERFACE_TARGET,PULSE_REGISTER_PATH, PULSE_INTERFACE_NAME, "setSourceVolume");
+    send.appendInteger(handle.handle);
+    send.appendInteger(sourceID);
+    send.appendInteger(volume);
+    send.appendInteger(ramp);
+    send.appendInteger(time);
+    send.sendReply();
+    return (E_OK);
 }
 
 am_Error_e CAmRoutingSenderDbus::asyncSetSourceState(const am_Handle_s handle, const am_sourceID_t sourceID, const am_SourceState_e state)
@@ -105,13 +137,23 @@ am_Error_e CAmRoutingSenderDbus::setDomainState(const am_domainID_t domainID, co
 
 am_Error_e CAmRoutingSenderDbus::startupInterface(IAmRoutingReceive *routingreceiveinterface)
 {
-    (void)routingreceiveinterface;
-    return (E_NOT_USED);
+    log(&routingDbus, DLT_LOG_INFO, "startupInterface called");
+    mRoutingReceiveInterface=routingreceiveinterface;
+    mRoutingReceiverShadow.setRoutingReceiver(mRoutingReceiveInterface);
+    mRoutingReceiveInterface->getDBusConnectionWrapper(mDBusWrapper);
+    //assert(mDBusWrapper!=NULL);
+    mDBusWrapper->getDBusConnection(connection);
+    //assert(connection!=NULL);
+    mDBusMessageHandler.setDBusConnection(connection);
+    return (E_OK);
 }
 
 void CAmRoutingSenderDbus::setRoutingReady(const uint16_t handle)
 {
     (void) handle;
+    log(&routingDbus, DLT_LOG_INFO, "sending systemReady signal");
+    mDBusMessageHandler.initSignal(std::string(ROUTING_NODE),"signal_systemReady");
+    mDBusMessageHandler.sendMessage();
 }
 
 void CAmRoutingSenderDbus::setRoutingRundown(const uint16_t handle)
@@ -127,10 +169,14 @@ am_Error_e CAmRoutingSenderDbus::returnBusName(std::string & BusName) const
 
 am_Error_e CAmRoutingSenderDbus::asyncSetSinkSoundProperty(const am_Handle_s handle, const am_sinkID_t sinkID, const am_SoundProperty_s & soundProperty)
 {
-    (void) handle;
-    (void) sinkID;
-    (void) soundProperty;
-    return (E_NOT_USED);
+    log(&routingDbus, DLT_LOG_INFO, "pulse set sink sound property ");
+    CAmDbusSend send = CAmDbusSend(connection,PULSE_INTERFACE_TARGET,PULSE_REGISTER_PATH, PULSE_INTERFACE_NAME, "setSinkSoundProperty");
+    send.appendInteger(handle.handle);
+    send.appendInteger(soundProperty.type);
+    send.appendInteger(soundProperty.value);
+    send.appendInteger(sinkID);
+    send.sendReply();
+    return (E_OK);
 }
 
 am_Error_e CAmRoutingSenderDbus::asyncSetSinkSoundProperties(const am_Handle_s handle, const am_sinkID_t sinkID, const std::vector<am_SoundProperty_s> & listSoundProperties)
diff --git a/PluginRoutingInterfaceDbus/src/IAmRoutingReceiverShadow.cpp b/PluginRoutingInterfaceDbus/src/IAmRoutingReceiverShadow.cpp
new file mode 100644
index 0000000..d8623cb
--- /dev/null
+++ b/PluginRoutingInterfaceDbus/src/IAmRoutingReceiverShadow.cpp
@@ -0,0 +1,491 @@
+/**
+ *  Copyright (c) copyright 2011-2012 Aricent® Group  and its licensors
+ *
+ *  \author: Sampreeth Ramavana
+ *
+ *  \copyright
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ *  including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+ *  subject to the following conditions:
+ *  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ *  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ *  THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *  For further information see http://www.genivi.org/.
+ */
+
+
+#include <audiomanagertypes.h>
+#include <string.h>
+#include <fstream>
+#include <stdexcept>
+#include <cassert>
+#include "IAmRoutingReceiverShadow.h"
+#include "CAmRoutingSenderDbus.h"
+#include "shared/CAmDltWrapper.h"
+
+using namespace am;
+
+DLT_IMPORT_CONTEXT(routingDbus)
+
+/**
+ * static ObjectPathTable is needed for DBus Callback handling
+ */
+static DBusObjectPathVTable gObjectPathVTable;
+
+IAmRoutingReceiverShadow::IAmRoutingReceiverShadow()
+: 	mRoutingReceiveInterface(NULL),
+  	mDBusWrapper(NULL),
+	mFunctionMap(createMap()),
+  	mDBUSMessageHandler()
+{
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow constructed");
+}
+
+IAmRoutingReceiverShadow::~IAmRoutingReceiverShadow()
+{
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow destructed");
+}
+
+
+void IAmRoutingReceiverShadow::registerDomain(DBusConnection *conn, DBusMessage *msg)
+{
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerDomain called");
+
+        (void) conn;
+        assert(mRoutingReceiveInterface!=NULL);
+
+        mDBUSMessageHandler.initReceive(msg);
+
+        am_Domain_s mDomain;
+        mDomain.domainID = 0;
+
+        char *name = mDBUSMessageHandler.getString();
+        char *nodename = mDBUSMessageHandler.getString();
+        mDomain.early = mDBUSMessageHandler.getBool();
+        mDomain.state = (am_DomainState_e)mDBUSMessageHandler.getInt32();
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerDomain called, name", name,"nodename", nodename,"mDomain.early", mDomain.early, "mDomain.state", mDomain.state );
+
+        mDomain.name = std::string(name);
+        mDomain.nodename = std::string(nodename);
+        mDomain.busname = "pulsePlugin";
+        mDomain.complete = 0; // will be set once hookdomainregistration event is received
+
+	// pass the data to the controller and the database
+        am_Error_e returnCode = mRoutingReceiveInterface->registerDomain(mDomain, mDomain.domainID);
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerDomain domain ID, mDomain.domainID", mDomain.domainID );
+        mDBUSMessageHandler.initReply(msg);
+        mDBUSMessageHandler.append((dbus_uint32_t)mDomain.domainID);
+        mDBUSMessageHandler.sendMessage();
+        if (returnCode != E_OK)
+        {
+            log(&routingDbus, DLT_LOG_INFO, "error registering domain" );
+        }
+}
+
+void IAmRoutingReceiverShadow::registerSource(DBusConnection *conn, DBusMessage *msg)
+{
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::RegisterSource called");
+
+        (void) conn;
+        assert(mRoutingReceiveInterface!=NULL);
+
+        mDBUSMessageHandler.initReceive(msg);
+
+        am_Source_s mSource;
+
+        char *name = mDBUSMessageHandler.getString();
+	mSource.sourceID = 0;
+        mSource.sourceClassID = mDBUSMessageHandler.getInt32();
+        mSource.domainID = mDBUSMessageHandler.getInt32();
+        mSource.sourceState = SS_ON;
+        mSource.listConnectionFormats.push_back(CF_GENIVI_STEREO);
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerSource called, name", name,"mSource.sourceClassID", mSource.sourceClassID,"mSource.domainID", mSource.domainID );
+
+        mSource.name = std::string(name);
+
+        am_Error_e returnCode = mRoutingReceiveInterface->registerSource(mSource, mSource.sourceID);
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registersource,  mSource.sourceID", mSource.sourceID );
+        mDBUSMessageHandler.initReply(msg);
+        mDBUSMessageHandler.append((dbus_uint32_t)mSource.sourceID);
+        mDBUSMessageHandler.sendMessage();
+        if (returnCode != E_OK)
+        {
+            log(&routingDbus, DLT_LOG_INFO, "error registering source" );
+        }
+
+}
+
+void IAmRoutingReceiverShadow::registerSink(DBusConnection *conn, DBusMessage *msg)
+{
+
+        (void) conn;
+        assert(mRoutingReceiveInterface!=NULL);
+
+        mDBUSMessageHandler.initReceive(msg);
+
+        am_Sink_s mSink;
+
+        char *name = mDBUSMessageHandler.getString();
+	mSink.sinkID = 0;
+        mSink.sinkClassID = mDBUSMessageHandler.getInt32();
+        mSink.domainID = mDBUSMessageHandler.getInt32();
+        mSink.muteState = MS_UNMUTED;
+        mSink.listConnectionFormats.push_back(CF_GENIVI_STEREO);
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerSink called, name", name,"mSink.sinkClassID", mSink.sinkClassID,"mSink.domainID", mSink.domainID );
+
+        mSink.name = std::string(name);
+
+        am_Error_e returnCode = mRoutingReceiveInterface->registerSink(mSink, mSink.sinkID);
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registersink, mSink.sinkID", mSink.sinkID );
+        mDBUSMessageHandler.initReply(msg);
+        mDBUSMessageHandler.append((dbus_uint32_t)mSink.sinkID);
+        mDBUSMessageHandler.sendMessage();
+        if (returnCode != E_OK)
+        {
+            log(&routingDbus, DLT_LOG_INFO, "error registering sink" );
+        }
+
+}
+
+void IAmRoutingReceiverShadow::registerGateway(DBusConnection *conn, DBusMessage *msg)
+{
+
+        (void) conn;
+        assert(mRoutingReceiveInterface!=NULL);
+
+        mDBUSMessageHandler.initReceive(msg);
+
+        am_Gateway_s mGateway;
+	mGateway.gatewayID = 0;
+
+        char *name = mDBUSMessageHandler.getString();
+        char *sink = mDBUSMessageHandler.getString();
+        char *source = mDBUSMessageHandler.getString();
+        char *domainsource = mDBUSMessageHandler.getString();
+        char *domainsink = mDBUSMessageHandler.getString();
+        char *controldomain = mDBUSMessageHandler.getString();
+	mGateway.listSinkFormats.push_back(CF_GENIVI_STEREO);
+	mGateway.listSourceFormats.push_back(CF_GENIVI_STEREO);
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerGateway called, name", name,"sink", sink,"source", source );
+        log(&routingDbus, DLT_LOG_INFO, "domainsource", domainsource,"domainsink", domainsink,"controldomain", controldomain );
+
+        mGateway.name = std::string(name);
+        mGateway.sinkID = 101;
+        mGateway.sourceID = 101;
+        mGateway.domainSourceID = 1;
+        mGateway.domainSinkID = 1;
+        mGateway.controlDomainID = 1;
+	mGateway.convertionMatrix.push_back(true);
+
+        am_Error_e returnCode = mRoutingReceiveInterface->registerGateway(mGateway, mGateway.gatewayID);
+        mDBUSMessageHandler.initReply(msg);
+        mDBUSMessageHandler.append((dbus_uint32_t)mGateway.gatewayID);
+        mDBUSMessageHandler.sendMessage();
+        if (returnCode != E_OK)
+        {
+            log(&routingDbus, DLT_LOG_INFO, "error registering gateway" );
+        }
+
+}
+
+void IAmRoutingReceiverShadow::hookDomainRegistrationComplete(DBusConnection *conn, DBusMessage *msg)
+{
+        (void) conn;
+        assert(mRoutingReceiveInterface!=NULL);
+
+        mDBUSMessageHandler.initReceive(msg);
+
+        int domainID = mDBUSMessageHandler.getInt32();
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookDomainRegistrationComplete called, domainID", domainID);
+        mRoutingReceiveInterface->hookDomainRegistrationComplete((am_domainID_t)domainID);
+
+}
+
+void IAmRoutingReceiverShadow::ackConnect(DBusConnection *conn, DBusMessage *msg)
+{
+
+        (void) conn;
+        assert(mRoutingReceiveInterface!=NULL);
+
+        mDBUSMessageHandler.initReceive(msg);
+        int handle = mDBUSMessageHandler.getInt32();
+        int conid = mDBUSMessageHandler.getInt32();
+        int error = mDBUSMessageHandler.getInt32();
+
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackConnect called, handle", handle, "conid", conid, "error", error);
+
+        am_Handle_s myhandle;
+        myhandle.handleType = H_CONNECT;
+        myhandle.handle = handle;
+        am_connectionID_t mconnectionid = (am_connectionID_t)conid;
+        am_Error_e merror = (am_Error_e) error;
+        mRoutingReceiveInterface->ackConnect(myhandle,mconnectionid, merror);
+}
+
+
+
+void IAmRoutingReceiverShadow::ackDisconnect(DBusConnection *conn, DBusMessage *msg)
+{
+
+        (void) conn;
+        assert(mRoutingReceiveInterface!=NULL);
+
+        mDBUSMessageHandler.initReceive(msg);
+
+        int handle = mDBUSMessageHandler.getInt32();
+        int conid = mDBUSMessageHandler.getInt32();
+        int error = mDBUSMessageHandler.getInt32();
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackDisconnect called, handle", handle, "conid", conid, "error", error);
+
+        am_Handle_s myhandle;
+        myhandle.handleType = H_DISCONNECT;
+        myhandle.handle = handle;
+        am_connectionID_t mconnectionid = conid;
+        am_Error_e merror = (am_Error_e) error;
+        mRoutingReceiveInterface->ackDisconnect(myhandle,mconnectionid, merror);
+
+}
+
+void IAmRoutingReceiverShadow::ackSetSinkVolume(DBusConnection *conn, DBusMessage *msg)
+{
+
+        (void) conn;
+        assert(mRoutingReceiveInterface!=NULL);
+
+        mDBUSMessageHandler.initReceive(msg);
+
+        int handle = mDBUSMessageHandler.getInt32();
+        int volume = mDBUSMessageHandler.getInt32();
+        int error = mDBUSMessageHandler.getInt32();
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSinkVolume called, handle", handle, "error", error, "volume", volume);
+
+        am_Handle_s myhandle;
+        myhandle.handleType = H_SETSINKVOLUME;
+        myhandle.handle = handle;
+        am_volume_t mvolume = volume;
+        am_Error_e merror = (am_Error_e) error;
+        mRoutingReceiveInterface->ackSetSinkVolumeChange(myhandle,mvolume, merror);
+
+}
+
+void IAmRoutingReceiverShadow::ackSinkVolumeTick(DBusConnection *conn, DBusMessage *msg)
+{
+
+        (void) conn;
+        assert(mRoutingReceiveInterface!=NULL);
+
+        mDBUSMessageHandler.initReceive(msg);
+
+        int handle = mDBUSMessageHandler.getInt32();
+        int sinkID = mDBUSMessageHandler.getInt32();
+        int volume = mDBUSMessageHandler.getInt32();
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSinkVolumeTick called, handle", handle, "sinkID", sinkID, "volume", volume);
+
+        am_Handle_s myhandle;
+        myhandle.handleType = H_SETSINKVOLUME;
+        myhandle.handle = handle;
+        am_volume_t mvolume = volume;
+        mRoutingReceiveInterface->ackSinkVolumeTick(myhandle,sinkID, mvolume);
+
+}
+
+void IAmRoutingReceiverShadow::ackSourceVolumeTick(DBusConnection *conn, DBusMessage *msg)
+{
+
+        (void) conn;
+        assert(mRoutingReceiveInterface!=NULL);
+
+        mDBUSMessageHandler.initReceive(msg);
+
+        int handle = mDBUSMessageHandler.getInt32();
+        int sourceID = mDBUSMessageHandler.getInt32();
+        int volume = mDBUSMessageHandler.getInt32();
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSourceVolumeTick called, handle", handle, "sourceID", sourceID, "volume", volume);
+
+        am_Handle_s myhandle;
+        myhandle.handleType = H_SETSINKVOLUME;
+        myhandle.handle = handle;
+        am_volume_t mvolume = volume;
+        mRoutingReceiveInterface->ackSourceVolumeTick(myhandle,sourceID, mvolume);
+
+}
+
+void IAmRoutingReceiverShadow::ackSetSourceVolume(DBusConnection *conn, DBusMessage *msg)
+{
+
+        (void) conn;
+        assert(mRoutingReceiveInterface!=NULL);
+
+        mDBUSMessageHandler.initReceive(msg);
+
+        int handle = mDBUSMessageHandler.getInt32();
+        int volume = mDBUSMessageHandler.getInt32();
+        int error = mDBUSMessageHandler.getInt32();
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSourceVolume called, handle", handle, "volume", volume, "error", error);
+
+        am_Handle_s myhandle;
+        myhandle.handleType = H_SETSOURCEVOLUME;
+        myhandle.handle = handle;
+        am_volume_t mvolume = volume;
+        am_Error_e merror = (am_Error_e) error;
+        mRoutingReceiveInterface->ackSetSourceVolumeChange(myhandle,mvolume, merror);
+
+}
+
+void IAmRoutingReceiverShadow::ackSetSinkSoundProperty(DBusConnection *conn, DBusMessage *msg)
+{
+
+        (void) conn;
+        assert(mRoutingReceiveInterface!=NULL);
+
+        mDBUSMessageHandler.initReceive(msg);
+
+        int handle = mDBUSMessageHandler.getInt32();
+        int error = mDBUSMessageHandler.getInt32();
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSinkSoundProperty called, handle", handle, "error", error);
+
+        am_Handle_s myhandle;
+        myhandle.handleType = H_SETSINKSOUNDPROPERTY;
+        myhandle.handle = handle;
+        am_Error_e merror = (am_Error_e) error;
+        mRoutingReceiveInterface->ackSetSinkSoundProperty(myhandle, merror);
+
+}
+
+void IAmRoutingReceiverShadow::ackSetSourceSoundProperty(DBusConnection *conn, DBusMessage *msg)
+{
+        (void) conn;
+        assert(mRoutingReceiveInterface!=NULL);
+
+        mDBUSMessageHandler.initReceive(msg);
+
+        int handle = mDBUSMessageHandler.getInt32();
+        int error = mDBUSMessageHandler.getInt32();
+        log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSourceSoundProperty called, handle", handle, "error", error);
+
+
+        am_Handle_s myhandle;
+        myhandle.handleType = H_SETSOURCESOUNDPROPERTY;
+        myhandle.handle = handle;
+        am_Error_e merror = (am_Error_e) error;
+        mRoutingReceiveInterface->ackSetSourceSoundProperty(myhandle, merror);
+
+}
+
+DBusHandlerResult IAmRoutingReceiverShadow::receiveCallback(DBusConnection *conn, DBusMessage *msg, void *user_data)
+{
+	assert(conn!=NULL);
+	assert(msg!=NULL);
+	assert(user_data!=NULL);
+        IAmRoutingReceiverShadow* reference=(IAmRoutingReceiverShadow*) user_data;
+	return (reference->receiveCallbackDelegate(conn,msg));
+}
+
+void IAmRoutingReceiverShadow::sendIntrospection(DBusConnection *conn, DBusMessage *msg)
+{
+	assert(conn!=NULL);
+	assert(msg!=NULL);
+    DBusMessage* reply;
+    DBusMessageIter args;
+    dbus_uint32_t serial = 0;
+
+    // create a reply from the message
+    reply = dbus_message_new_method_return(msg);
+    //std::ifstream in(ROUTING_XML_FILE);
+    //assert(in!=NULL);
+    std::ifstream in("RoutingReceiver.xml", std::ifstream::in);
+    if (!in)
+    {
+        logError("IAmCommandReceiverShadow::sendIntrospection could not load xml file");
+        throw std::runtime_error("IAmCommandReceiverShadow::sendIntrospection Could not load introspecton XML");
+    }
+    std::string introspect((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+    const char* string = introspect.c_str();
+    log(&routingDbus, DLT_LOG_INFO, introspect.c_str());
+
+    // add the arguments to the reply
+    dbus_message_iter_init_append(reply, &args);
+    if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &string))
+    {
+        log(&routingDbus, DLT_LOG_INFO, "DBUS handler Out Of Memory!");
+    }
+
+    // send the reply && flush the connection
+    if (!dbus_connection_send(conn, reply, &serial))
+    {
+        log(&routingDbus, DLT_LOG_INFO, "DBUS handler Out Of Memory!");
+    }
+    dbus_connection_flush(conn);
+
+    // free the reply
+    dbus_message_unref(reply);
+}
+
+DBusHandlerResult IAmRoutingReceiverShadow::receiveCallbackDelegate(DBusConnection *conn, DBusMessage *msg)
+{
+
+	if (dbus_message_is_method_call(msg, DBUS_INTERFACE_INTROSPECTABLE, "Introspect")) {
+		sendIntrospection(conn,msg);
+		return (DBUS_HANDLER_RESULT_HANDLED);
+	}
+
+	functionMap_t::iterator iter = mFunctionMap.begin();
+	std::string k(dbus_message_get_member(msg));
+        log(&routingDbus, DLT_LOG_INFO, k.c_str());
+        iter=mFunctionMap.find(k);
+    if (iter != mFunctionMap.end())
+    {
+    	std::string p(iter->first);
+    	CallBackMethod cb=iter->second;
+    	(this->*cb)(conn,msg);
+    	return (DBUS_HANDLER_RESULT_HANDLED);
+    }
+
+	return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
+}
+
+void IAmRoutingReceiverShadow::setRoutingReceiver(IAmRoutingReceive*& receiver)
+{
+	assert(receiver!=NULL);
+        mRoutingReceiveInterface=receiver;
+
+        gObjectPathVTable.message_function=IAmRoutingReceiverShadow::receiveCallback;
+
+	DBusConnection* connection;
+        mRoutingReceiveInterface->getDBusConnectionWrapper(mDBusWrapper);
+	assert(mDBusWrapper!=NULL);
+
+	mDBusWrapper->getDBusConnection(connection);
+	assert(connection!=NULL);
+	mDBUSMessageHandler.setDBusConnection(connection);
+
+        std::string path(ROUTING_NODE);
+	mDBusWrapper->registerCallback(&gObjectPathVTable,path,this);
+
+}
+
+IAmRoutingReceiverShadow::functionMap_t IAmRoutingReceiverShadow::createMap()
+{
+	functionMap_t m;
+        m["ackConnect"]=&IAmRoutingReceiverShadow::ackConnect ;
+        m["ackDisconnect"]=&IAmRoutingReceiverShadow::ackDisconnect ;
+        m["ackSetSinkVolume"]=&IAmRoutingReceiverShadow::ackSetSinkVolume ;
+        m["ackSetSourceVolume"]=&IAmRoutingReceiverShadow::ackSetSourceVolume ;
+        m["ackSinkVolumeTick"]=&IAmRoutingReceiverShadow::ackSinkVolumeTick ;
+        m["ackSourceVolumeTick"]=&IAmRoutingReceiverShadow::ackSourceVolumeTick ;
+        m["ackSetSinkSoundProperty"]=&IAmRoutingReceiverShadow::ackSetSinkSoundProperty ;
+        m["ackSetSourceSoundProperty"]=&IAmRoutingReceiverShadow::ackSetSourceSoundProperty ;
+
+        m["registerDomain"]=&IAmRoutingReceiverShadow::registerDomain ;
+        m["registerSource"]=&IAmRoutingReceiverShadow::registerSource ;
+        m["registerSink"]=&IAmRoutingReceiverShadow::registerSink ;
+        m["registerGateway"]=&IAmRoutingReceiverShadow::registerGateway ;
+
+        m["hookDomainRegistrationComplete"]=&IAmRoutingReceiverShadow::hookDomainRegistrationComplete;
+	return (m);
+}
+
+
+