* fix [GAM-28] problems in routingsender.cpp

* [GAM-27] major refactoring: bringing everything to standardized names
* Enhancement of CAmSerializer.h
* improvement of documentation
* adoption & regeneration of inerfaces

16 files changed, 989 insertions, 967 deletions

diff --git a/AudioManagerDaemon/src/CommandReceiver.cpp b/AudioManagerDaemon/src/CAmCommandReceiver.cpp
index 21e19d9..c6f760c 100644
--- a/AudioManagerDaemon/src/CommandReceiver.cpp
+++ b/AudioManagerDaemon/src/CAmCommandReceiver.cpp
@@ -22,17 +22,18 @@
  *
  */
 
-#include "CommandReceiver.h"
-#include "DatabaseHandler.h"
-#include "ControlSender.h"
-#include "DLTWrapper.h"
-#include <SocketHandler.h>
+#include "CAmCommandReceiver.h"
+#include "CAmDatabaseHandler.h"
+#include "CAmControlSender.h"
+#include "shared/CAmDltWrapper.h"
+#include <shared/CAmSocketHandler.h>
 #include <cassert>
 #include <algorithm>
 
-using namespace am;
+namespace am
+{
 
-CommandReceiver::CommandReceiver(DatabaseHandler *iDatabaseHandler, ControlSender *iControlSender, SocketHandler *iSocketHandler) :
+CAmCommandReceiver::CAmCommandReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler) :
         mDatabaseHandler(iDatabaseHandler), //
         mControlSender(iControlSender), //
         mSocketHandler(iSocketHandler), //
@@ -47,7 +48,7 @@ CommandReceiver::CommandReceiver(DatabaseHandler *iDatabaseHandler, ControlSende
     assert(mControlSender!=NULL);
 }
 
-CommandReceiver::CommandReceiver(DatabaseHandler *iDatabaseHandler, ControlSender *iControlSender, SocketHandler *iSocketHandler, DBusWrapper *iDBusWrapper) :
+CAmCommandReceiver::CAmCommandReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper) :
         mDatabaseHandler(iDatabaseHandler), //
         mControlSender(iControlSender), //
         mDBusWrapper(iDBusWrapper), //
@@ -63,105 +64,105 @@ CommandReceiver::CommandReceiver(DatabaseHandler *iDatabaseHandler, ControlSende
     assert(mDBusWrapper!=NULL);
 }
 
-CommandReceiver::~CommandReceiver()
+CAmCommandReceiver::~CAmCommandReceiver()
 {
 }
 
-am_Error_e CommandReceiver::connect(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t & mainConnectionID)
+am_Error_e CAmCommandReceiver::connect(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t & mainConnectionID)
 {
     logInfo("CommandReceiver::connect got called, sourceID=", sourceID, "sinkID=", sinkID);
     return mControlSender->hookUserConnectionRequest(sourceID, sinkID, mainConnectionID);
 }
 
-am_Error_e CommandReceiver::disconnect(const am_mainConnectionID_t mainConnectionID)
+am_Error_e CAmCommandReceiver::disconnect(const am_mainConnectionID_t mainConnectionID)
 {
     logInfo("CommandReceiver::disconnect got called, mainConnectionID=", mainConnectionID);
     return mControlSender->hookUserDisconnectionRequest(mainConnectionID);
 }
 
-am_Error_e CommandReceiver::setVolume(const am_sinkID_t sinkID, const am_mainVolume_t volume)
+am_Error_e CAmCommandReceiver::setVolume(const am_sinkID_t sinkID, const am_mainVolume_t volume)
 {
     logInfo("CommandReceiver::setVolume got called, sinkID=", sinkID, "volume=", volume);
     return mControlSender->hookUserVolumeChange(sinkID, volume);
 }
 
-am_Error_e CommandReceiver::volumeStep(const am_sinkID_t sinkID, const int16_t volumeStep)
+am_Error_e CAmCommandReceiver::volumeStep(const am_sinkID_t sinkID, const int16_t volumeStep)
 {
     logInfo("CommandReceiver::volumeStep got called, sinkID=", sinkID, "volumeStep=", volumeStep);
     return mControlSender->hookUserVolumeStep(sinkID, volumeStep);
 }
 
-am_Error_e CommandReceiver::setSinkMuteState(const am_sinkID_t sinkID, const am_MuteState_e muteState)
+am_Error_e CAmCommandReceiver::setSinkMuteState(const am_sinkID_t sinkID, const am_MuteState_e muteState)
 {
     logInfo("CommandReceiver::setSinkMuteState got called, sinkID=", sinkID, "muteState=", muteState);
     return mControlSender->hookUserSetSinkMuteState(sinkID, muteState);
 }
 
-am_Error_e CommandReceiver::setMainSinkSoundProperty(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID)
+am_Error_e CAmCommandReceiver::setMainSinkSoundProperty(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID)
 {
     logInfo("CommandReceiver::setMainSinkSoundProperty got called, sinkID=", sinkID, "soundPropertyType=", soundProperty.type, "soundPropertyValue=", soundProperty.value);
     return mControlSender->hookUserSetMainSinkSoundProperty(sinkID, soundProperty);
 }
 
-am_Error_e CommandReceiver::setMainSourceSoundProperty(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID)
+am_Error_e CAmCommandReceiver::setMainSourceSoundProperty(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID)
 {
     logInfo("CommandReceiver::setMainSourceSoundProperty got called, sourceID=", sourceID, "soundPropertyType=", soundProperty.type, "soundPropertyValue=", soundProperty.value);
     return mControlSender->hookUserSetMainSourceSoundProperty(sourceID, soundProperty);
 }
 
-am_Error_e CommandReceiver::setSystemProperty(const am_SystemProperty_s & property)
+am_Error_e CAmCommandReceiver::setSystemProperty(const am_SystemProperty_s & property)
 {
     logInfo("CommandReceiver::setSystemProperty got called", "type=", property.type, "soundPropertyValue=", property.value);
     return mControlSender->hookUserSetSystemProperty(property);
 }
 
-am_Error_e CommandReceiver::getListMainConnections(std::vector<am_MainConnectionType_s> & listConnections) const
+am_Error_e CAmCommandReceiver::getListMainConnections(std::vector<am_MainConnectionType_s> & listConnections) const
 {
     return mDatabaseHandler->getListVisibleMainConnections(listConnections);
 
 }
 
-am_Error_e CommandReceiver::getListMainSinks(std::vector<am_SinkType_s>& listMainSinks) const
+am_Error_e CAmCommandReceiver::getListMainSinks(std::vector<am_SinkType_s>& listMainSinks) const
 {
     return mDatabaseHandler->getListMainSinks(listMainSinks);
 }
 
-am_Error_e CommandReceiver::getListMainSources(std::vector<am_SourceType_s>& listMainSources) const
+am_Error_e CAmCommandReceiver::getListMainSources(std::vector<am_SourceType_s>& listMainSources) const
 {
     return mDatabaseHandler->getListMainSources(listMainSources);
 }
 
-am_Error_e CommandReceiver::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_MainSoundProperty_s> & listSoundProperties) const
+am_Error_e CAmCommandReceiver::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_MainSoundProperty_s> & listSoundProperties) const
 {
     return mDatabaseHandler->getListMainSinkSoundProperties(sinkID, listSoundProperties);
 }
 
-am_Error_e CommandReceiver::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_MainSoundProperty_s> & listSourceProperties) const
+am_Error_e CAmCommandReceiver::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_MainSoundProperty_s> & listSourceProperties) const
 {
     return mDatabaseHandler->getListMainSourceSoundProperties(sourceID, listSourceProperties);
 }
 
-am_Error_e CommandReceiver::getListSourceClasses(std::vector<am_SourceClass_s> & listSourceClasses) const
+am_Error_e CAmCommandReceiver::getListSourceClasses(std::vector<am_SourceClass_s> & listSourceClasses) const
 {
     return mDatabaseHandler->getListSourceClasses(listSourceClasses);
 }
 
-am_Error_e CommandReceiver::getListSinkClasses(std::vector<am_SinkClass_s> & listSinkClasses) const
+am_Error_e CAmCommandReceiver::getListSinkClasses(std::vector<am_SinkClass_s> & listSinkClasses) const
 {
     return mDatabaseHandler->getListSinkClasses(listSinkClasses);
 }
 
-am_Error_e CommandReceiver::getListSystemProperties(std::vector<am_SystemProperty_s> & listSystemProperties) const
+am_Error_e CAmCommandReceiver::getListSystemProperties(std::vector<am_SystemProperty_s> & listSystemProperties) const
 {
     return mDatabaseHandler->getListSystemProperties(listSystemProperties);
 }
 
-am_Error_e CommandReceiver::getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t & delay) const
+am_Error_e CAmCommandReceiver::getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t & delay) const
 {
     return mDatabaseHandler->getTimingInformation(mainConnectionID, delay);
 }
 
-am_Error_e CommandReceiver::getDBusConnectionWrapper(DBusWrapper*& dbusConnectionWrapper) const
+am_Error_e CAmCommandReceiver::getDBusConnectionWrapper(CAmDbusWrapper*& dbusConnectionWrapper) const
 {
 #ifdef WITH_DBUS_WRAPPER
     dbusConnectionWrapper = mDBusWrapper;
@@ -171,52 +172,53 @@ am_Error_e CommandReceiver::getDBusConnectionWrapper(DBusWrapper*& dbusConnectio
 #endif /*WITH_DBUS_WRAPPER*/
 }
 
-am_Error_e CommandReceiver::getSocketHandler(SocketHandler *& socketHandler) const
+am_Error_e CAmCommandReceiver::getSocketHandler(CAmSocketHandler *& socketHandler) const
 {
     socketHandler = mSocketHandler;
     return E_OK;
 }
 
-void CommandReceiver::getInterfaceVersion(std::string & version) const
+void CAmCommandReceiver::getInterfaceVersion(std::string & version) const
 {
     version = CommandReceiveVersion;
 }
 
-void CommandReceiver::confirmCommandReady(const uint16_t handle)
+void CAmCommandReceiver::confirmCommandReady(const uint16_t handle)
 {
     mListStartupHandles.erase(std::remove(mListStartupHandles.begin(), mListStartupHandles.end(), handle), mListStartupHandles.end());
     if (mWaitStartup && mListStartupHandles.empty())
         mControlSender->confirmCommandReady();
 }
 
-void CommandReceiver::confirmCommandRundown(const uint16_t handle)
+void CAmCommandReceiver::confirmCommandRundown(const uint16_t handle)
 {
     mListRundownHandles.erase(std::remove(mListRundownHandles.begin(), mListRundownHandles.end(), handle), mListRundownHandles.end());
     if (mWaitRundown && mListRundownHandles.empty())
         mControlSender->confirmCommandRundown();
 }
 
-uint16_t CommandReceiver::getStartupHandle()
+uint16_t CAmCommandReceiver::getStartupHandle()
 {
     uint16_t handle = ++handleCount; //todo: handle overflow
     mListStartupHandles.push_back(handle);
     return handle;
 }
 
-uint16_t CommandReceiver::getRundownHandle()
+uint16_t CAmCommandReceiver::getRundownHandle()
 {
     uint16_t handle = ++handleCount; //todo: handle overflow
     mListRundownHandles.push_back(handle);
     return handle;
 }
 
-void CommandReceiver::waitOnStartup(bool startup)
+void CAmCommandReceiver::waitOnStartup(bool startup)
 {
     mWaitStartup = startup;
 }
 
-void CommandReceiver::waitOnRundown(bool rundown)
+void CAmCommandReceiver::waitOnRundown(bool rundown)
 {
     mWaitRundown = rundown;
 }
 
+}
diff --git a/AudioManagerDaemon/src/CommandSender.cpp b/AudioManagerDaemon/src/CAmCommandSender.cpp
index c613a4e..0ada15c 100644
--- a/AudioManagerDaemon/src/CommandSender.cpp
+++ b/AudioManagerDaemon/src/CAmCommandSender.cpp
@@ -3,7 +3,7 @@
  *
  * GeniviAudioMananger AudioManagerDaemon
  *
- * \file CommandSender.cpp
+ * \file CAmCommandSender.cpp
  *
  * \date 20-Oct-2011 3:42:04 PM
  * \author Christian Mueller (christian.ei.mueller@bmw.de)
@@ -22,29 +22,30 @@
  *
  */
 
-#include "CommandSender.h"
+#include "CAmCommandSender.h"
 #include <dirent.h>
 #include <sstream>
 #include <string>
-#include "CommandReceiver.h"
-#include "PluginTemplate.h"
-#include "DLTWrapper.h"
+#include "CAmCommandReceiver.h"
+#include "TAmPluginTemplate.h"
+#include "shared/CAmDltWrapper.h"
 
-using namespace am;
+namespace am
+{
 
 #define REQUIRED_INTERFACE_VERSION_MAJOR 1
 #define REQUIRED_INTERFACE_VERSION_MINOR 0
 
 //!< macro to call all interfaces
 #define CALL_ALL_INTERFACES(...) 														 \
-		std::vector<CommandSendInterface*>::iterator iter = mListInterfaces.begin();	 \
-		std::vector<CommandSendInterface*>::iterator iterEnd = mListInterfaces.end();	 \
+		std::vector<IAmCommandSend*>::iterator iter = mListInterfaces.begin();	 \
+		std::vector<IAmCommandSend*>::iterator iterEnd = mListInterfaces.end();	 \
 		for (; iter<iterEnd;++iter)													 	 \
 		{																				 \
 			(*iter)->__VA_ARGS__;													 	 \
 		}
 
-CommandSender::CommandSender(const std::vector<std::string>& listOfPluginDirectories) :
+CAmCommandSender::CAmCommandSender(const std::vector<std::string>& listOfPluginDirectories) :
         mListInterfaces(), //
         mListLibraryHandles(), //
         mListLibraryNames(), //
@@ -93,9 +94,9 @@ CommandSender::CommandSender(const std::vector<std::string>& listOfPluginDirecto
     for (; iter < iterEnd; ++iter)
     {
         logInfo("Loading CommandSender plugin", *iter);
-        CommandSendInterface* (*createFunc)();
+        IAmCommandSend* (*createFunc)();
         void* tempLibHandle = NULL;
-        createFunc = getCreateFunction<CommandSendInterface*()>(*iter, tempLibHandle);
+        createFunc = getCreateFunction<IAmCommandSend*()>(*iter, tempLibHandle);
 
         if (!createFunc)
         {
@@ -103,7 +104,7 @@ CommandSender::CommandSender(const std::vector<std::string>& listOfPluginDirecto
             continue;
         }
 
-        CommandSendInterface* commander = createFunc();
+        IAmCommandSend* commander = createFunc();
 
         if (!commander)
         {
@@ -130,18 +131,18 @@ CommandSender::CommandSender(const std::vector<std::string>& listOfPluginDirecto
     }
 }
 
-CommandSender::~CommandSender()
+CAmCommandSender::~CAmCommandSender()
 {
     unloadLibraries();
 }
 
-am_Error_e CommandSender::startupInterfaces(CommandReceiver *iCommandReceiver)
+am_Error_e CAmCommandSender::startupInterfaces(CAmCommandReceiver *iCommandReceiver)
 {
     mCommandReceiver = iCommandReceiver;
     am_Error_e returnError = E_OK;
 
-    std::vector<CommandSendInterface*>::iterator iter = mListInterfaces.begin();
-    std::vector<CommandSendInterface*>::iterator iterEnd = mListInterfaces.end();
+    std::vector<IAmCommandSend*>::iterator iter = mListInterfaces.begin();
+    std::vector<IAmCommandSend*>::iterator iterEnd = mListInterfaces.end();
     for (; iter < iterEnd; ++iter)
     {
         am_Error_e error = (*iter)->startupInterface(iCommandReceiver);
@@ -153,96 +154,96 @@ am_Error_e CommandSender::startupInterfaces(CommandReceiver *iCommandReceiver)
     return returnError;
 }
 
-void CommandSender::cbNumberOfSinkClassesChanged()
+void CAmCommandSender::cbNumberOfSinkClassesChanged()
 {
     CALL_ALL_INTERFACES(cbNumberOfSinkClassesChanged())
 }
 
-void CommandSender::cbNumberOfSourceClassesChanged()
+void CAmCommandSender::cbNumberOfSourceClassesChanged()
 {
     CALL_ALL_INTERFACES(cbNumberOfSourceClassesChanged())
 }
 
-void CommandSender::cbMainConnectionStateChanged(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState)
+void CAmCommandSender::cbMainConnectionStateChanged(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState)
 {
     CALL_ALL_INTERFACES(cbMainConnectionStateChanged(connectionID,connectionState))
 }
 
-void CommandSender::cbMainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty)
+void CAmCommandSender::cbMainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty)
 {
     CALL_ALL_INTERFACES(cbMainSinkSoundPropertyChanged(sinkID,SoundProperty))
 }
 
-void CommandSender::cbMainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s& SoundProperty)
+void CAmCommandSender::cbMainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s& SoundProperty)
 {
     CALL_ALL_INTERFACES(cbMainSourceSoundPropertyChanged(sourceID,SoundProperty))
 }
 
-void CommandSender::cbSinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s & availability)
+void CAmCommandSender::cbSinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s & availability)
 {
     CALL_ALL_INTERFACES(cbSinkAvailabilityChanged(sinkID,availability))
 }
 
-void CommandSender::cbSourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s & availability)
+void CAmCommandSender::cbSourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s & availability)
 {
     CALL_ALL_INTERFACES(cbSourceAvailabilityChanged(sourceID,availability))
 }
 
-void CommandSender::cbVolumeChanged(const am_sinkID_t sinkID, const am_mainVolume_t volume)
+void CAmCommandSender::cbVolumeChanged(const am_sinkID_t sinkID, const am_mainVolume_t volume)
 {
     CALL_ALL_INTERFACES(cbVolumeChanged(sinkID,volume))
 }
 
-void CommandSender::cbSinkMuteStateChanged(const am_sinkID_t sinkID, const am_MuteState_e muteState)
+void CAmCommandSender::cbSinkMuteStateChanged(const am_sinkID_t sinkID, const am_MuteState_e muteState)
 {
     CALL_ALL_INTERFACES(cbSinkMuteStateChanged(sinkID,muteState))
 }
 
-void CommandSender::cbSystemPropertyChanged(const am_SystemProperty_s & SystemProperty)
+void CAmCommandSender::cbSystemPropertyChanged(const am_SystemProperty_s & SystemProperty)
 {
     CALL_ALL_INTERFACES(cbSystemPropertyChanged(SystemProperty))
 }
 
-void CommandSender::cbTimingInformationChanged(const am_mainConnectionID_t mainConnection, const am_timeSync_t time)
+void CAmCommandSender::cbTimingInformationChanged(const am_mainConnectionID_t mainConnection, const am_timeSync_t time)
 {
     CALL_ALL_INTERFACES(cbTimingInformationChanged(mainConnection,time))
 }
 
-void CommandSender::cbNewMainConnection(const am_MainConnectionType_s mainConnection)
+void CAmCommandSender::cbNewMainConnection(const am_MainConnectionType_s mainConnection)
 {
     CALL_ALL_INTERFACES(cbNewMainConnection(mainConnection))
 }
 
-void CommandSender::cbRemovedMainConnection(const am_mainConnectionID_t mainConnection)
+void CAmCommandSender::cbRemovedMainConnection(const am_mainConnectionID_t mainConnection)
 {
     CALL_ALL_INTERFACES(cbRemovedMainConnection(mainConnection))
 }
 
-void CommandSender::cbNewSink(const am_SinkType_s sink)
+void CAmCommandSender::cbNewSink(const am_SinkType_s sink)
 {
     CALL_ALL_INTERFACES(cbNewSink(sink))
 }
 
-void CommandSender::cbRemovedSink(const am_sinkID_t sink)
+void CAmCommandSender::cbRemovedSink(const am_sinkID_t sink)
 {
     CALL_ALL_INTERFACES(cbRemovedSink(sink))
 }
 
-void CommandSender::cbNewSource(const am_SourceType_s source)
+void CAmCommandSender::cbNewSource(const am_SourceType_s source)
 {
     CALL_ALL_INTERFACES(cbNewSource(source))
 }
 
-void CommandSender::cbRemovedSource(const am_sourceID_t source)
+void CAmCommandSender::cbRemovedSource(const am_sourceID_t source)
 {
     CALL_ALL_INTERFACES(cbRemovedSource(source))
 }
 
-void CommandSender::setCommandReady()
+void CAmCommandSender::setCommandReady()
 {
     mCommandReceiver->waitOnStartup(false);
-    std::vector<CommandSendInterface*>::iterator iter = mListInterfaces.begin();
-    std::vector<CommandSendInterface*>::iterator iterEnd = mListInterfaces.end();
+    std::vector<IAmCommandSend*>::iterator iter = mListInterfaces.begin();
+    std::vector<IAmCommandSend*>::iterator iterEnd = mListInterfaces.end();
     for (; iter < iterEnd; ++iter)
     {
         (*iter)->setCommandReady(mCommandReceiver->getStartupHandle());
@@ -250,11 +251,11 @@ void CommandSender::setCommandReady()
     mCommandReceiver->waitOnStartup(true);
 }
 
-void CommandSender::setCommandRundown()
+void CAmCommandSender::setCommandRundown()
 {
     mCommandReceiver->waitOnRundown(false);
-    std::vector<CommandSendInterface*>::iterator iter = mListInterfaces.begin();
-    std::vector<CommandSendInterface*>::iterator iterEnd = mListInterfaces.end();
+    std::vector<IAmCommandSend*>::iterator iter = mListInterfaces.begin();
+    std::vector<IAmCommandSend*>::iterator iterEnd = mListInterfaces.end();
     for (; iter < iterEnd; ++iter)
     {
         (*iter)->setCommandRundown(mCommandReceiver->getRundownHandle());
@@ -262,18 +263,18 @@ void CommandSender::setCommandRundown()
     mCommandReceiver->waitOnRundown(true);
 }
 
-void CommandSender::getInterfaceVersion(std::string & version) const
+void CAmCommandSender::getInterfaceVersion(std::string & version) const
 {
     version = CommandSendVersion;
 }
 
-am_Error_e am::CommandSender::getListPlugins(std::vector<std::string> & interfaces) const
+am_Error_e am::CAmCommandSender::getListPlugins(std::vector<std::string> & interfaces) const
 {
     interfaces = mListLibraryNames;
     return E_OK;
 }
 
-void CommandSender::unloadLibraries(void)
+void CAmCommandSender::unloadLibraries(void)
 {
     std::vector<void*>::iterator iterator = mListLibraryHandles.begin();
     for (; iterator < mListLibraryHandles.end(); ++iterator)
@@ -282,4 +283,4 @@ void CommandSender::unloadLibraries(void)
     }
     mListLibraryHandles.clear();
 }
-
+}
diff --git a/AudioManagerDaemon/src/ControlReceiver.cpp b/AudioManagerDaemon/src/CAmControlReceiver.cpp
index 8ef8d23..6d68089 100644
--- a/AudioManagerDaemon/src/ControlReceiver.cpp
+++ b/AudioManagerDaemon/src/CAmControlReceiver.cpp
@@ -3,7 +3,7 @@
  *
  * GeniviAudioMananger AudioManagerDaemon
  *
- * \file ControlReceiver.cpp
+ * \file CAmControlReceiver.cpp
  *
  * \date 20-Oct-2011 3:42:04 PM
  * \author Christian Mueller (christian.ei.mueller@bmw.de)
@@ -23,18 +23,18 @@
  */
 
 #include <config.h>
-#include <SocketHandler.h>
-#include "ControlReceiver.h"
-#include "DatabaseHandler.h"
-#include "RoutingSender.h"
-#include "CommandSender.h"
-#include "Router.h"
-#include "DLTWrapper.h"
+#include <shared/CAmSocketHandler.h>
+#include "CAmControlReceiver.h"
+#include "CAmDatabaseHandler.h"
+#include "CAmRoutingSender.h"
+#include "CAmCommandSender.h"
+#include "CAmRouter.h"
+#include "shared/CAmDltWrapper.h"
 #include <cassert>
 
-using namespace am;
+namespace am {
 
-ControlReceiver::ControlReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, CommandSender *iCommandSender, SocketHandler *iSocketHandler, Router* iRouter) :
+CAmControlReceiver::CAmControlReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmCommandSender *iCommandSender, CAmSocketHandler *iSocketHandler, CAmRouter* iRouter) :
         mDatabaseHandler(iDatabaseHandler), //
         mRoutingSender(iRoutingSender), //
         mCommandSender(iCommandSender), //
@@ -48,18 +48,18 @@ ControlReceiver::ControlReceiver(DatabaseHandler *iDatabaseHandler, RoutingSende
     assert(mRouter!=NULL);
 }
 
-ControlReceiver::~ControlReceiver()
+CAmControlReceiver::~CAmControlReceiver()
 {
 }
 
-am_Error_e ControlReceiver::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s> & returnList)
+am_Error_e CAmControlReceiver::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s> & returnList)
 {
     return mRouter->getRoute(onlyfree, sourceID, sinkID, returnList);
 }
 
-am_Error_e ControlReceiver::connect(am_Handle_s & handle, am_connectionID_t & connectionID, const am_ConnectionFormat_e format, const am_sourceID_t sourceID, const am_sinkID_t sinkID)
+am_Error_e CAmControlReceiver::connect(am_Handle_s & handle, am_connectionID_t & connectionID, const am_ConnectionFormat_e format, const am_sourceID_t sourceID, const am_sinkID_t sinkID)
 {
-    logInfo("ControlReceiver::connect got called, connectionFormat=", format, "sourceID=", sourceID, "sinkID=", sinkID);
+    logInfo("CAmControlReceiver::connect got called, connectionFormat=", format, "sourceID=", sourceID, "sinkID=", sinkID);
 
     am_Connection_s tempConnection;
     tempConnection.sinkID = sinkID;
@@ -75,27 +75,27 @@ am_Error_e ControlReceiver::connect(am_Handle_s & handle, am_connectionID_t & co
     return mRoutingSender->asyncConnect(handle, connectionID, sourceID, sinkID, format);
 }
 
-am_Error_e ControlReceiver::disconnect(am_Handle_s & handle, const am_connectionID_t connectionID)
+am_Error_e CAmControlReceiver::disconnect(am_Handle_s & handle, const am_connectionID_t connectionID)
 {
-    logInfo("ControlReceiver::disconnect got called, connectionID=", connectionID);
+    logInfo("CAmControlReceiver::disconnect got called, connectionID=", connectionID);
 
     if (!mDatabaseHandler->existConnectionID(connectionID))
         return E_NON_EXISTENT; //todo: check with EA model and correct
     return mRoutingSender->asyncDisconnect(handle, connectionID);
 }
 
-am_Error_e ControlReceiver::crossfade(am_Handle_s & handle, const am_HotSink_e hotSource, const am_crossfaderID_t crossfaderID, const am_RampType_e rampType, const am_time_t rampTime)
+am_Error_e CAmControlReceiver::crossfade(am_Handle_s & handle, const am_HotSink_e hotSource, const am_crossfaderID_t crossfaderID, const am_RampType_e rampType, const am_time_t rampTime)
 {
-    logInfo("ControlReceiver::crossfade got called, hotSource=", hotSource, "crossfaderID=", crossfaderID, "rampType=", rampType, "rampTime=", rampTime);
+    logInfo("CAmControlReceiver::crossfade got called, hotSource=", hotSource, "crossfaderID=", crossfaderID, "rampType=", rampType, "rampTime=", rampTime);
 
     if (!mDatabaseHandler->existcrossFader(crossfaderID))
         return E_NON_EXISTENT;
     return mRoutingSender->asyncCrossFade(handle, crossfaderID, hotSource, rampType, rampTime);
 }
 
-am_Error_e ControlReceiver::setSourceState(am_Handle_s & handle, const am_sourceID_t sourceID, const am_SourceState_e state)
+am_Error_e CAmControlReceiver::setSourceState(am_Handle_s & handle, const am_sourceID_t sourceID, const am_SourceState_e state)
 {
-    logInfo("ControlReceiver::setSourceState got called, sourceID=", sourceID, "state=", state);
+    logInfo("CAmControlReceiver::setSourceState got called, sourceID=", sourceID, "state=", state);
 
     am_SourceState_e sourceState;
     if (mDatabaseHandler->getSoureState(sourceID, sourceState) != E_OK)
@@ -105,9 +105,9 @@ am_Error_e ControlReceiver::setSourceState(am_Handle_s & handle, const am_source
     return mRoutingSender->asyncSetSourceState(handle, sourceID, state);
 }
 
-am_Error_e ControlReceiver::setSinkVolume(am_Handle_s & handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time)
+am_Error_e CAmControlReceiver::setSinkVolume(am_Handle_s & handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time)
 {
-    logInfo("ControlReceiver::setSinkVolume got called, sinkID=", sinkID, "volume=", volume, "ramp=", ramp, "time=", time);
+    logInfo("CAmControlReceiver::setSinkVolume got called, sinkID=", sinkID, "volume=", volume, "ramp=", ramp, "time=", time);
 
     am_volume_t tempVolume;
     if (mDatabaseHandler->getSinkVolume(sinkID, tempVolume) != E_OK)
@@ -117,9 +117,9 @@ am_Error_e ControlReceiver::setSinkVolume(am_Handle_s & handle, const am_sinkID_
     return mRoutingSender->asyncSetSinkVolume(handle, sinkID, volume, ramp, time);
 }
 
-am_Error_e ControlReceiver::setSourceVolume(am_Handle_s & handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_RampType_e rampType, const am_time_t time)
+am_Error_e CAmControlReceiver::setSourceVolume(am_Handle_s & handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_RampType_e rampType, const am_time_t time)
 {
-    logInfo("ControlReceiver::setSourceVolume got called, sourceID=", sourceID, "volume=", volume, "ramp=", rampType, "time=", time);
+    logInfo("CAmControlReceiver::setSourceVolume got called, sourceID=", sourceID, "volume=", volume, "ramp=", rampType, "time=", time);
 
     am_volume_t tempVolume;
     if (mDatabaseHandler->getSourceVolume(sourceID, tempVolume) != E_OK)
@@ -129,9 +129,9 @@ am_Error_e ControlReceiver::setSourceVolume(am_Handle_s & handle, const am_sourc
     return mRoutingSender->asyncSetSourceVolume(handle, sourceID, volume, rampType, time);
 }
 
-am_Error_e ControlReceiver::setSinkSoundProperty(am_Handle_s & handle, const am_sinkID_t sinkID, const am_SoundProperty_s & soundProperty)
+am_Error_e CAmControlReceiver::setSinkSoundProperty(am_Handle_s & handle, const am_sinkID_t sinkID, const am_SoundProperty_s & soundProperty)
 {
-    logInfo("ControlReceiver::setSinkSoundProperty got called, sinkID=", sinkID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value);
+    logInfo("CAmControlReceiver::setSinkSoundProperty got called, sinkID=", sinkID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value);
 
     uint16_t value;
     if (mDatabaseHandler->getSinkSoundPropertyValue(sinkID, soundProperty.type, value) != E_OK)
@@ -141,9 +141,9 @@ am_Error_e ControlReceiver::setSinkSoundProperty(am_Handle_s & handle, const am_
     return mRoutingSender->asyncSetSinkSoundProperty(handle, sinkID, soundProperty);
 }
 
-am_Error_e ControlReceiver::setSinkSoundProperties(am_Handle_s & handle, const am_sinkID_t sinkID, const std::vector<am_SoundProperty_s> & listSoundProperties)
+am_Error_e CAmControlReceiver::setSinkSoundProperties(am_Handle_s & handle, const am_sinkID_t sinkID, const std::vector<am_SoundProperty_s> & listSoundProperties)
 {
-    logInfo("ControlReceiver::setSinkSoundProperties got called, sinkID=", sinkID);
+    logInfo("CAmControlReceiver::setSinkSoundProperties got called, sinkID=", sinkID);
 
     uint16_t value;
     bool noChange = true;
@@ -160,9 +160,9 @@ am_Error_e ControlReceiver::setSinkSoundProperties(am_Handle_s & handle, const a
     return (mRoutingSender->asyncSetSinkSoundProperties(handle, listSoundProperties, sinkID));
 }
 
-am_Error_e ControlReceiver::setSourceSoundProperty(am_Handle_s & handle, const am_sourceID_t sourceID, const am_SoundProperty_s & soundProperty)
+am_Error_e CAmControlReceiver::setSourceSoundProperty(am_Handle_s & handle, const am_sourceID_t sourceID, const am_SoundProperty_s & soundProperty)
 {
-    logInfo("ControlReceiver::setSourceSoundProperty got called, sourceID=", sourceID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value);
+    logInfo("CAmControlReceiver::setSourceSoundProperty got called, sourceID=", sourceID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value);
 
     uint16_t value;
     if (mDatabaseHandler->getSourceSoundPropertyValue(sourceID, soundProperty.type, value) != E_OK)
@@ -172,9 +172,9 @@ am_Error_e ControlReceiver::setSourceSoundProperty(am_Handle_s & handle, const a
     return mRoutingSender->asyncSetSourceSoundProperty(handle, sourceID, soundProperty);
 }
 
-am_Error_e ControlReceiver::setSourceSoundProperties(am_Handle_s & handle, const am_sourceID_t sourceID, const std::vector<am_SoundProperty_s> & listSoundProperties)
+am_Error_e CAmControlReceiver::setSourceSoundProperties(am_Handle_s & handle, const am_sourceID_t sourceID, const std::vector<am_SoundProperty_s> & listSoundProperties)
 {
-    logInfo("ControlReceiver::setSourceSoundProperties got called, sourceID=", sourceID);
+    logInfo("CAmControlReceiver::setSourceSoundProperties got called, sourceID=", sourceID);
 
     uint16_t value;
     bool noChange = true;
@@ -191,9 +191,9 @@ am_Error_e ControlReceiver::setSourceSoundProperties(am_Handle_s & handle, const
     return (mRoutingSender->asyncSetSourceSoundProperties(handle, listSoundProperties, sourceID));
 }
 
-am_Error_e ControlReceiver::setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState)
+am_Error_e CAmControlReceiver::setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState)
 {
-    logInfo("ControlReceiver::setDomainState got called, domainID=", domainID, "domainState=", domainState);
+    logInfo("CAmControlReceiver::setDomainState got called, domainID=", domainID, "domainState=", domainState);
 
     am_DomainState_e tempState = DS_UNKNOWN;
     if (mDatabaseHandler->getDomainState(domainID, tempState) != E_OK)
@@ -203,312 +203,311 @@ am_Error_e ControlReceiver::setDomainState(const am_domainID_t domainID, const a
     return mRoutingSender->setDomainState(domainID, domainState);
 }
 
-am_Error_e ControlReceiver::abortAction(const am_Handle_s handle)
+am_Error_e CAmControlReceiver::abortAction(const am_Handle_s handle)
 {
-    logInfo("ControlReceiver::abortAction got called, handle.type=", handle.handle, "handle.handleType=", handle.handleType);
+    logInfo("CAmControlReceiver::abortAction got called, handle.type=", handle.handle, "handle.handleType=", handle.handleType);
 
     return mRoutingSender->asyncAbort(handle);
 }
 
-am_Error_e ControlReceiver::enterDomainDB(const am_Domain_s & domainData, am_domainID_t & domainID)
+am_Error_e CAmControlReceiver::enterDomainDB(const am_Domain_s & domainData, am_domainID_t & domainID)
 {
     return mDatabaseHandler->enterDomainDB(domainData, domainID);
 }
 
-am_Error_e ControlReceiver::enterMainConnectionDB(const am_MainConnection_s & mainConnectionData, am_mainConnectionID_t & connectionID)
+am_Error_e CAmControlReceiver::enterMainConnectionDB(const am_MainConnection_s & mainConnectionData, am_mainConnectionID_t & connectionID)
 {
     return mDatabaseHandler->enterMainConnectionDB(mainConnectionData, connectionID);
 }
 
-am_Error_e ControlReceiver::enterSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
+am_Error_e CAmControlReceiver::enterSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
 {
     return mDatabaseHandler->enterSinkDB(sinkData, sinkID);
 }
 
-am_Error_e ControlReceiver::enterCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
+am_Error_e CAmControlReceiver::enterCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
 {
     return mDatabaseHandler->enterCrossfaderDB(crossfaderData, crossfaderID);
 }
 
-am_Error_e ControlReceiver::enterGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
+am_Error_e CAmControlReceiver::enterGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
 {
     return mDatabaseHandler->enterGatewayDB(gatewayData, gatewayID);
 }
 
-am_Error_e ControlReceiver::enterSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID)
+am_Error_e CAmControlReceiver::enterSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID)
 {
     return mDatabaseHandler->enterSourceDB(sourceData, sourceID);
 }
 
-am_Error_e ControlReceiver::enterSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID)
+am_Error_e CAmControlReceiver::enterSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID)
 {
     return mDatabaseHandler->enterSinkClassDB(sinkClass, sinkClassID);
 }
 
-am_Error_e ControlReceiver::enterSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass)
+am_Error_e CAmControlReceiver::enterSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass)
 {
     return mDatabaseHandler->enterSourceClassDB(sourceClassID, sourceClass);
 }
 
-am_Error_e ControlReceiver::enterSystemPropertiesListDB(const std::vector<am_SystemProperty_s> & listSystemProperties)
+am_Error_e CAmControlReceiver::enterSystemPropertiesListDB(const std::vector<am_SystemProperty_s> & listSystemProperties)
 {
     return mDatabaseHandler->enterSystemProperties(listSystemProperties);
 }
 
-am_Error_e ControlReceiver::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector<am_connectionID_t>& listConnectionID)
+am_Error_e CAmControlReceiver::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector<am_connectionID_t>& listConnectionID)
 {
     return mDatabaseHandler->changeMainConnectionRouteDB(mainconnectionID, listConnectionID);
 }
 
-am_Error_e ControlReceiver::changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState)
+am_Error_e CAmControlReceiver::changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState)
 {
     return mDatabaseHandler->changeMainConnectionStateDB(mainconnectionID, connectionState);
 }
 
-am_Error_e ControlReceiver::changeSinkMainVolumeDB(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID)
+am_Error_e CAmControlReceiver::changeSinkMainVolumeDB(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID)
 {
     return mDatabaseHandler->changeSinkMainVolumeDB(mainVolume, sinkID);
 }
 
-am_Error_e ControlReceiver::changeSinkAvailabilityDB(const am_Availability_s & availability, const am_sinkID_t sinkID)
+am_Error_e CAmControlReceiver::changeSinkAvailabilityDB(const am_Availability_s & availability, const am_sinkID_t sinkID)
 {
     return mDatabaseHandler->changeSinkAvailabilityDB(availability, sinkID);
 }
 
-am_Error_e ControlReceiver::changDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID)
+am_Error_e CAmControlReceiver::changDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID)
 {
     return mDatabaseHandler->changDomainStateDB(domainState, domainID);
 }
 
-am_Error_e ControlReceiver::changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID)
+am_Error_e CAmControlReceiver::changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID)
 {
     return mDatabaseHandler->changeSinkMuteStateDB(muteState, sinkID);
 }
 
-am_Error_e ControlReceiver::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID)
+am_Error_e CAmControlReceiver::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID)
 {
     return mDatabaseHandler->changeMainSinkSoundPropertyDB(soundProperty, sinkID);
 }
 
-am_Error_e ControlReceiver::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID)
+am_Error_e CAmControlReceiver::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID)
 {
     return mDatabaseHandler->changeMainSinkSoundPropertyDB(soundProperty, sourceID);
 }
 
-am_Error_e ControlReceiver::changeSourceAvailabilityDB(const am_Availability_s & availability, const am_sourceID_t sourceID)
+am_Error_e CAmControlReceiver::changeSourceAvailabilityDB(const am_Availability_s & availability, const am_sourceID_t sourceID)
 {
     return mDatabaseHandler->changeSourceAvailabilityDB(availability, sourceID);
 }
 
-am_Error_e ControlReceiver::changeSystemPropertyDB(const am_SystemProperty_s & property)
+am_Error_e CAmControlReceiver::changeSystemPropertyDB(const am_SystemProperty_s & property)
 {
     return mDatabaseHandler->changeSystemPropertyDB(property);
 }
 
-am_Error_e ControlReceiver::removeMainConnectionDB(const am_mainConnectionID_t mainConnectionID)
+am_Error_e CAmControlReceiver::removeMainConnectionDB(const am_mainConnectionID_t mainConnectionID)
 {
     return mDatabaseHandler->removeMainConnectionDB(mainConnectionID);
 }
 
-am_Error_e ControlReceiver::removeSinkDB(const am_sinkID_t sinkID)
+am_Error_e CAmControlReceiver::removeSinkDB(const am_sinkID_t sinkID)
 {
     return mDatabaseHandler->removeSinkDB(sinkID);
 }
 
-am_Error_e ControlReceiver::removeSourceDB(const am_sourceID_t sourceID)
+am_Error_e CAmControlReceiver::removeSourceDB(const am_sourceID_t sourceID)
 {
     return mDatabaseHandler->removeSourceDB(sourceID);
 }
 
-am_Error_e ControlReceiver::removeGatewayDB(const am_gatewayID_t gatewayID)
+am_Error_e CAmControlReceiver::removeGatewayDB(const am_gatewayID_t gatewayID)
 {
     return mDatabaseHandler->removeGatewayDB(gatewayID);
 }
 
-am_Error_e ControlReceiver::removeCrossfaderDB(const am_crossfaderID_t crossfaderID)
+am_Error_e CAmControlReceiver::removeCrossfaderDB(const am_crossfaderID_t crossfaderID)
 {
     return mDatabaseHandler->removeCrossfaderDB(crossfaderID);
 }
 
-am_Error_e ControlReceiver::removeDomainDB(const am_domainID_t domainID)
+am_Error_e CAmControlReceiver::removeDomainDB(const am_domainID_t domainID)
 {
     return mDatabaseHandler->removeDomainDB(domainID);
 }
 
-am_Error_e ControlReceiver::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s & classInfo) const
+am_Error_e CAmControlReceiver::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s & classInfo) const
 {
     return mDatabaseHandler->getSourceClassInfoDB(sourceID, classInfo);
 }
 
-am_Error_e ControlReceiver::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s & sinkClass) const
+am_Error_e CAmControlReceiver::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s & sinkClass) const
 {
     return mDatabaseHandler->getSinkClassInfoDB(sinkID, sinkClass);
 }
 
-am_Error_e ControlReceiver::getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s & sinkData) const
+am_Error_e CAmControlReceiver::getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s & sinkData) const
 {
     return mDatabaseHandler->getSinkInfoDB(sinkID, sinkData);
 }
 
-am_Error_e ControlReceiver::getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s & sourceData) const
+am_Error_e CAmControlReceiver::getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s & sourceData) const
 {
     return mDatabaseHandler->getSourceInfoDB(sourceID, sourceData);
 }
 
-am_Error_e ControlReceiver::getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s & mainConnectionData) const
+am_Error_e CAmControlReceiver::getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s & mainConnectionData) const
 {
     return mDatabaseHandler->getMainConnectionInfoDB(mainConnectionID, mainConnectionData);
 }
 
-am_Error_e ControlReceiver::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s & gatewayData) const
+am_Error_e CAmControlReceiver::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s & gatewayData) const
 {
     return mDatabaseHandler->getGatewayInfoDB(gatewayID, gatewayData);
 }
 
-am_Error_e ControlReceiver::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s & crossfaderData) const
+am_Error_e CAmControlReceiver::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s & crossfaderData) const
 {
     return mDatabaseHandler->getCrossfaderInfoDB(crossfaderID, crossfaderData);
 }
 
-am_Error_e ControlReceiver::getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t> & listSinkID) const
+am_Error_e CAmControlReceiver::getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t> & listSinkID) const
 {
     return mDatabaseHandler->getListSinksOfDomain(domainID, listSinkID);
 }
 
-am_Error_e ControlReceiver::getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t> & listSourceID) const
+am_Error_e CAmControlReceiver::getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t> & listSourceID) const
 {
     return mDatabaseHandler->getListSourcesOfDomain(domainID, listSourceID);
 }
 
-am_Error_e ControlReceiver::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t> & listGatewaysID) const
+am_Error_e CAmControlReceiver::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t> & listGatewaysID) const
 {
     return mDatabaseHandler->getListCrossfadersOfDomain(domainID, listGatewaysID);
 }
 
-am_Error_e ControlReceiver::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t> & listGatewaysID) const
+am_Error_e CAmControlReceiver::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t> & listGatewaysID) const
 {
     return mDatabaseHandler->getListGatewaysOfDomain(domainID, listGatewaysID);
 }
 
-am_Error_e ControlReceiver::getListMainConnections(std::vector<am_MainConnection_s> & listMainConnections) const
+am_Error_e CAmControlReceiver::getListMainConnections(std::vector<am_MainConnection_s> & listMainConnections) const
 {
     return mDatabaseHandler->getListMainConnections(listMainConnections);
 }
 
-am_Error_e ControlReceiver::getListDomains(std::vector<am_Domain_s> & listDomains) const
+am_Error_e CAmControlReceiver::getListDomains(std::vector<am_Domain_s> & listDomains) const
 {
     return mDatabaseHandler->getListDomains(listDomains);
 }
 
-am_Error_e ControlReceiver::getListConnections(std::vector<am_Connection_s> & listConnections) const
+am_Error_e CAmControlReceiver::getListConnections(std::vector<am_Connection_s> & listConnections) const
 {
     return mDatabaseHandler->getListConnections(listConnections);
 }
 
-am_Error_e ControlReceiver::getListSinks(std::vector<am_Sink_s> & listSinks) const
+am_Error_e CAmControlReceiver::getListSinks(std::vector<am_Sink_s> & listSinks) const
 {
     return mDatabaseHandler->getListSinks(listSinks);
 }
 
-am_Error_e ControlReceiver::getListSources(std::vector<am_Source_s> & listSources) const
+am_Error_e CAmControlReceiver::getListSources(std::vector<am_Source_s> & listSources) const
 {
     return mDatabaseHandler->getListSources(listSources);
 }
 
-am_Error_e ControlReceiver::getListSourceClasses(std::vector<am_SourceClass_s> & listSourceClasses) const
+am_Error_e CAmControlReceiver::getListSourceClasses(std::vector<am_SourceClass_s> & listSourceClasses) const
 {
     return mDatabaseHandler->getListSourceClasses(listSourceClasses);
 }
 
-am_Error_e ControlReceiver::getListHandles(std::vector<am_Handle_s> & listHandles) const
+am_Error_e CAmControlReceiver::getListHandles(std::vector<am_Handle_s> & listHandles) const
 {
     return mRoutingSender->getListHandles(listHandles);
 }
 
-am_Error_e ControlReceiver::getListCrossfaders(std::vector<am_Crossfader_s> & listCrossfaders) const
+am_Error_e CAmControlReceiver::getListCrossfaders(std::vector<am_Crossfader_s> & listCrossfaders) const
 {
     return mDatabaseHandler->getListCrossfaders(listCrossfaders);
 }
 
-am_Error_e ControlReceiver::getListGateways(std::vector<am_Gateway_s> & listGateways) const
+am_Error_e CAmControlReceiver::getListGateways(std::vector<am_Gateway_s> & listGateways) const
 {
     return mDatabaseHandler->getListGateways(listGateways);
 }
 
-am_Error_e ControlReceiver::getListSinkClasses(std::vector<am_SinkClass_s> & listSinkClasses) const
+am_Error_e CAmControlReceiver::getListSinkClasses(std::vector<am_SinkClass_s> & listSinkClasses) const
 {
     return mDatabaseHandler->getListSinkClasses(listSinkClasses);
 }
 
-am_Error_e ControlReceiver::getListSystemProperties(std::vector<am_SystemProperty_s> & listSystemProperties) const
+am_Error_e CAmControlReceiver::getListSystemProperties(std::vector<am_SystemProperty_s> & listSystemProperties) const
 {
     return mDatabaseHandler->getListSystemProperties(listSystemProperties);
 }
 
-am_Error_e ControlReceiver::changeSinkClassInfoDB(const am_SinkClass_s & classInfo)
+am_Error_e CAmControlReceiver::changeSinkClassInfoDB(const am_SinkClass_s & classInfo)
 {
     return mDatabaseHandler->changeSinkClassInfoDB(classInfo);
 }
 
-am_Error_e ControlReceiver::changeSourceClassInfoDB(const am_SourceClass_s & classInfo)
+am_Error_e CAmControlReceiver::changeSourceClassInfoDB(const am_SourceClass_s & classInfo)
 {
     return mDatabaseHandler->changeSourceClassInfoDB(classInfo);
 }
 
-am_Error_e ControlReceiver::removeSinkClassDB(const am_sinkClass_t sinkClassID)
+am_Error_e CAmControlReceiver::removeSinkClassDB(const am_sinkClass_t sinkClassID)
 {
     return mDatabaseHandler->removeSinkClassDB(sinkClassID);
 }
 
-am_Error_e ControlReceiver::removeSourceClassDB(const am_sourceClass_t sourceClassID)
+am_Error_e CAmControlReceiver::removeSourceClassDB(const am_sourceClass_t sourceClassID)
 {
     return mDatabaseHandler->removeSourceClassDB(sourceClassID);
 }
 
-void ControlReceiver::setCommandReady()
+void CAmControlReceiver::setCommandReady()
 {
-    logInfo("ControlReceiver::setCommandReady got called");
+    logInfo("CAmControlReceiver::setCommandReady got called");
     mCommandSender->setCommandReady();
 }
 
-void ControlReceiver::setRoutingReady()
+void CAmControlReceiver::setRoutingReady()
 {
-    logInfo("ControlReceiver::setRoutingReady got called");
+    logInfo("CAmControlReceiver::setRoutingReady got called");
     mRoutingSender->setRoutingReady();
 }
 
-void ControlReceiver::confirmControllerReady()
+void CAmControlReceiver::confirmControllerReady()
 {
     //todo: one time implement here system interaction with NSM
 }
 
-void ControlReceiver::confirmControllerRundown()
+void CAmControlReceiver::confirmControllerRundown()
 {
     //todo: one time implement here system interaction with NSM
 }
 
-am_Error_e ControlReceiver::getSocketHandler(SocketHandler *& socketHandler)
+am_Error_e CAmControlReceiver::getSocketHandler(CAmSocketHandler *& socketHandler)
 {
     socketHandler = mSocketHandler;
     return E_OK;
 }
 
-void ControlReceiver::setCommandRundown()
+void CAmControlReceiver::setCommandRundown()
 {
-    logInfo("ControlReceiver::setCommandRundown got called");
+    logInfo("CAmControlReceiver::setCommandRundown got called");
     mCommandSender->setCommandRundown();
 }
 
-void ControlReceiver::setRoutingRundown()
+void CAmControlReceiver::setRoutingRundown()
 {
-    logInfo("ControlReceiver::setRoutingRundown got called");
+    logInfo("CAmControlReceiver::setRoutingRundown got called");
     mRoutingSender->setRoutingRundown();
 }
 
-void ControlReceiver::getInterfaceVersion(std::string & version) const
+void CAmControlReceiver::getInterfaceVersion(std::string & version) const
 {
     version = ControlReceiveVersion;
 }
-
-
+}
 
diff --git a/AudioManagerDaemon/src/ControlSender.cpp b/AudioManagerDaemon/src/CAmControlSender.cpp
index 492244e..cc26c90 100644
--- a/AudioManagerDaemon/src/ControlSender.cpp
+++ b/AudioManagerDaemon/src/CAmControlSender.cpp
@@ -3,7 +3,7 @@
  *
  * GeniviAudioMananger AudioManagerDaemon
  *
- * \file ControlSender.cpp
+ * \file CAmControlSender.cpp
  *
  * \date 20-Oct-2011 3:42:04 PM
  * \author Christian Mueller (christian.ei.mueller@bmw.de)
@@ -22,21 +22,21 @@
  *
  */
 
-#include "ControlSender.h"
-#include "PluginTemplate.h"
-#include "DLTWrapper.h"
+#include "CAmControlSender.h"
+#include "TAmPluginTemplate.h"
+#include "shared/CAmDltWrapper.h"
 #include <cassert>
 #include <fstream>
 #include <iostream>
 #include <sstream>
 #include <stdexcept>
 
-using namespace am;
+namespace am {
 
 #define REQUIRED_INTERFACE_VERSION_MAJOR 1
 #define REQUIRED_INTERFACE_VERSION_MINOR 0
 
-ControlSender::ControlSender(std::string controlPluginFile) :
+CAmControlSender::CAmControlSender(std::string controlPluginFile) :
         mlibHandle(NULL), //
         mController(NULL)
 {
@@ -47,8 +47,8 @@ ControlSender::ControlSender(std::string controlPluginFile) :
     }
     else if (!controlPluginFile.empty())
     {
-        ControlSendInterface* (*createFunc)();
-        createFunc = getCreateFunction<ControlSendInterface*()>(controlPluginFile, mlibHandle);
+        IAmControlSend* (*createFunc)();
+        createFunc = getCreateFunction<IAmControlSend*()>(controlPluginFile, mlibHandle);
         assert(createFunc!=NULL);
         mController = createFunc();
 
@@ -71,244 +71,244 @@ ControlSender::ControlSender(std::string controlPluginFile) :
     }
 }
 
-ControlSender::~ControlSender()
+CAmControlSender::~CAmControlSender()
 {
     if (mlibHandle)
         dlclose(mlibHandle);
 }
 
-am_Error_e ControlSender::hookUserConnectionRequest(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t & mainConnectionID)
+am_Error_e CAmControlSender::hookUserConnectionRequest(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t & mainConnectionID)
 {
     return mController->hookUserConnectionRequest(sourceID, sinkID, mainConnectionID);
 }
 
-am_Error_e ControlSender::hookUserDisconnectionRequest(const am_mainConnectionID_t connectionID)
+am_Error_e CAmControlSender::hookUserDisconnectionRequest(const am_mainConnectionID_t connectionID)
 {
     return mController->hookUserDisconnectionRequest(connectionID);
 }
 
-am_Error_e ControlSender::hookUserSetMainSinkSoundProperty(const am_sinkID_t sinkID, const am_MainSoundProperty_s & soundProperty)
+am_Error_e CAmControlSender::hookUserSetMainSinkSoundProperty(const am_sinkID_t sinkID, const am_MainSoundProperty_s & soundProperty)
 {
     return mController->hookUserSetMainSinkSoundProperty(sinkID, soundProperty);
 }
 
-am_Error_e ControlSender::hookUserSetMainSourceSoundProperty(const am_sourceID_t sourceID, const am_MainSoundProperty_s & soundProperty)
+am_Error_e CAmControlSender::hookUserSetMainSourceSoundProperty(const am_sourceID_t sourceID, const am_MainSoundProperty_s & soundProperty)
 {
     return mController->hookUserSetMainSourceSoundProperty(sourceID, soundProperty);
 }
 
-am_Error_e ControlSender::hookUserSetSystemProperty(const am_SystemProperty_s & property)
+am_Error_e CAmControlSender::hookUserSetSystemProperty(const am_SystemProperty_s & property)
 {
     return mController->hookUserSetSystemProperty(property);
 }
 
-am_Error_e ControlSender::hookUserVolumeChange(const am_sinkID_t sinkID, const am_mainVolume_t newVolume)
+am_Error_e CAmControlSender::hookUserVolumeChange(const am_sinkID_t sinkID, const am_mainVolume_t newVolume)
 {
     return mController->hookUserVolumeChange(sinkID, newVolume);
 }
 
-am_Error_e ControlSender::hookUserVolumeStep(const am_sinkID_t sinkID, const int16_t increment)
+am_Error_e CAmControlSender::hookUserVolumeStep(const am_sinkID_t sinkID, const int16_t increment)
 {
     return mController->hookUserVolumeStep(sinkID, increment);
 }
 
-am_Error_e ControlSender::hookUserSetSinkMuteState(const am_sinkID_t sinkID, const am_MuteState_e muteState)
+am_Error_e CAmControlSender::hookUserSetSinkMuteState(const am_sinkID_t sinkID, const am_MuteState_e muteState)
 {
     return mController->hookUserSetSinkMuteState(sinkID, muteState);
 }
 
-am_Error_e ControlSender::hookSystemRegisterDomain(const am_Domain_s & domainData, am_domainID_t & domainID)
+am_Error_e CAmControlSender::hookSystemRegisterDomain(const am_Domain_s & domainData, am_domainID_t & domainID)
 {
     return mController->hookSystemRegisterDomain(domainData, domainID);
 }
 
-am_Error_e ControlSender::hookSystemDeregisterDomain(const am_domainID_t domainID)
+am_Error_e CAmControlSender::hookSystemDeregisterDomain(const am_domainID_t domainID)
 {
     return mController->hookSystemDeregisterDomain(domainID);
 }
 
-void ControlSender::hookSystemDomainRegistrationComplete(const am_domainID_t domainID)
+void CAmControlSender::hookSystemDomainRegistrationComplete(const am_domainID_t domainID)
 {
     return mController->hookSystemDomainRegistrationComplete(domainID);
 }
 
-am_Error_e ControlSender::hookSystemRegisterSink(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
+am_Error_e CAmControlSender::hookSystemRegisterSink(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
 {
     return mController->hookSystemRegisterSink(sinkData, sinkID);
 }
 
-am_Error_e ControlSender::hookSystemDeregisterSink(const am_sinkID_t sinkID)
+am_Error_e CAmControlSender::hookSystemDeregisterSink(const am_sinkID_t sinkID)
 {
     return mController->hookSystemDeregisterSink(sinkID);
 }
 
-am_Error_e ControlSender::hookSystemRegisterSource(const am_Source_s & sourceData, am_sourceID_t & sourceID)
+am_Error_e CAmControlSender::hookSystemRegisterSource(const am_Source_s & sourceData, am_sourceID_t & sourceID)
 {
     return mController->hookSystemRegisterSource(sourceData, sourceID);
 }
 
-am_Error_e ControlSender::hookSystemDeregisterSource(const am_sourceID_t sourceID)
+am_Error_e CAmControlSender::hookSystemDeregisterSource(const am_sourceID_t sourceID)
 {
     return mController->hookSystemDeregisterSource(sourceID);
 }
 
-am_Error_e ControlSender::hookSystemRegisterGateway(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
+am_Error_e CAmControlSender::hookSystemRegisterGateway(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
 {
     return mController->hookSystemRegisterGateway(gatewayData, gatewayID);
 }
 
-am_Error_e ControlSender::hookSystemDeregisterGateway(const am_gatewayID_t gatewayID)
+am_Error_e CAmControlSender::hookSystemDeregisterGateway(const am_gatewayID_t gatewayID)
 {
     return mController->hookSystemDeregisterGateway(gatewayID);
 }
 
-am_Error_e ControlSender::hookSystemRegisterCrossfader(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
+am_Error_e CAmControlSender::hookSystemRegisterCrossfader(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
 {
     return mController->hookSystemRegisterCrossfader(crossfaderData, crossfaderID);
 }
 
-am_Error_e ControlSender::hookSystemDeregisterCrossfader(const am_crossfaderID_t crossfaderID)
+am_Error_e CAmControlSender::hookSystemDeregisterCrossfader(const am_crossfaderID_t crossfaderID)
 {
     return mController->hookSystemDeregisterCrossfader(crossfaderID);
 }
 
-void ControlSender::hookSystemSinkVolumeTick(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume)
+void CAmControlSender::hookSystemSinkVolumeTick(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume)
 {
     mController->hookSystemSinkVolumeTick(handle, sinkID, volume);
 }
 
-void ControlSender::hookSystemSourceVolumeTick(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume)
+void CAmControlSender::hookSystemSourceVolumeTick(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume)
 {
     mController->hookSystemSourceVolumeTick(handle, sourceID, volume);
 }
 
-void ControlSender::hookSystemInterruptStateChange(const am_sourceID_t sourceID, const am_InterruptState_e interruptState)
+void CAmControlSender::hookSystemInterruptStateChange(const am_sourceID_t sourceID, const am_InterruptState_e interruptState)
 {
     mController->hookSystemInterruptStateChange(sourceID, interruptState);
 }
 
-void ControlSender::hookSystemSinkAvailablityStateChange(const am_sinkID_t sinkID, const am_Availability_s & availability)
+void CAmControlSender::hookSystemSinkAvailablityStateChange(const am_sinkID_t sinkID, const am_Availability_s & availability)
 {
     mController->hookSystemSinkAvailablityStateChange(sinkID, availability);
 }
 
-void ControlSender::hookSystemSourceAvailablityStateChange(const am_sourceID_t sourceID, const am_Availability_s & availability)
+void CAmControlSender::hookSystemSourceAvailablityStateChange(const am_sourceID_t sourceID, const am_Availability_s & availability)
 {
     mController->hookSystemSourceAvailablityStateChange(sourceID, availability);
 }
 
-void ControlSender::hookSystemDomainStateChange(const am_domainID_t domainID, const am_DomainState_e state)
+void CAmControlSender::hookSystemDomainStateChange(const am_domainID_t domainID, const am_DomainState_e state)
 {
     mController->hookSystemDomainStateChange(domainID, state);
 }
 
-void ControlSender::hookSystemReceiveEarlyData(const std::vector<am_EarlyData_s> & data)
+void CAmControlSender::hookSystemReceiveEarlyData(const std::vector<am_EarlyData_s> & data)
 {
     mController->hookSystemReceiveEarlyData(data);
 }
 
-void ControlSender::hookSystemSpeedChange(const am_speed_t speed)
+void CAmControlSender::hookSystemSpeedChange(const am_speed_t speed)
 {
     mController->hookSystemSpeedChange(speed);
 }
 
-void ControlSender::hookSystemTimingInformationChanged(const am_mainConnectionID_t mainConnectionID, const am_timeSync_t time)
+void CAmControlSender::hookSystemTimingInformationChanged(const am_mainConnectionID_t mainConnectionID, const am_timeSync_t time)
 {
     mController->hookSystemTimingInformationChanged(mainConnectionID, time);
 }
 
-void ControlSender::cbAckConnect(const am_Handle_s handle, const am_Error_e errorID)
+void CAmControlSender::cbAckConnect(const am_Handle_s handle, const am_Error_e errorID)
 {
     mController->cbAckConnect(handle, errorID);
 }
 
-void ControlSender::cbAckDisconnect(const am_Handle_s handle, const am_Error_e errorID)
+void CAmControlSender::cbAckDisconnect(const am_Handle_s handle, const am_Error_e errorID)
 {
     mController->cbAckDisconnect(handle, errorID);
 }
 
-void ControlSender::cbAckCrossFade(const am_Handle_s handle, const am_HotSink_e hostsink, const am_Error_e error)
+void CAmControlSender::cbAckCrossFade(const am_Handle_s handle, const am_HotSink_e hostsink, const am_Error_e error)
 {
     mController->cbAckCrossFade(handle, hostsink, error);
 }
 
-void ControlSender::cbAckSetSinkVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
+void CAmControlSender::cbAckSetSinkVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
 {
     mController->cbAckSetSinkVolumeChange(handle, volume, error);
 }
 
-void ControlSender::cbAckSetSourceVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
+void CAmControlSender::cbAckSetSourceVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
 {
     mController->cbAckSetSourceVolumeChange(handle, volume, error);
 }
 
-void ControlSender::cbAckSetSourceState(const am_Handle_s handle, const am_Error_e error)
+void CAmControlSender::cbAckSetSourceState(const am_Handle_s handle, const am_Error_e error)
 {
     mController->cbAckSetSourceState(handle, error);
 }
 
-void ControlSender::cbAckSetSourceSoundProperty(const am_Handle_s handle, const am_Error_e error)
+void CAmControlSender::cbAckSetSourceSoundProperty(const am_Handle_s handle, const am_Error_e error)
 {
     mController->cbAckSetSourceSoundProperty(handle, error);
 }
 
-am_Error_e ControlSender::startupController(ControlReceiveInterface *controlreceiveinterface)
+am_Error_e CAmControlSender::startupController(IAmControlReceive *controlreceiveinterface)
 {
     return mController->startupController(controlreceiveinterface);
 }
 
-void ControlSender::cbAckSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error)
+void CAmControlSender::cbAckSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error)
 {
     mController->cbAckSetSinkSoundProperty(handle, error);
 }
 
-void ControlSender::cbAckSetSinkSoundProperties(const am_Handle_s handle, const am_Error_e error)
+void CAmControlSender::cbAckSetSinkSoundProperties(const am_Handle_s handle, const am_Error_e error)
 {
     mController->cbAckSetSinkSoundProperties(handle, error);
 }
 
-void ControlSender::cbAckSetSourceSoundProperties(const am_Handle_s handle, const am_Error_e error)
+void CAmControlSender::cbAckSetSourceSoundProperties(const am_Handle_s handle, const am_Error_e error)
 {
     mController->cbAckSetSourceSoundProperties(handle, error);
 }
 
-void ControlSender::setControllerReady()
+void CAmControlSender::setControllerReady()
 {
     mController->setControllerReady();
 }
 
-void ControlSender::setControllerRundown()
+void CAmControlSender::setControllerRundown()
 {
     mController->setControllerRundown();
 }
 
-am_Error_e am::ControlSender::getConnectionFormatChoice(const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_Route_s listRoute, const std::vector<am_ConnectionFormat_e> listPossibleConnectionFormats, std::vector<am_ConnectionFormat_e> & listPrioConnectionFormats)
+am_Error_e am::CAmControlSender::getConnectionFormatChoice(const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_Route_s listRoute, const std::vector<am_ConnectionFormat_e> listPossibleConnectionFormats, std::vector<am_ConnectionFormat_e> & listPrioConnectionFormats)
 {
     return mController->getConnectionFormatChoice(sourceID, sinkID, listRoute, listPossibleConnectionFormats, listPrioConnectionFormats);
 }
 
-void ControlSender::getInterfaceVersion(std::string & version) const
+void CAmControlSender::getInterfaceVersion(std::string & version) const
 {
     version = ControlSendVersion;
 }
 
-void ControlSender::confirmCommandReady()
+void CAmControlSender::confirmCommandReady()
 {
     mController->confirmCommandReady();
 }
 
-void ControlSender::confirmRoutingReady()
+void CAmControlSender::confirmRoutingReady()
 {
     mController->confirmRoutingReady();
 }
 
-void ControlSender::confirmCommandRundown()
+void CAmControlSender::confirmCommandRundown()
 {
     mController->confirmCommandRundown();
 }
 
-void ControlSender::confirmRoutingRundown()
+void CAmControlSender::confirmRoutingRundown()
 {
     mController->confirmRoutingRundown();
 }
-
+}
diff --git a/AudioManagerDaemon/src/DatabaseHandler.cpp b/AudioManagerDaemon/src/CAmDatabaseHandler.cpp
index 54e0129..b9da10e 100644
--- a/AudioManagerDaemon/src/DatabaseHandler.cpp
+++ b/AudioManagerDaemon/src/CAmDatabaseHandler.cpp
@@ -3,7 +3,7 @@
  *
  * GeniviAudioMananger AudioManagerDaemon
  *
- * \file Databasehandler.cpp
+ * \file CAmDatabaseHandler.cpp
  *
  * \date 20-Oct-2011 3:42:04 PM
  * \author Christian Mueller (christian.ei.mueller@bmw.de)
@@ -22,15 +22,15 @@
  *
  */
 
-#include "DatabaseHandler.h"
-#include "DatabaseObserver.h"
+#include "CAmDatabaseHandler.h"
+#include "CAmDatabaseObserver.h"
 #include <cassert>
 #include <vector>
 #include <fstream>
 #include <sstream>
 #include <string>
-#include "DLTWrapper.h"
-#include "Router.h"
+#include "shared/CAmDltWrapper.h"
+#include "CAmRouter.h"
 
 #define DOMAIN_TABLE "Domains"
 #define SOURCE_CLASS_TABLE "SourceClasses"
@@ -45,7 +45,8 @@
 #define MAIN_TABLE "MainTable"
 #define SYSTEM_TABLE "SystemProperties"
 
-using namespace am;
+namespace am
+{
 
 const std::string databaseTables[] =
 { " Domains (domainID INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, name VARCHAR(50), busname VARCHAR(50), nodename VARCHAR(50), early BOOL, complete BOOL, state INTEGER, reserved BOOL);", //
@@ -72,7 +73,7 @@ inline std::string i2s(T const& x)
     return o.str();
 }
 
-DatabaseHandler::DatabaseHandler(std::string databasePath) :
+CAmDatabaseHandler::CAmDatabaseHandler(std::string databasePath) :
         mDatabase(NULL), //
         mPath(databasePath), //
         mDatabaseObserver(NULL), //
@@ -102,13 +103,13 @@ DatabaseHandler::DatabaseHandler(std::string databasePath) :
     createTables();
 }
 
-DatabaseHandler::~DatabaseHandler()
+CAmDatabaseHandler::~CAmDatabaseHandler()
 {
     logInfo("Closed Database");
     sqlite3_close(mDatabase);
 }
 
-am_Error_e DatabaseHandler::enterDomainDB(const am_Domain_s & domainData, am_domainID_t & domainID)
+am_Error_e CAmDatabaseHandler::enterDomainDB(const am_Domain_s & domainData, am_domainID_t & domainID)
 {
     assert(domainData.domainID==0);
     assert(!domainData.name.empty());
@@ -174,7 +175,7 @@ am_Error_e DatabaseHandler::enterDomainDB(const am_Domain_s & domainData, am_dom
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::enterMainConnectionDB(const am_MainConnection_s & mainConnectionData, am_mainConnectionID_t & connectionID)
+am_Error_e CAmDatabaseHandler::enterMainConnectionDB(const am_MainConnection_s & mainConnectionData, am_mainConnectionID_t & connectionID)
 {
     assert(mainConnectionData.mainConnectionID==0);
     assert(mainConnectionData.connectionState>=CS_UNKNOWN && mainConnectionData.connectionState<=CS_MAX);
@@ -263,11 +264,11 @@ am_Error_e DatabaseHandler::enterMainConnectionDB(const am_MainConnection_s & ma
     if (mDatabaseObserver)
     {
         am_MainConnectionType_s mainConnection;
-        mainConnection.mainConnectionID=connectionID;
-        mainConnection.connectionState=mainConnectionData.connectionState;
-        mainConnection.delay=delay;
-        mainConnection.sinkID=mainConnectionData.sinkID;
-        mainConnection.sourceID=mainConnectionData.sourceID;
+        mainConnection.mainConnectionID = connectionID;
+        mainConnection.connectionState = mainConnectionData.connectionState;
+        mainConnection.delay = delay;
+        mainConnection.sinkID = mainConnectionData.sinkID;
+        mainConnection.sourceID = mainConnectionData.sourceID;
         mDatabaseObserver->newMainConnection(mainConnection);
         mDatabaseObserver->mainConnectionStateChanged(connectionID, mainConnectionData.connectionState);
     }
@@ -278,7 +279,7 @@ am_Error_e DatabaseHandler::enterMainConnectionDB(const am_MainConnection_s & ma
     return changeDelayMainConnection(delay, connectionID);
 }
 
-am_Error_e DatabaseHandler::enterSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
+am_Error_e CAmDatabaseHandler::enterSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
 {
     assert(sinkData.sinkID<DYNAMIC_ID_BOUNDARY);
     assert(sinkData.domainID!=0);
@@ -455,7 +456,7 @@ am_Error_e DatabaseHandler::enterSinkDB(const am_Sink_s & sinkData, am_sinkID_t
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::enterCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
+am_Error_e CAmDatabaseHandler::enterCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
 {
     assert(crossfaderData.crossfaderID<DYNAMIC_ID_BOUNDARY);
     assert(crossfaderData.hotSink>=HS_UNKNOWN && crossfaderData.hotSink<=HS_MAX);
@@ -542,7 +543,7 @@ am_Error_e DatabaseHandler::enterCrossfaderDB(const am_Crossfader_s & crossfader
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::enterGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
+am_Error_e CAmDatabaseHandler::enterGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
 {
     assert(gatewayData.gatewayID<DYNAMIC_ID_BOUNDARY);
     assert(gatewayData.sinkID!=0);
@@ -654,7 +655,7 @@ am_Error_e DatabaseHandler::enterGatewayDB(const am_Gateway_s & gatewayData, am_
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::enterSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID)
+am_Error_e CAmDatabaseHandler::enterSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID)
 {
     assert(sourceData.sourceID<DYNAMIC_ID_BOUNDARY);
     assert(sourceData.domainID!=0);
@@ -833,7 +834,7 @@ am_Error_e DatabaseHandler::enterSourceDB(const am_Source_s & sourceData, am_sou
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector<am_connectionID_t>& listConnectionID)
+am_Error_e CAmDatabaseHandler::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector<am_connectionID_t>& listConnectionID)
 {
     assert(mainconnectionID!=0);
     if (!existMainConnection(mainconnectionID))
@@ -905,7 +906,7 @@ am_Error_e DatabaseHandler::changeMainConnectionRouteDB(const am_mainConnectionI
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState)
+am_Error_e CAmDatabaseHandler::changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState)
 {
     assert(mainconnectionID!=0);
     assert(connectionState>=CS_UNKNOWN && connectionState<=CS_MAX);
@@ -938,7 +939,7 @@ am_Error_e DatabaseHandler::changeMainConnectionStateDB(const am_mainConnectionI
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeSinkMainVolumeDB(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID)
+am_Error_e CAmDatabaseHandler::changeSinkMainVolumeDB(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID)
 {
     assert(sinkID!=0);
 
@@ -972,7 +973,7 @@ am_Error_e DatabaseHandler::changeSinkMainVolumeDB(const am_mainVolume_t mainVol
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeSinkAvailabilityDB(const am_Availability_s & availability, const am_sinkID_t sinkID)
+am_Error_e CAmDatabaseHandler::changeSinkAvailabilityDB(const am_Availability_s & availability, const am_sinkID_t sinkID)
 {
     assert(sinkID!=0);
     assert(availability.availability>=A_UNKNOWN && availability.availability<=A_MAX);
@@ -1009,7 +1010,7 @@ am_Error_e DatabaseHandler::changeSinkAvailabilityDB(const am_Availability_s & a
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID)
+am_Error_e CAmDatabaseHandler::changDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID)
 {
     assert(domainID!=0);
     assert(domainState>=DS_UNKNOWN && domainState<=DS_MAX);
@@ -1042,7 +1043,7 @@ am_Error_e DatabaseHandler::changDomainStateDB(const am_DomainState_e domainStat
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID)
+am_Error_e CAmDatabaseHandler::changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID)
 {
     assert(sinkID!=0);
     assert(muteState>=MS_UNKNOWN && muteState<=MS_MAX);
@@ -1078,7 +1079,7 @@ am_Error_e DatabaseHandler::changeSinkMuteStateDB(const am_MuteState_e muteState
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID)
+am_Error_e CAmDatabaseHandler::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID)
 {
     assert(soundProperty.type>=MSP_UNKNOWN && soundProperty.type<=MSP_MAX);
     assert(sinkID!=0);
@@ -1112,7 +1113,7 @@ am_Error_e DatabaseHandler::changeMainSinkSoundPropertyDB(const am_MainSoundProp
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID)
+am_Error_e CAmDatabaseHandler::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID)
 {
     assert(soundProperty.type>=MSP_UNKNOWN && soundProperty.type<=MSP_MAX);
     assert(sourceID!=0);
@@ -1147,7 +1148,7 @@ am_Error_e DatabaseHandler::changeMainSourceSoundPropertyDB(const am_MainSoundPr
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeSourceAvailabilityDB(const am_Availability_s & availability, const am_sourceID_t sourceID)
+am_Error_e CAmDatabaseHandler::changeSourceAvailabilityDB(const am_Availability_s & availability, const am_sourceID_t sourceID)
 {
     assert(sourceID!=0);
     assert(availability.availability>=A_UNKNOWN && availability.availability<=A_MAX);
@@ -1184,7 +1185,7 @@ am_Error_e DatabaseHandler::changeSourceAvailabilityDB(const am_Availability_s &
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeSystemPropertyDB(const am_SystemProperty_s & property)
+am_Error_e CAmDatabaseHandler::changeSystemPropertyDB(const am_SystemProperty_s & property)
 {
     assert(property.type>=SYP_UNKNOWN && property.type<=SYP_MAX);
     sqlite3_stmt* query = NULL;
@@ -1215,7 +1216,7 @@ am_Error_e DatabaseHandler::changeSystemPropertyDB(const am_SystemProperty_s & p
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::removeMainConnectionDB(const am_mainConnectionID_t mainConnectionID)
+am_Error_e CAmDatabaseHandler::removeMainConnectionDB(const am_mainConnectionID_t mainConnectionID)
 {
     assert(mainConnectionID!=0);
 
@@ -1238,7 +1239,7 @@ am_Error_e DatabaseHandler::removeMainConnectionDB(const am_mainConnectionID_t m
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::removeSinkDB(const am_sinkID_t sinkID)
+am_Error_e CAmDatabaseHandler::removeSinkDB(const am_sinkID_t sinkID)
 {
     assert(sinkID!=0);
 
@@ -1247,7 +1248,7 @@ am_Error_e DatabaseHandler::removeSinkDB(const am_sinkID_t sinkID)
         return E_NON_EXISTENT;
     }
 
-    bool visible=sinkVisible(sinkID);
+    bool visible = sinkVisible(sinkID);
 
     std::string command = "DELETE from " + std::string(SINK_TABLE) + " WHERE sinkID=" + i2s(sinkID);
     std::string command1 = "DROP table SinkConnectionFormat" + i2s(sinkID);
@@ -1264,12 +1265,12 @@ am_Error_e DatabaseHandler::removeSinkDB(const am_sinkID_t sinkID)
     logInfo("DatabaseHandler::removeSinkDB removed:", sinkID);
 
     if (mDatabaseObserver != NULL)
-        mDatabaseObserver->removedSink(sinkID,visible);
+        mDatabaseObserver->removedSink(sinkID, visible);
 
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::removeSourceDB(const am_sourceID_t sourceID)
+am_Error_e CAmDatabaseHandler::removeSourceDB(const am_sourceID_t sourceID)
 {
     assert(sourceID!=0);
 
@@ -1278,7 +1279,7 @@ am_Error_e DatabaseHandler::removeSourceDB(const am_sourceID_t sourceID)
         return E_NON_EXISTENT;
     }
 
-    bool visible=sourceVisible(sourceID);
+    bool visible = sourceVisible(sourceID);
 
     std::string command = "DELETE from " + std::string(SOURCE_TABLE) + " WHERE sourceID=" + i2s(sourceID);
     std::string command1 = "DROP table SourceConnectionFormat" + i2s(sourceID);
@@ -1294,11 +1295,11 @@ am_Error_e DatabaseHandler::removeSourceDB(const am_sourceID_t sourceID)
         return E_DATABASE_ERROR;
     logInfo("DatabaseHandler::removeSourceDB removed:", sourceID);
     if (mDatabaseObserver)
-        mDatabaseObserver->removedSource(sourceID,visible);
+        mDatabaseObserver->removedSource(sourceID, visible);
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::removeGatewayDB(const am_gatewayID_t gatewayID)
+am_Error_e CAmDatabaseHandler::removeGatewayDB(const am_gatewayID_t gatewayID)
 {
     assert(gatewayID!=0);
 
@@ -1315,7 +1316,7 @@ am_Error_e DatabaseHandler::removeGatewayDB(const am_gatewayID_t gatewayID)
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::removeCrossfaderDB(const am_crossfaderID_t crossfaderID)
+am_Error_e CAmDatabaseHandler::removeCrossfaderDB(const am_crossfaderID_t crossfaderID)
 {
     assert(crossfaderID!=0);
 
@@ -1332,7 +1333,7 @@ am_Error_e DatabaseHandler::removeCrossfaderDB(const am_crossfaderID_t crossfade
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::removeDomainDB(const am_domainID_t domainID)
+am_Error_e CAmDatabaseHandler::removeDomainDB(const am_domainID_t domainID)
 {
     assert(domainID!=0);
 
@@ -1349,7 +1350,7 @@ am_Error_e DatabaseHandler::removeDomainDB(const am_domainID_t domainID)
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::removeSinkClassDB(const am_sinkClass_t sinkClassID)
+am_Error_e CAmDatabaseHandler::removeSinkClassDB(const am_sinkClass_t sinkClassID)
 {
     assert(sinkClassID!=0);
 
@@ -1371,7 +1372,7 @@ am_Error_e DatabaseHandler::removeSinkClassDB(const am_sinkClass_t sinkClassID)
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::removeSourceClassDB(const am_sourceClass_t sourceClassID)
+am_Error_e CAmDatabaseHandler::removeSourceClassDB(const am_sourceClass_t sourceClassID)
 {
     assert(sourceClassID!=0);
 
@@ -1391,7 +1392,7 @@ am_Error_e DatabaseHandler::removeSourceClassDB(const am_sourceClass_t sourceCla
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::removeConnection(const am_connectionID_t connectionID)
+am_Error_e CAmDatabaseHandler::removeConnection(const am_connectionID_t connectionID)
 {
     assert(connectionID!=0);
 
@@ -1402,7 +1403,7 @@ am_Error_e DatabaseHandler::removeConnection(const am_connectionID_t connectionI
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s & classInfo) const
+am_Error_e CAmDatabaseHandler::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s & classInfo) const
 {
     assert(sourceID!=0);
 
@@ -1477,7 +1478,7 @@ am_Error_e DatabaseHandler::getSourceClassInfoDB(const am_sourceID_t sourceID, a
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s & sinkData) const
+am_Error_e CAmDatabaseHandler::getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s & sinkData) const
 {
 
     assert(sinkID!=0);
@@ -1576,7 +1577,7 @@ am_Error_e DatabaseHandler::getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s &
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s & sourceData) const
+am_Error_e CAmDatabaseHandler::getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s & sourceData) const
 {
     assert(sourceID!=0);
 
@@ -1673,7 +1674,7 @@ am_Error_e DatabaseHandler::getSourceInfoDB(const am_sourceID_t sourceID, am_Sou
     return E_OK;
 }
 
-am_Error_e am::DatabaseHandler::getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s & mainConnectionData) const
+am_Error_e am::CAmDatabaseHandler::getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s & mainConnectionData) const
 {
     assert(mainConnectionID!=0);
     if (!existMainConnection(mainConnectionID))
@@ -1717,7 +1718,7 @@ am_Error_e am::DatabaseHandler::getMainConnectionInfoDB(const am_mainConnectionI
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeSinkClassInfoDB(const am_SinkClass_s& sinkClass)
+am_Error_e CAmDatabaseHandler::changeSinkClassInfoDB(const am_SinkClass_s& sinkClass)
 {
     assert(sinkClass.sinkClassID!=0);
     assert(!sinkClass.listClassProperties.empty());
@@ -1755,7 +1756,7 @@ am_Error_e DatabaseHandler::changeSinkClassInfoDB(const am_SinkClass_s& sinkClas
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeSourceClassInfoDB(const am_SourceClass_s& sourceClass)
+am_Error_e CAmDatabaseHandler::changeSourceClassInfoDB(const am_SourceClass_s& sourceClass)
 {
     assert(sourceClass.sourceClassID!=0);
     assert(!sourceClass.listClassProperties.empty());
@@ -1793,7 +1794,7 @@ am_Error_e DatabaseHandler::changeSourceClassInfoDB(const am_SourceClass_s& sour
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s & sinkClass) const
+am_Error_e CAmDatabaseHandler::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s & sinkClass) const
 {
     assert(sinkID!=0);
 
@@ -1868,7 +1869,7 @@ am_Error_e DatabaseHandler::getSinkClassInfoDB(const am_sinkID_t sinkID, am_Sink
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s & gatewayData) const
+am_Error_e CAmDatabaseHandler::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s & gatewayData) const
 {
     assert(gatewayID!=0);
     if (!existGateway(gatewayID))
@@ -1949,7 +1950,7 @@ am_Error_e DatabaseHandler::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_
 
 }
 
-am_Error_e DatabaseHandler::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s & crossfaderData) const
+am_Error_e CAmDatabaseHandler::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s & crossfaderData) const
 {
     assert(crossfaderID!=0);
     if (!existcrossFader(crossfaderID))
@@ -1986,7 +1987,7 @@ am_Error_e DatabaseHandler::getCrossfaderInfoDB(const am_crossfaderID_t crossfad
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t> & listSinkID) const
+am_Error_e CAmDatabaseHandler::getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t> & listSinkID) const
 {
     assert(domainID!=0);
     listSinkID.clear();
@@ -2021,7 +2022,7 @@ am_Error_e DatabaseHandler::getListSinksOfDomain(const am_domainID_t domainID, s
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t> & listSourceID) const
+am_Error_e CAmDatabaseHandler::getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t> & listSourceID) const
 {
     assert(domainID!=0);
     listSourceID.clear();
@@ -2057,7 +2058,7 @@ am_Error_e DatabaseHandler::getListSourcesOfDomain(const am_domainID_t domainID,
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t> & listCrossfader) const
+am_Error_e CAmDatabaseHandler::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t> & listCrossfader) const
 {
     assert(domainID!=0);
     listCrossfader.clear();
@@ -2094,7 +2095,7 @@ am_Error_e DatabaseHandler::getListCrossfadersOfDomain(const am_domainID_t domai
 
 }
 
-am_Error_e DatabaseHandler::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t> & listGatewaysID) const
+am_Error_e CAmDatabaseHandler::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t> & listGatewaysID) const
 {
     assert(domainID!=0);
     listGatewaysID.clear();
@@ -2130,7 +2131,7 @@ am_Error_e DatabaseHandler::getListGatewaysOfDomain(const am_domainID_t domainID
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListMainConnections(std::vector<am_MainConnection_s> & listMainConnections) const
+am_Error_e CAmDatabaseHandler::getListMainConnections(std::vector<am_MainConnection_s> & listMainConnections) const
 {
     listMainConnections.clear();
     sqlite3_stmt *query = NULL, *query1 = NULL;
@@ -2171,7 +2172,7 @@ am_Error_e DatabaseHandler::getListMainConnections(std::vector<am_MainConnection
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListDomains(std::vector<am_Domain_s> & listDomains) const
+am_Error_e CAmDatabaseHandler::getListDomains(std::vector<am_Domain_s> & listDomains) const
 {
     listDomains.clear();
     sqlite3_stmt* query = NULL;
@@ -2209,7 +2210,7 @@ am_Error_e DatabaseHandler::getListDomains(std::vector<am_Domain_s> & listDomain
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListConnections(std::vector<am_Connection_s> & listConnections) const
+am_Error_e CAmDatabaseHandler::getListConnections(std::vector<am_Connection_s> & listConnections) const
 {
     listConnections.clear();
     sqlite3_stmt* query = NULL;
@@ -2243,7 +2244,7 @@ am_Error_e DatabaseHandler::getListConnections(std::vector<am_Connection_s> & li
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListSinks(std::vector<am_Sink_s> & listSinks) const
+am_Error_e CAmDatabaseHandler::getListSinks(std::vector<am_Sink_s> & listSinks) const
 {
     listSinks.clear();
     sqlite3_stmt* query = NULL, *qConnectionFormat = NULL, *qSoundProperty = NULL, *qMAinSoundProperty = NULL;
@@ -2340,7 +2341,7 @@ am_Error_e DatabaseHandler::getListSinks(std::vector<am_Sink_s> & listSinks) con
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListSources(std::vector<am_Source_s> & listSources) const
+am_Error_e CAmDatabaseHandler::getListSources(std::vector<am_Source_s> & listSources) const
 {
     listSources.clear();
     sqlite3_stmt* query = NULL, *qConnectionFormat = NULL, *qSoundProperty = NULL, *qMAinSoundProperty = NULL;
@@ -2437,7 +2438,7 @@ am_Error_e DatabaseHandler::getListSources(std::vector<am_Source_s> & listSource
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListSourceClasses(std::vector<am_SourceClass_s> & listSourceClasses) const
+am_Error_e CAmDatabaseHandler::getListSourceClasses(std::vector<am_SourceClass_s> & listSourceClasses) const
 {
     listSourceClasses.clear();
 
@@ -2499,7 +2500,7 @@ am_Error_e DatabaseHandler::getListSourceClasses(std::vector<am_SourceClass_s> &
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListCrossfaders(std::vector<am_Crossfader_s> & listCrossfaders) const
+am_Error_e CAmDatabaseHandler::getListCrossfaders(std::vector<am_Crossfader_s> & listCrossfaders) const
 {
     listCrossfaders.clear();
     sqlite3_stmt* query = NULL;
@@ -2534,7 +2535,7 @@ am_Error_e DatabaseHandler::getListCrossfaders(std::vector<am_Crossfader_s> & li
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListGateways(std::vector<am_Gateway_s> & listGateways) const
+am_Error_e CAmDatabaseHandler::getListGateways(std::vector<am_Gateway_s> & listGateways) const
 {
     listGateways.clear();
     sqlite3_stmt* query = NULL, *qSinkConnectionFormat = NULL, *qSourceConnectionFormat = NULL;
@@ -2620,7 +2621,7 @@ am_Error_e DatabaseHandler::getListGateways(std::vector<am_Gateway_s> & listGate
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListSinkClasses(std::vector<am_SinkClass_s> & listSinkClasses) const
+am_Error_e CAmDatabaseHandler::getListSinkClasses(std::vector<am_SinkClass_s> & listSinkClasses) const
 {
     listSinkClasses.clear();
 
@@ -2682,7 +2683,7 @@ am_Error_e DatabaseHandler::getListSinkClasses(std::vector<am_SinkClass_s> & lis
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListVisibleMainConnections(std::vector<am_MainConnectionType_s> & listConnections) const
+am_Error_e CAmDatabaseHandler::getListVisibleMainConnections(std::vector<am_MainConnectionType_s> & listConnections) const
 {
     listConnections.clear();
     sqlite3_stmt *query = NULL;
@@ -2719,7 +2720,7 @@ am_Error_e DatabaseHandler::getListVisibleMainConnections(std::vector<am_MainCon
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListMainSinks(std::vector<am_SinkType_s> & listMainSinks) const
+am_Error_e CAmDatabaseHandler::getListMainSinks(std::vector<am_SinkType_s> & listMainSinks) const
 {
     listMainSinks.clear();
     sqlite3_stmt* query = NULL;
@@ -2758,7 +2759,7 @@ am_Error_e DatabaseHandler::getListMainSinks(std::vector<am_SinkType_s> & listMa
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListMainSources(std::vector<am_SourceType_s> & listMainSources) const
+am_Error_e CAmDatabaseHandler::getListMainSources(std::vector<am_SourceType_s> & listMainSources) const
 {
     listMainSources.clear();
     sqlite3_stmt* query = NULL;
@@ -2795,7 +2796,7 @@ am_Error_e DatabaseHandler::getListMainSources(std::vector<am_SourceType_s> & li
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_MainSoundProperty_s> & listSoundProperties) const
+am_Error_e CAmDatabaseHandler::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_MainSoundProperty_s> & listSoundProperties) const
 {
     assert(sinkID!=0);
     if (!existSink(sinkID))
@@ -2832,7 +2833,7 @@ am_Error_e DatabaseHandler::getListMainSinkSoundProperties(const am_sinkID_t sin
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_MainSoundProperty_s> & listSourceProperties) const
+am_Error_e CAmDatabaseHandler::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_MainSoundProperty_s> & listSourceProperties) const
 {
     assert(sourceID!=0);
     if (!existSource(sourceID))
@@ -2869,7 +2870,7 @@ am_Error_e DatabaseHandler::getListMainSourceSoundProperties(const am_sourceID_t
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListSystemProperties(std::vector<am_SystemProperty_s> & listSystemProperties) const
+am_Error_e CAmDatabaseHandler::getListSystemProperties(std::vector<am_SystemProperty_s> & listSystemProperties) const
 {
     listSystemProperties.clear();
 
@@ -2903,7 +2904,7 @@ am_Error_e DatabaseHandler::getListSystemProperties(std::vector<am_SystemPropert
     return E_OK;
 }
 
-am_Error_e am::DatabaseHandler::getListSinkConnectionFormats(const am_sinkID_t sinkID, std::vector<am_ConnectionFormat_e> & listConnectionFormats) const
+am_Error_e am::CAmDatabaseHandler::getListSinkConnectionFormats(const am_sinkID_t sinkID, std::vector<am_ConnectionFormat_e> & listConnectionFormats) const
 {
     listConnectionFormats.clear();
     sqlite3_stmt *qConnectionFormat = NULL;
@@ -2927,7 +2928,7 @@ am_Error_e am::DatabaseHandler::getListSinkConnectionFormats(const am_sinkID_t s
     return E_OK;
 }
 
-am_Error_e am::DatabaseHandler::getListSourceConnectionFormats(const am_sourceID_t sourceID, std::vector<am_ConnectionFormat_e> & listConnectionFormats) const
+am_Error_e am::CAmDatabaseHandler::getListSourceConnectionFormats(const am_sourceID_t sourceID, std::vector<am_ConnectionFormat_e> & listConnectionFormats) const
 {
     listConnectionFormats.clear();
     sqlite3_stmt* qConnectionFormat = NULL;
@@ -2953,7 +2954,7 @@ am_Error_e am::DatabaseHandler::getListSourceConnectionFormats(const am_sourceID
     return E_OK;
 }
 
-am_Error_e am::DatabaseHandler::getListGatewayConnectionFormats(const am_gatewayID_t gatewayID, std::vector<bool> & listConnectionFormat) const
+am_Error_e am::CAmDatabaseHandler::getListGatewayConnectionFormats(const am_gatewayID_t gatewayID, std::vector<bool> & listConnectionFormat) const
 {
     ListConnectionFormat::const_iterator iter = mListConnectionFormat.begin();
     iter = mListConnectionFormat.find(gatewayID);
@@ -2968,7 +2969,7 @@ am_Error_e am::DatabaseHandler::getListGatewayConnectionFormats(const am_gateway
     return (E_OK);
 }
 
-am_Error_e DatabaseHandler::getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t & delay) const
+am_Error_e CAmDatabaseHandler::getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t & delay) const
 {
     assert(mainConnectionID!=0);
     delay = -1;
@@ -3003,7 +3004,7 @@ am_Error_e DatabaseHandler::getTimingInformation(const am_mainConnectionID_t mai
     return E_OK;
 }
 
-bool DatabaseHandler::sqQuery(const std::string& query)
+bool CAmDatabaseHandler::sqQuery(const std::string& query)
 {
     sqlite3_stmt* statement;
     int eCode = 0;
@@ -3015,7 +3016,7 @@ bool DatabaseHandler::sqQuery(const std::string& query)
     return true;
 }
 
-bool DatabaseHandler::openDatabase()
+bool CAmDatabaseHandler::openDatabase()
 {
     if (sqlite3_open_v2(mPath.c_str(), &mDatabase, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX, NULL) == SQLITE_OK)
     {
@@ -3026,7 +3027,7 @@ bool DatabaseHandler::openDatabase()
     return false;
 }
 
-am_Error_e DatabaseHandler::changeDelayMainConnection(const am_timeSync_t & delay, const am_mainConnectionID_t & connectionID)
+am_Error_e CAmDatabaseHandler::changeDelayMainConnection(const am_timeSync_t & delay, const am_mainConnectionID_t & connectionID)
 {
     assert(connectionID!=0);
 
@@ -3066,7 +3067,7 @@ am_Error_e DatabaseHandler::changeDelayMainConnection(const am_timeSync_t & dela
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::enterConnectionDB(const am_Connection_s& connection, am_connectionID_t& connectionID)
+am_Error_e CAmDatabaseHandler::enterConnectionDB(const am_Connection_s& connection, am_connectionID_t& connectionID)
 {
     assert(connection.connectionID==0);
     assert(connection.sinkID!=0);
@@ -3104,7 +3105,7 @@ am_Error_e DatabaseHandler::enterConnectionDB(const am_Connection_s& connection,
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::enterSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID)
+am_Error_e CAmDatabaseHandler::enterSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID)
 {
     assert(sinkClass.sinkClassID<DYNAMIC_ID_BOUNDARY);
     assert(!sinkClass.name.empty());
@@ -3192,7 +3193,7 @@ am_Error_e DatabaseHandler::enterSinkClassDB(const am_SinkClass_s & sinkClass, a
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::enterSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass)
+am_Error_e CAmDatabaseHandler::enterSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass)
 {
     assert(sourceClass.sourceClassID<DYNAMIC_ID_BOUNDARY);
     assert(!sourceClass.name.empty());
@@ -3281,7 +3282,7 @@ am_Error_e DatabaseHandler::enterSourceClassDB(am_sourceClass_t & sourceClassID,
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::enterSystemProperties(const std::vector<am_SystemProperty_s> & listSystemProperties)
+am_Error_e CAmDatabaseHandler::enterSystemProperties(const std::vector<am_SystemProperty_s> & listSystemProperties)
 {
     assert(!listSystemProperties.empty());
     sqlite3_stmt* query = NULL;
@@ -3319,7 +3320,7 @@ am_Error_e DatabaseHandler::enterSystemProperties(const std::vector<am_SystemPro
     return E_OK;
 }
 
-bool DatabaseHandler::existMainConnection(const am_mainConnectionID_t mainConnectionID) const
+bool CAmDatabaseHandler::existMainConnection(const am_mainConnectionID_t mainConnectionID) const
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT mainConnectionID FROM " + std::string(MAINCONNECTION_TABLE) + " WHERE mainConnectionID=" + i2s(mainConnectionID);
@@ -3337,7 +3338,7 @@ bool DatabaseHandler::existMainConnection(const am_mainConnectionID_t mainConnec
     return returnVal;
 }
 
-bool DatabaseHandler::existSource(const am_sourceID_t sourceID) const
+bool CAmDatabaseHandler::existSource(const am_sourceID_t sourceID) const
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT sourceID FROM " + std::string(SOURCE_TABLE) + " WHERE reserved=0 AND sourceID=" + i2s(sourceID);
@@ -3355,7 +3356,7 @@ bool DatabaseHandler::existSource(const am_sourceID_t sourceID) const
     return returnVal;
 }
 
-bool DatabaseHandler::existSourceNameOrID(const am_sourceID_t sourceID, const std::string & name) const
+bool CAmDatabaseHandler::existSourceNameOrID(const am_sourceID_t sourceID, const std::string & name) const
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT sourceID FROM " + std::string(SOURCE_TABLE) + " WHERE reserved=0 AND (name=? OR sourceID=?)";
@@ -3375,7 +3376,7 @@ bool DatabaseHandler::existSourceNameOrID(const am_sourceID_t sourceID, const st
     return returnVal;
 }
 
-bool DatabaseHandler::existSourceName(const std::string & name) const
+bool CAmDatabaseHandler::existSourceName(const std::string & name) const
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT sourceID FROM " + std::string(SOURCE_TABLE) + " WHERE reserved=0 AND name=?";
@@ -3394,7 +3395,7 @@ bool DatabaseHandler::existSourceName(const std::string & name) const
     return returnVal;
 }
 
-bool DatabaseHandler::existSink(const am_sinkID_t sinkID) const
+bool CAmDatabaseHandler::existSink(const am_sinkID_t sinkID) const
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT sinkID FROM " + std::string(SINK_TABLE) + " WHERE reserved=0 AND sinkID=" + i2s(sinkID);
@@ -3412,7 +3413,7 @@ bool DatabaseHandler::existSink(const am_sinkID_t sinkID) const
     return returnVal;
 }
 
-bool DatabaseHandler::existSinkNameOrID(const am_sinkID_t sinkID, const std::string & name) const
+bool CAmDatabaseHandler::existSinkNameOrID(const am_sinkID_t sinkID, const std::string & name) const
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT sinkID FROM " + std::string(SINK_TABLE) + " WHERE reserved=0 AND (name=? OR sinkID=?)";
@@ -3432,7 +3433,7 @@ bool DatabaseHandler::existSinkNameOrID(const am_sinkID_t sinkID, const std::str
     return returnVal;
 }
 
-bool DatabaseHandler::existSinkName(const std::string & name) const
+bool CAmDatabaseHandler::existSinkName(const std::string & name) const
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT sinkID FROM " + std::string(SINK_TABLE) + " WHERE reserved=0 AND name=?";
@@ -3451,7 +3452,7 @@ bool DatabaseHandler::existSinkName(const std::string & name) const
     return returnVal;
 }
 
-bool DatabaseHandler::existDomain(const am_domainID_t domainID) const
+bool CAmDatabaseHandler::existDomain(const am_domainID_t domainID) const
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT domainID FROM " + std::string(DOMAIN_TABLE) + " WHERE reserved=0 AND domainID=" + i2s(domainID);
@@ -3469,7 +3470,7 @@ bool DatabaseHandler::existDomain(const am_domainID_t domainID) const
     return returnVal;
 }
 
-bool DatabaseHandler::existGateway(const am_gatewayID_t gatewayID) const
+bool CAmDatabaseHandler::existGateway(const am_gatewayID_t gatewayID) const
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT gatewayID FROM " + std::string(GATEWAY_TABLE) + " WHERE gatewayID=" + i2s(gatewayID);
@@ -3487,7 +3488,7 @@ bool DatabaseHandler::existGateway(const am_gatewayID_t gatewayID) const
     return returnVal;
 }
 
-am_Error_e DatabaseHandler::getDomainOfSource(const am_sourceID_t sourceID, am_domainID_t & domainID) const
+am_Error_e CAmDatabaseHandler::getDomainOfSource(const am_sourceID_t sourceID, am_domainID_t & domainID) const
 {
     assert(sourceID!=0);
 
@@ -3509,7 +3510,7 @@ am_Error_e DatabaseHandler::getDomainOfSource(const am_sourceID_t sourceID, am_d
     return (returnVal);
 }
 
-am_Error_e am::DatabaseHandler::getDomainOfSink(const am_sinkID_t sinkID, am_domainID_t & domainID) const
+am_Error_e am::CAmDatabaseHandler::getDomainOfSink(const am_sinkID_t sinkID, am_domainID_t & domainID) const
 {
     assert(sinkID!=0);
 
@@ -3531,7 +3532,7 @@ am_Error_e am::DatabaseHandler::getDomainOfSink(const am_sinkID_t sinkID, am_dom
     return (returnVal);
 }
 
-bool DatabaseHandler::existSinkClass(const am_sinkClass_t sinkClassID) const
+bool CAmDatabaseHandler::existSinkClass(const am_sinkClass_t sinkClassID) const
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT sinkClassID FROM " + std::string(SINK_CLASS_TABLE) + " WHERE sinkClassID=" + i2s(sinkClassID);
@@ -3549,7 +3550,7 @@ bool DatabaseHandler::existSinkClass(const am_sinkClass_t sinkClassID) const
     return returnVal;
 }
 
-bool DatabaseHandler::existSourceClass(const am_sourceClass_t sourceClassID) const
+bool CAmDatabaseHandler::existSourceClass(const am_sourceClass_t sourceClassID) const
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT sourceClassID FROM " + std::string(SOURCE_CLASS_TABLE) + " WHERE sourceClassID=" + i2s(sourceClassID);
@@ -3567,7 +3568,7 @@ bool DatabaseHandler::existSourceClass(const am_sourceClass_t sourceClassID) con
     return returnVal;
 }
 
-am_Error_e DatabaseHandler::changeConnectionTimingInformation(const am_connectionID_t connectionID, const am_timeSync_t delay)
+am_Error_e CAmDatabaseHandler::changeConnectionTimingInformation(const am_connectionID_t connectionID, const am_timeSync_t delay)
 {
     assert(connectionID!=0);
 
@@ -3637,7 +3638,7 @@ am_Error_e DatabaseHandler::changeConnectionTimingInformation(const am_connectio
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeConnectionFinal(const am_connectionID_t connectionID)
+am_Error_e CAmDatabaseHandler::changeConnectionFinal(const am_connectionID_t connectionID)
 {
     assert(connectionID!=0);
 
@@ -3664,7 +3665,7 @@ am_Error_e DatabaseHandler::changeConnectionFinal(const am_connectionID_t connec
     return E_OK;
 }
 
-am_timeSync_t DatabaseHandler::calculateMainConnectionDelay(const am_mainConnectionID_t mainConnectionID) const
+am_timeSync_t CAmDatabaseHandler::calculateMainConnectionDelay(const am_mainConnectionID_t mainConnectionID) const
 {
     assert(mainConnectionID!=0);
     sqlite3_stmt* query = NULL;
@@ -3697,13 +3698,13 @@ am_timeSync_t DatabaseHandler::calculateMainConnectionDelay(const am_mainConnect
 
 }
 
-void DatabaseHandler::registerObserver(DatabaseObserver *iObserver)
+void CAmDatabaseHandler::registerObserver(CAmDatabaseObserver *iObserver)
 {
     assert(iObserver!=NULL);
     mDatabaseObserver = iObserver;
 }
 
-bool DatabaseHandler::sourceVisible(const am_sourceID_t sourceID) const
+bool CAmDatabaseHandler::sourceVisible(const am_sourceID_t sourceID) const
 {
     assert(sourceID!=0);
     sqlite3_stmt* query = NULL;
@@ -3724,7 +3725,7 @@ bool DatabaseHandler::sourceVisible(const am_sourceID_t sourceID) const
     return returnVal;
 }
 
-bool DatabaseHandler::sinkVisible(const am_sinkID_t sinkID) const
+bool CAmDatabaseHandler::sinkVisible(const am_sinkID_t sinkID) const
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT visible FROM " + std::string(SINK_TABLE) + " WHERE reserved=0 AND sinkID=" + i2s(sinkID);
@@ -3744,7 +3745,7 @@ bool DatabaseHandler::sinkVisible(const am_sinkID_t sinkID) const
     return returnVal;
 }
 
-bool DatabaseHandler::existConnection(const am_Connection_s connection)
+bool CAmDatabaseHandler::existConnection(const am_Connection_s connection)
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT connectionID FROM " + std::string(CONNECTION_TABLE) + " WHERE sinkID=? AND sourceID=? AND connectionFormat=? AND reserved=0";
@@ -3765,7 +3766,7 @@ bool DatabaseHandler::existConnection(const am_Connection_s connection)
     return returnVal;
 }
 
-bool DatabaseHandler::existConnectionID(const am_connectionID_t connectionID)
+bool CAmDatabaseHandler::existConnectionID(const am_connectionID_t connectionID)
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT connectionID FROM " + std::string(CONNECTION_TABLE) + " WHERE connectionID=? AND reserved=0";
@@ -3784,7 +3785,7 @@ bool DatabaseHandler::existConnectionID(const am_connectionID_t connectionID)
     return returnVal;
 }
 
-bool DatabaseHandler::existcrossFader(const am_crossfaderID_t crossfaderID) const
+bool CAmDatabaseHandler::existcrossFader(const am_crossfaderID_t crossfaderID) const
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT crossfaderID FROM " + std::string(CROSSFADER_TABLE) + " WHERE crossfaderID=?";
@@ -3803,7 +3804,7 @@ bool DatabaseHandler::existcrossFader(const am_crossfaderID_t crossfaderID) cons
     return returnVal;
 }
 
-am_Error_e DatabaseHandler::getSoureState(const am_sourceID_t sourceID, am_SourceState_e & sourceState) const
+am_Error_e CAmDatabaseHandler::getSoureState(const am_sourceID_t sourceID, am_SourceState_e & sourceState) const
 {
     assert(sourceID!=0);
     sqlite3_stmt* query = NULL;
@@ -3823,7 +3824,7 @@ am_Error_e DatabaseHandler::getSoureState(const am_sourceID_t sourceID, am_Sourc
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeSourceState(const am_sourceID_t sourceID, const am_SourceState_e sourceState)
+am_Error_e CAmDatabaseHandler::changeSourceState(const am_sourceID_t sourceID, const am_SourceState_e sourceState)
 {
     assert(sourceID!=0);
     assert(sourceState>=SS_UNKNNOWN && sourceState<=SS_MAX);
@@ -3848,7 +3849,7 @@ am_Error_e DatabaseHandler::changeSourceState(const am_sourceID_t sourceID, cons
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getSinkVolume(const am_sinkID_t sinkID, am_volume_t & volume) const
+am_Error_e CAmDatabaseHandler::getSinkVolume(const am_sinkID_t sinkID, am_volume_t & volume) const
 {
     assert(sinkID!=0);
     sqlite3_stmt* query = NULL;
@@ -3868,7 +3869,7 @@ am_Error_e DatabaseHandler::getSinkVolume(const am_sinkID_t sinkID, am_volume_t
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getSourceVolume(const am_sourceID_t sourceID, am_volume_t & volume) const
+am_Error_e CAmDatabaseHandler::getSourceVolume(const am_sourceID_t sourceID, am_volume_t & volume) const
 {
     assert(sourceID!=0);
     sqlite3_stmt* query = NULL;
@@ -3888,7 +3889,7 @@ am_Error_e DatabaseHandler::getSourceVolume(const am_sourceID_t sourceID, am_vol
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_SoundPropertyType_e propertyType, uint16_t & value) const
+am_Error_e CAmDatabaseHandler::getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_SoundPropertyType_e propertyType, uint16_t & value) const
 {
     assert(sinkID!=0);
     if (!existSink(sinkID))
@@ -3921,7 +3922,7 @@ am_Error_e DatabaseHandler::getSinkSoundPropertyValue(const am_sinkID_t sinkID,
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_SoundPropertyType_e propertyType, uint16_t & value) const
+am_Error_e CAmDatabaseHandler::getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_SoundPropertyType_e propertyType, uint16_t & value) const
 {
     assert(sourceID!=0);
     if (!existSource(sourceID))
@@ -3954,7 +3955,7 @@ am_Error_e DatabaseHandler::getSourceSoundPropertyValue(const am_sourceID_t sour
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getDomainState(const am_domainID_t domainID, am_DomainState_e state) const
+am_Error_e CAmDatabaseHandler::getDomainState(const am_domainID_t domainID, am_DomainState_e state) const
 {
     assert(domainID!=0);
     sqlite3_stmt* query = NULL;
@@ -3975,7 +3976,7 @@ am_Error_e DatabaseHandler::getDomainState(const am_domainID_t domainID, am_Doma
 
 }
 
-am_Error_e DatabaseHandler::peekDomain(const std::string & name, am_domainID_t & domainID)
+am_Error_e CAmDatabaseHandler::peekDomain(const std::string & name, am_domainID_t & domainID)
 {
     sqlite3_stmt* query = NULL, *queryInsert = NULL;
     std::string command = "SELECT domainID FROM " + std::string(DOMAIN_TABLE) + " WHERE name=?";
@@ -4014,7 +4015,7 @@ am_Error_e DatabaseHandler::peekDomain(const std::string & name, am_domainID_t &
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::peekSink(const std::string & name, am_sinkID_t & sinkID)
+am_Error_e CAmDatabaseHandler::peekSink(const std::string & name, am_sinkID_t & sinkID)
 {
     sqlite3_stmt* query = NULL, *queryInsert = NULL;
     std::string command = "SELECT sinkID FROM " + std::string(SINK_TABLE) + " WHERE name=?";
@@ -4061,7 +4062,7 @@ am_Error_e DatabaseHandler::peekSink(const std::string & name, am_sinkID_t & sin
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::peekSource(const std::string & name, am_sourceID_t & sourceID)
+am_Error_e CAmDatabaseHandler::peekSource(const std::string & name, am_sourceID_t & sourceID)
 {
     sqlite3_stmt* query = NULL, *queryInsert = NULL;
     std::string command = "SELECT sourceID FROM " + std::string(SOURCE_TABLE) + " WHERE name=?";
@@ -4108,7 +4109,7 @@ am_Error_e DatabaseHandler::peekSource(const std::string & name, am_sourceID_t &
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeSinkVolume(const am_sinkID_t sinkID, const am_volume_t volume)
+am_Error_e CAmDatabaseHandler::changeSinkVolume(const am_sinkID_t sinkID, const am_volume_t volume)
 {
     assert(sinkID!=0);
 
@@ -4141,7 +4142,7 @@ am_Error_e DatabaseHandler::changeSinkVolume(const am_sinkID_t sinkID, const am_
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeSourceVolume(const am_sourceID_t sourceID, const am_volume_t volume)
+am_Error_e CAmDatabaseHandler::changeSourceVolume(const am_sourceID_t sourceID, const am_volume_t volume)
 {
     assert(sourceID!=0);
 
@@ -4174,7 +4175,7 @@ am_Error_e DatabaseHandler::changeSourceVolume(const am_sourceID_t sourceID, con
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeSourceSoundPropertyDB(const am_SoundProperty_s & soundProperty, const am_sourceID_t sourceID)
+am_Error_e CAmDatabaseHandler::changeSourceSoundPropertyDB(const am_SoundProperty_s & soundProperty, const am_sourceID_t sourceID)
 {
     assert(soundProperty.type>=SP_UNKNOWN && soundProperty.type<=SP_MAX);
     assert(sourceID!=0);
@@ -4209,7 +4210,7 @@ am_Error_e DatabaseHandler::changeSourceSoundPropertyDB(const am_SoundProperty_s
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeSinkSoundPropertyDB(const am_SoundProperty_s & soundProperty, const am_sinkID_t sinkID)
+am_Error_e CAmDatabaseHandler::changeSinkSoundPropertyDB(const am_SoundProperty_s & soundProperty, const am_sinkID_t sinkID)
 {
     assert(soundProperty.type>=SP_UNKNOWN && soundProperty.type<=SP_MAX);
     assert(sinkID!=0);
@@ -4242,7 +4243,7 @@ am_Error_e DatabaseHandler::changeSinkSoundPropertyDB(const am_SoundProperty_s &
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::changeCrossFaderHotSink(const am_crossfaderID_t crossfaderID, const am_HotSink_e hotsink)
+am_Error_e CAmDatabaseHandler::changeCrossFaderHotSink(const am_crossfaderID_t crossfaderID, const am_HotSink_e hotsink)
 {
     assert(crossfaderID!=0);
     assert(hotsink>=HS_UNKNOWN && hotsink>=HS_MAX);
@@ -4275,14 +4276,14 @@ am_Error_e DatabaseHandler::changeCrossFaderHotSink(const am_crossfaderID_t cros
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getRoutingTree(bool onlyfree, RoutingTree& tree, std::vector<RoutingTreeItem*>& flatTree)
+am_Error_e CAmDatabaseHandler::getRoutingTree(bool onlyfree, CAmRoutingTree& tree, std::vector<CAmRoutingTreeItem*>& flatTree)
 {
     sqlite3_stmt* query = NULL;
     int eCode = 0;
     size_t i = 0;
     std::string command;
     am_domainID_t rootID = tree.returnRootDomainID();
-    RoutingTreeItem *parent = tree.returnRootItem();
+    CAmRoutingTreeItem *parent = tree.returnRootItem();
 
     if (onlyfree)
     {
@@ -4327,7 +4328,7 @@ am_Error_e DatabaseHandler::getRoutingTree(bool onlyfree, RoutingTree& tree, std
     return (E_OK);
 }
 
-am_Error_e am::DatabaseHandler::peekSinkClassID(const std::string & name, am_sinkClass_t & sinkClassID)
+am_Error_e am::CAmDatabaseHandler::peekSinkClassID(const std::string & name, am_sinkClass_t & sinkClassID)
 {
     if (name.empty())
         return E_NON_EXISTENT;
@@ -4359,7 +4360,7 @@ am_Error_e am::DatabaseHandler::peekSinkClassID(const std::string & name, am_sin
     return returnVal;
 }
 
-am_Error_e am::DatabaseHandler::peekSourceClassID(const std::string & name, am_sourceClass_t & sourceClassID)
+am_Error_e am::CAmDatabaseHandler::peekSourceClassID(const std::string & name, am_sourceClass_t & sourceClassID)
 {
     if (name.empty())
         return E_NON_EXISTENT;
@@ -4391,11 +4392,11 @@ am_Error_e am::DatabaseHandler::peekSourceClassID(const std::string & name, am_s
     return returnVal;
 }
 
-void DatabaseHandler::createTables()
+void CAmDatabaseHandler::createTables()
 {
     for (uint16_t i = 0; i < sizeof(databaseTables) / sizeof(databaseTables[0]); i++)
     {
         assert(sqQuery("CREATE TABLE " + databaseTables[i]));
     }
 }
-
+}
diff --git a/AudioManagerDaemon/src/CAmDatabaseObserver.cpp b/AudioManagerDaemon/src/CAmDatabaseObserver.cpp
new file mode 100644
index 0000000..9bbc275
--- /dev/null
+++ b/AudioManagerDaemon/src/CAmDatabaseObserver.cpp
@@ -0,0 +1,207 @@
+/**
+ * Copyright (C) 2011, BMW AG
+ *
+ * GeniviAudioMananger AudioManagerDaemon
+ *
+ * \file CAmDatabaseObserver.cpp
+ *
+ * \date 20-Oct-2011 3:42:04 PM
+ * \author Christian Mueller (christian.ei.mueller@bmw.de)
+ *
+ * \section License
+ * GNU Lesser General Public License, version 2.1, with special exception (GENIVI clause)
+ * Copyright (C) 2011, BMW AG Christian Mueller  Christian.ei.mueller@bmw.de
+ *
+ * This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License, version 2.1, as published by the Free Software Foundation.
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License, version 2.1, for more details.
+ * You should have received a copy of the GNU Lesser General Public License, version 2.1, along with this program; if not, see <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ * Note that the copyright holders assume that the GNU Lesser General Public License, version 2.1, may also be applicable to programs even in cases in which the program is not a library in the technical sense.
+ * Linking AudioManager statiasyncCally or dynamiasyncCally with other modules is making a combined work based on AudioManager. You may license such other modules under the GNU Lesser General Public License, version 2.1. If you do not want to license your linked modules under the GNU Lesser General Public License, version 2.1, you may use the program under the following exception.
+ * As a special exception, the copyright holders of AudioManager give you permission to combine AudioManager with software programs or libraries that are released under any license unless such a combination is not permitted by the license of such a software program or library. You may copy and distribute such a system following the terms of the GNU Lesser General Public License, version 2.1, including this special exception, for AudioManager and the licenses of the other code concerned.
+ * Note that people who make modified versions of AudioManager are not obligated to grant this special exception for their modified versions; it is their choice whether to do so. The GNU Lesser General Public License, version 2.1, gives permission to release a modified version without this exception; this exception also makes it possible to release a modified version which carries forward this exception.
+ *
+ */
+
+#include "CAmDatabaseObserver.h"
+#include <string.h>
+#include <cassert>
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include "CAmCommandSender.h"
+#include "CAmRoutingSender.h"
+#include "CAmTelnetServer.h"
+#include "shared/CAmDltWrapper.h"
+#include "shared/CAmSerializer.h"
+
+namespace am {
+
+CAmDatabaseObserver::CAmDatabaseObserver(CAmCommandSender *iCommandSender, CAmRoutingSender *iRoutingSender, CAmSocketHandler *iSocketHandler) :
+        mCommandSender(iCommandSender), //
+        mRoutingSender(iRoutingSender), //
+        mSerializer(iSocketHandler) //
+{
+    assert(mCommandSender!=0);
+    assert(mRoutingSender!=0);
+    assert(iSocketHandler!=0);
+}
+
+CAmDatabaseObserver::CAmDatabaseObserver(CAmCommandSender *iCommandSender, CAmRoutingSender *iRoutingSender, CAmSocketHandler *iSocketHandler, CAmTelnetServer *iTelnetServer) :
+        mCommandSender(iCommandSender), //
+        mRoutingSender(iRoutingSender), //
+        mTelnetServer(iTelnetServer), //
+        mSerializer(iSocketHandler) //
+{
+    assert(mTelnetServer!=0);
+    assert(mCommandSender!=0);
+    assert(mRoutingSender!=0);
+    assert(iSocketHandler!=0);
+}
+
+CAmDatabaseObserver::~CAmDatabaseObserver()
+{
+}
+
+void CAmDatabaseObserver::newMainConnection(const am_MainConnectionType_s& mainConnection)
+{
+    mSerializer.asyncCall<CAmCommandSender, const am_MainConnectionType_s>(mCommandSender, &CAmCommandSender::cbNewMainConnection, mainConnection);
+}
+
+void CAmDatabaseObserver::removedMainConnection(const am_mainConnectionID_t mainConnection)
+{
+    mSerializer.asyncCall<CAmCommandSender, const am_mainConnectionID_t>(mCommandSender, &CAmCommandSender::cbRemovedMainConnection, mainConnection);
+}
+
+void CAmDatabaseObserver::newSink(const am_Sink_s& sink)
+{
+    mRoutingSender->addSinkLookup(sink);
+    if (sink.visible)
+    {
+        am_SinkType_s s;
+        s.availability = sink.available;
+        s.muteState = sink.muteState;
+        s.name = sink.name;
+        s.sinkClassID = sink.sinkClassID;
+        s.sinkID = sink.sinkID;
+        s.volume = sink.mainVolume;
+        mSerializer.asyncCall<CAmCommandSender, const am_SinkType_s>(mCommandSender, &CAmCommandSender::cbNewSink, s);
+    }
+}
+
+void CAmDatabaseObserver::newSource(const am_Source_s& source)
+{
+    mRoutingSender->addSourceLookup(source);
+    if (source.visible)
+    {
+        am_SourceType_s s;
+        s.availability = source.available;
+        s.name = source.name;
+        s.sourceClassID = source.sourceClassID;
+        s.sourceID = source.sourceID;
+        mSerializer.asyncCall<CAmCommandSender, const am_SourceType_s>(mCommandSender, &CAmCommandSender::cbNewSource, s);
+    }
+}
+
+void CAmDatabaseObserver::newDomain(const am_Domain_s& domain)
+{
+    mRoutingSender->addDomainLookup(domain);
+}
+
+void CAmDatabaseObserver::newGateway(const am_Gateway_s& gateway)
+{
+    (void) gateway;
+    //todo: implement something
+}
+
+void CAmDatabaseObserver::newCrossfader(const am_Crossfader_s& crossfader)
+{
+    mRoutingSender->addCrossfaderLookup(crossfader);
+}
+
+void CAmDatabaseObserver::removedSink(const am_sinkID_t sinkID, const bool visible)
+{
+    mRoutingSender->removeSinkLookup(sinkID);
+
+    if (visible)
+        mSerializer.asyncCall<CAmCommandSender, const am_sinkID_t>(mCommandSender, &CAmCommandSender::cbRemovedSink, sinkID);
+}
+
+void CAmDatabaseObserver::removedSource(const am_sourceID_t sourceID, const bool visible)
+{
+    mRoutingSender->removeSourceLookup(sourceID);
+
+    if (visible)
+        mSerializer.asyncCall<CAmCommandSender, const am_sourceID_t>(mCommandSender, &CAmCommandSender::cbRemovedSource, sourceID);
+}
+
+void CAmDatabaseObserver::removeDomain(const am_domainID_t domainID)
+{
+    mRoutingSender->removeDomainLookup(domainID);
+}
+
+void CAmDatabaseObserver::removeGateway(const am_gatewayID_t gatewayID)
+{
+    (void) gatewayID;
+    //todo: implement something?
+}
+
+void CAmDatabaseObserver::removeCrossfader(const am_crossfaderID_t crossfaderID)
+{
+    mRoutingSender->removeCrossfaderLookup(crossfaderID);
+}
+
+void CAmDatabaseObserver::numberOfSinkClassesChanged()
+{
+    mSerializer.asyncCall<CAmCommandSender>(mCommandSender, &CAmCommandSender::cbNumberOfSinkClassesChanged);
+}
+
+void CAmDatabaseObserver::numberOfSourceClassesChanged()
+{
+    mSerializer.asyncCall<CAmCommandSender>(mCommandSender, &CAmCommandSender::cbNumberOfSourceClassesChanged);
+}
+
+void CAmDatabaseObserver::mainConnectionStateChanged(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState)
+{
+    mSerializer.asyncCall<CAmCommandSender, const am_connectionID_t, const am_ConnectionState_e>(mCommandSender, &CAmCommandSender::cbMainConnectionStateChanged, connectionID, connectionState);
+}
+
+void CAmDatabaseObserver::mainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty)
+{
+    mSerializer.asyncCall<CAmCommandSender, const am_sinkID_t, const am_MainSoundProperty_s&>(mCommandSender, &CAmCommandSender::cbMainSinkSoundPropertyChanged, sinkID, SoundProperty);
+}
+
+void CAmDatabaseObserver::mainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s & SoundProperty)
+{
+    mSerializer.asyncCall<CAmCommandSender, const am_sourceID_t, const am_MainSoundProperty_s&>(mCommandSender, &CAmCommandSender::cbMainSourceSoundPropertyChanged, sourceID, SoundProperty);
+}
+
+void CAmDatabaseObserver::sinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s & availability)
+{
+    mSerializer.asyncCall<CAmCommandSender, const am_sinkID_t, const am_Availability_s&>(mCommandSender, &CAmCommandSender::cbSinkAvailabilityChanged, sinkID, availability);
+}
+
+void CAmDatabaseObserver::sourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s & availability)
+{
+    mSerializer.asyncCall<CAmCommandSender, const am_sourceID_t, const am_Availability_s&>(mCommandSender, &CAmCommandSender::cbSourceAvailabilityChanged, sourceID, availability);
+}
+
+void CAmDatabaseObserver::volumeChanged(const am_sinkID_t sinkID, const am_mainVolume_t volume)
+{
+    mSerializer.asyncCall<CAmCommandSender, const am_sinkID_t, const am_mainVolume_t>(mCommandSender, &CAmCommandSender::cbVolumeChanged, sinkID, volume);
+}
+
+void CAmDatabaseObserver::sinkMuteStateChanged(const am_sinkID_t sinkID, const am_MuteState_e muteState)
+{
+    mSerializer.asyncCall<CAmCommandSender, const am_sinkID_t, const am_MuteState_e>(mCommandSender, &CAmCommandSender::cbSinkMuteStateChanged, sinkID, muteState);
+}
+
+void CAmDatabaseObserver::systemPropertyChanged(const am_SystemProperty_s& SystemProperty)
+{
+    mSerializer.asyncCall<CAmCommandSender, const am_SystemProperty_s&>(mCommandSender, &CAmCommandSender::cbSystemPropertyChanged, SystemProperty);
+}
+
+void CAmDatabaseObserver::timingInformationChanged(const am_mainConnectionID_t mainConnection, const am_timeSync_t time)
+{
+    mSerializer.asyncCall<CAmCommandSender, const am_mainConnectionID_t, const am_timeSync_t>(mCommandSender, &CAmCommandSender::cbTimingInformationChanged, mainConnection, time);
+}
+}
diff --git a/AudioManagerDaemon/src/DBusWrapper.cpp b/AudioManagerDaemon/src/CAmDbusWrapper.cpp
index 71352ef..082d62f 100644
--- a/AudioManagerDaemon/src/DBusWrapper.cpp
+++ b/AudioManagerDaemon/src/CAmDbusWrapper.cpp
@@ -3,7 +3,7 @@
  *
  * GeniviAudioMananger AudioManagerDaemon
  *
- * \file SocketHandler.cpp
+ * \file CAmSocketHandler.cpp
  *
  * \date 20-Oct-2011 3:42:04 PM
  * \author Christian Mueller (christian.ei.mueller@bmw.de)
@@ -22,17 +22,18 @@
  *
  */
 
-#include <dbus/DBusWrapper.h>
-#include <SocketHandler.h>
+#include "shared/CAmDbusWrapper.h"
 #include <config.h>
 #include <fstream>
 #include <sstream>
 #include <string>
 #include <cassert>
 #include <cstdlib>
-#include "DLTWrapper.h"
+#include "shared/CAmDltWrapper.h"
+#include "shared/CAmSocketHandler.h"
 
-using namespace am;
+namespace am
+{
 
 #define ROOT_INTROSPECT_XML												\
 DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE								\
@@ -43,59 +44,59 @@ DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE								\
 "</method>"							      								\
 "</interface>"															\
 
-DBusWrapper* DBusWrapper::mReference = NULL;
+CAmDbusWrapper* CAmDbusWrapper::mpReference = NULL;
 
-DBusWrapper::DBusWrapper(SocketHandler* socketHandler) :
-        pDbusDispatchCallback(this, &DBusWrapper::dbusDispatchCallback), //
-        pDbusFireCallback(this, &DBusWrapper::dbusFireCallback), //
-        pDbusCheckCallback(this, &DBusWrapper::dbusCheckCallback), //
-        pDbusTimerCallback(this, &DBusWrapper::dbusTimerCallback), //
-        mDbusConnection(0), //
+CAmDbusWrapper::CAmDbusWrapper(CAmSocketHandler* socketHandler) :
+        pDbusDispatchCallback(this, &CAmDbusWrapper::dbusDispatchCallback), //
+        pDbusFireCallback(this, &CAmDbusWrapper::dbusFireCallback), //
+        pDbusCheckCallback(this, &CAmDbusWrapper::dbusCheckCallback), //
+        pDbusTimerCallback(this, &CAmDbusWrapper::dbusTimerCallback), //
+        mpDbusConnection(0), //
         mDBusError(), //
-        mNodesList(), //
-        mListTimerhandlePointer(), //
-        mSocketHandler(socketHandler)
+        mListNodes(), //
+        mpListTimerhandles(), //
+        mpSocketHandler(socketHandler)
 {
-    assert(mSocketHandler!=0);
+    assert(mpSocketHandler!=0);
 
     dbus_error_init(&mDBusError);
     logInfo("DBusWrapper::DBusWrapper Opening DBus connection");
-    mDbusConnection = dbus_bus_get(DBUS_BUS_SESSION, &mDBusError);
+    mpDbusConnection = dbus_bus_get(DBUS_BUS_SESSION, &mDBusError);
     if (dbus_error_is_set(&mDBusError))
     {
         logError("DBusWrapper::DBusWrapper Error while getting the DBus");
         dbus_error_free(&mDBusError);
     }
-    if (NULL == mDbusConnection)
+    if (NULL == mpDbusConnection)
     {
         logError("DBusWrapper::DBusWrapper DBus Connection is null");
     }
 
     //then we need to adopt the dbus to our mainloop:
     //first, we are old enought to live longer then the connection:
-    dbus_connection_set_exit_on_disconnect(mDbusConnection, FALSE);
+    dbus_connection_set_exit_on_disconnect(mpDbusConnection, FALSE);
 
     //we do not need the manual dispatching, since it is not allowed to call from a different thread. So leave it uncommented:
     //dbus_connection_set_dispatch_status_function
 
     //add watch functions:
-    dbus_bool_t watch = dbus_connection_set_watch_functions(mDbusConnection, addWatch, removeWatch, toogleWatch, this, NULL);
+    dbus_bool_t watch = dbus_connection_set_watch_functions(mpDbusConnection, addWatch, removeWatch, toogleWatch, this, NULL);
     if (!watch)
     {
         logError("DBusWrapper::DBusWrapper Registering of watch functions failed");
     }
 
     //add timer functions:
-    dbus_bool_t timer = dbus_connection_set_timeout_functions(mDbusConnection, addTimeout, removeTimeout, toggleTimeout, this, NULL);
+    dbus_bool_t timer = dbus_connection_set_timeout_functions(mpDbusConnection, addTimeout, removeTimeout, toggleTimeout, this, NULL);
     if (!timer)
     {
         logError("DBusWrapper::DBusWrapper Registering of timer functions failed");
     }
 
     //register callback for Introspectio
-    mObjectPathVTable.message_function = DBusWrapper::cbRootIntrospection;
-    dbus_connection_register_object_path(mDbusConnection, DBUS_SERVICE_OBJECT_PATH, &mObjectPathVTable, this);
-    int ret = dbus_bus_request_name(mDbusConnection, DBUS_SERVICE_PREFIX, DBUS_NAME_FLAG_DO_NOT_QUEUE, &mDBusError);
+    mObjectPathVTable.message_function = CAmDbusWrapper::cbRootIntrospection;
+    dbus_connection_register_object_path(mpDbusConnection, DBUS_SERVICE_OBJECT_PATH, &mObjectPathVTable, this);
+    int ret = dbus_bus_request_name(mpDbusConnection, DBUS_SERVICE_PREFIX, DBUS_NAME_FLAG_DO_NOT_QUEUE, &mDBusError);
     if (dbus_error_is_set(&mDBusError))
     {
         logError("DBusWrapper::DBusWrapper Name Error",mDBusError.message);
@@ -108,42 +109,42 @@ DBusWrapper::DBusWrapper(SocketHandler* socketHandler) :
     }
 }
 
-DBusWrapper::~DBusWrapper()
+CAmDbusWrapper::~CAmDbusWrapper()
 {
     //close the connection again
     logInfo("DBusWrapper::~DBusWrapper Closing DBus connection");
-    dbus_connection_unref(mDbusConnection);
+    dbus_connection_unref(mpDbusConnection);
 
     //clean up all timerhandles we created but did not delete before
-    std::vector<sh_timerHandle_t*>::iterator it = mListTimerhandlePointer.begin();
-    for (; it != mListTimerhandlePointer.end(); ++it)
+    std::vector<sh_timerHandle_t*>::iterator it = mpListTimerhandles.begin();
+    for (; it != mpListTimerhandles.end(); ++it)
     {
         delete *it;
     }
 }
 
-void DBusWrapper::registerCallback(const DBusObjectPathVTable* vtable, const std::string& path, void* userdata)
+void CAmDbusWrapper::registerCallback(const DBusObjectPathVTable* vtable, const std::string& path, void* userdata)
 {
     logInfo("DBusWrapper::~registerCallback register callback:",path);
 
     std::string completePath = std::string(DBUS_SERVICE_OBJECT_PATH) + "/" + path;
     dbus_error_init(&mDBusError);
-    mDbusConnection = dbus_bus_get(DBUS_BUS_SESSION, &mDBusError);
-    dbus_connection_register_object_path(mDbusConnection, completePath.c_str(), vtable, userdata);
+    mpDbusConnection = dbus_bus_get(DBUS_BUS_SESSION, &mDBusError);
+    dbus_connection_register_object_path(mpDbusConnection, completePath.c_str(), vtable, userdata);
     if (dbus_error_is_set(&mDBusError))
     {
         logError("DBusWrapper::registerCallack error: ",mDBusError.message);
         dbus_error_free(&mDBusError);
     }
-    mNodesList.push_back(path);
+    mListNodes.push_back(path);
 }
 
-DBusHandlerResult DBusWrapper::cbRootIntrospection(DBusConnection *conn, DBusMessage *msg, void *reference)
+DBusHandlerResult CAmDbusWrapper::cbRootIntrospection(DBusConnection *conn, DBusMessage *msg, void *reference)
 {
     logInfo("DBusWrapper::~cbRootIntrospection called:");
 
-    mReference = (DBusWrapper*) reference;
-    std::list<std::string> nodesList = mReference->mNodesList;
+    mpReference = (CAmDbusWrapper*) reference;
+    std::list<std::string> nodesList = mpReference->mListNodes;
     DBusMessage * reply;
     DBusMessageIter args;
     dbus_uint32_t serial = 0;
@@ -187,19 +188,19 @@ DBusHandlerResult DBusWrapper::cbRootIntrospection(DBusConnection *conn, DBusMes
     }
 }
 
-void DBusWrapper::getDBusConnection(DBusConnection *& connection) const
+void CAmDbusWrapper::getDBusConnection(DBusConnection *& connection) const
 {
-    connection = mDbusConnection;
+    connection = mpDbusConnection;
 }
 
-dbus_bool_t DBusWrapper::addWatch(DBusWatch *watch, void *userData)
+dbus_bool_t CAmDbusWrapper::addWatch(DBusWatch *watch, void *userData)
 {
-    mReference = (DBusWrapper*) userData;
-    assert(mReference!=0);
-    return mReference->addWatchDelegate(watch, userData);
+    mpReference = (CAmDbusWrapper*) userData;
+    assert(mpReference!=0);
+    return mpReference->addWatchDelegate(watch, userData);
 }
 
-dbus_bool_t DBusWrapper::addWatchDelegate(DBusWatch * watch, void* userData)
+dbus_bool_t CAmDbusWrapper::addWatchDelegate(DBusWatch * watch, void* userData)
 {
     (void) userData;
     int16_t event = 0;
@@ -216,7 +217,7 @@ dbus_bool_t DBusWrapper::addWatchDelegate(DBusWatch * watch, void* userData)
     }
 
     logInfo("DBusWrapper::addWatchDelegate entered new watch, fd=",dbus_watch_get_unix_fd(watch),"event flag=",event);
-    am_Error_e error = mSocketHandler->addFDPoll(dbus_watch_get_unix_fd(watch), event, NULL, &pDbusFireCallback, &pDbusCheckCallback, &pDbusDispatchCallback, watch, handle);
+    am_Error_e error = mpSocketHandler->addFDPoll(dbus_watch_get_unix_fd(watch), event, NULL, &pDbusFireCallback, &pDbusCheckCallback, &pDbusDispatchCallback, watch, handle);
 
     //if everything is alright, add the watch and the handle to our map so we know this relationship
     if (error == E_OK && handle != 0)
@@ -228,32 +229,32 @@ dbus_bool_t DBusWrapper::addWatchDelegate(DBusWatch * watch, void* userData)
     return (true);
 }
 
-void DBusWrapper::removeWatch(DBusWatch *watch, void *userData)
+void CAmDbusWrapper::removeWatch(DBusWatch *watch, void *userData)
 {
-    mReference = (DBusWrapper*) userData;
-    assert(mReference!=0);
-    mReference->removeWatchDelegate(watch, userData);
+    mpReference = (CAmDbusWrapper*) userData;
+    assert(mpReference!=0);
+    mpReference->removeWatchDelegate(watch, userData);
 }
 
-void DBusWrapper::removeWatchDelegate(DBusWatch *watch, void *userData)
+void CAmDbusWrapper::removeWatchDelegate(DBusWatch *watch, void *userData)
 {
     (void) userData;
     std::map<DBusWatch*, sh_pollHandle_t>::iterator iterator = mMapHandleWatch.begin();
     iterator = mMapHandleWatch.find(watch);
     if (iterator != mMapHandleWatch.end())
-        mSocketHandler->removeFDPoll(iterator->second);
+        mpSocketHandler->removeFDPoll(iterator->second);
     logInfo("DBusWrapper::removeWatch removed watch with handle",iterator->second);
     mMapHandleWatch.erase(iterator);
 }
 
-void DBusWrapper::toogleWatch(DBusWatch *watch, void *userData)
+void CAmDbusWrapper::toogleWatch(DBusWatch *watch, void *userData)
 {
-    mReference = (DBusWrapper*) userData;
-    assert(mReference!=0);
-    mReference->toogleWatchDelegate(watch, userData);
+    mpReference = (CAmDbusWrapper*) userData;
+    assert(mpReference!=0);
+    mpReference->toogleWatchDelegate(watch, userData);
 }
 
-void DBusWrapper::toogleWatchDelegate(DBusWatch *watch, void *userData)
+void CAmDbusWrapper::toogleWatchDelegate(DBusWatch *watch, void *userData)
 {
     (void) userData;
     int16_t event = 0;
@@ -270,18 +271,18 @@ void DBusWrapper::toogleWatchDelegate(DBusWatch *watch, void *userData)
     std::map<DBusWatch*, sh_pollHandle_t>::iterator iterator = mMapHandleWatch.begin();
     iterator = mMapHandleWatch.find(watch);
     if (iterator != mMapHandleWatch.end())
-        mSocketHandler->updateEventFlags(iterator->second, event);
+        mpSocketHandler->updateEventFlags(iterator->second, event);
     logInfo("DBusWrapper::toogleWatchDelegate watch was toggeled");
 }
 
-dbus_bool_t DBusWrapper::addTimeout(DBusTimeout *timeout, void* userData)
+dbus_bool_t CAmDbusWrapper::addTimeout(DBusTimeout *timeout, void* userData)
 {
-    mReference = (DBusWrapper*) userData;
-    assert(mReference!=0);
-    return mReference->addTimeoutDelegate(timeout, userData);
+    mpReference = (CAmDbusWrapper*) userData;
+    assert(mpReference!=0);
+    return mpReference->addTimeoutDelegate(timeout, userData);
 }
 
-dbus_bool_t DBusWrapper::addTimeoutDelegate(DBusTimeout *timeout, void* userData)
+dbus_bool_t CAmDbusWrapper::addTimeoutDelegate(DBusTimeout *timeout, void* userData)
 {
     if (!dbus_timeout_get_enabled(timeout))
         return false;
@@ -294,11 +295,11 @@ dbus_bool_t DBusWrapper::addTimeoutDelegate(DBusTimeout *timeout, void* userData
 
     //prepare handle and callback. new is eval, but there is no other choice because we need the pointer!
     sh_timerHandle_t* handle = new sh_timerHandle_t;
-    mListTimerhandlePointer.push_back(handle);
-    shTimerCallBack* buffer = &pDbusTimerCallback;
+    mpListTimerhandles.push_back(handle);
+    CAmShTimerCallBack* buffer = &pDbusTimerCallback;
 
     //add the timer to the pollLoop
-    mSocketHandler->addTimer(pollTimeout, buffer, *handle, timeout);
+    mpSocketHandler->addTimer(pollTimeout, buffer, *handle, timeout);
 
     //save the handle with dbus context
     dbus_timeout_set_data(timeout, handle, NULL);
@@ -309,27 +310,27 @@ dbus_bool_t DBusWrapper::addTimeoutDelegate(DBusTimeout *timeout, void* userData
     return true;
 }
 
-void DBusWrapper::removeTimeout(DBusTimeout *timeout, void* userData)
+void CAmDbusWrapper::removeTimeout(DBusTimeout *timeout, void* userData)
 {
-    mReference = (DBusWrapper*) userData;
-    assert(mReference!=0);
-    mReference->removeTimeoutDelegate(timeout, userData);
+    mpReference = (CAmDbusWrapper*) userData;
+    assert(mpReference!=0);
+    mpReference->removeTimeoutDelegate(timeout, userData);
 }
 
-void DBusWrapper::removeTimeoutDelegate(DBusTimeout *timeout, void* userData)
+void CAmDbusWrapper::removeTimeoutDelegate(DBusTimeout *timeout, void* userData)
 {
     (void) userData;
     //get the pointer to the handle and remove the timer
     sh_timerHandle_t* handle = (sh_timerHandle_t*) dbus_timeout_get_data(timeout);
-    mSocketHandler->removeTimer(*handle);
+    mpSocketHandler->removeTimer(*handle);
 
     //now go throught the timerlist and remove the pointer, free memory
-    std::vector<sh_timerHandle_t*>::iterator it = mListTimerhandlePointer.begin();
-    for (; it != mListTimerhandlePointer.end(); ++it)
+    std::vector<sh_timerHandle_t*>::iterator it = mpListTimerhandles.begin();
+    for (; it != mpListTimerhandles.end(); ++it)
     {
         if (*it == handle)
         {
-            mListTimerhandlePointer.erase(it);
+            mpListTimerhandles.erase(it);
             break;
         }
     }
@@ -337,40 +338,40 @@ void DBusWrapper::removeTimeoutDelegate(DBusTimeout *timeout, void* userData)
     logInfo("DBusWrapper::removeTimeoutDelegate a timeout was removed");
 }
 
-void DBusWrapper::toggleTimeout(DBusTimeout *timeout, void* userData)
+void CAmDbusWrapper::toggleTimeout(DBusTimeout *timeout, void* userData)
 {
-    mReference = (DBusWrapper*) userData;
-    assert(mReference!=0);
-    mReference->toggleTimeoutDelegate(timeout, userData);
+    mpReference = (CAmDbusWrapper*) userData;
+    assert(mpReference!=0);
+    mpReference->toggleTimeoutDelegate(timeout, userData);
 }
 
-bool am::DBusWrapper::dbusDispatchCallback(const sh_pollHandle_t handle, void *userData)
+bool am::CAmDbusWrapper::dbusDispatchCallback(const sh_pollHandle_t handle, void *userData)
 {
     (void) handle;
     (void) userData;
     bool returnVal = true;
-    dbus_connection_ref(mDbusConnection);
-    if (dbus_connection_dispatch(mDbusConnection) == DBUS_DISPATCH_COMPLETE)
+    dbus_connection_ref(mpDbusConnection);
+    if (dbus_connection_dispatch(mpDbusConnection) == DBUS_DISPATCH_COMPLETE)
         returnVal = false;
-    dbus_connection_unref(mDbusConnection);
+    dbus_connection_unref(mpDbusConnection);
 //    logInfo("DBusWrapper::dbusDispatchCallback was called");
     return returnVal;
 }
 
-bool am::DBusWrapper::dbusCheckCallback(const sh_pollHandle_t handle, void *userData)
+bool am::CAmDbusWrapper::dbusCheckCallback(const sh_pollHandle_t handle, void *userData)
 {
     (void) handle;
     (void) userData;
     bool returnVal = false;
-    dbus_connection_ref(mDbusConnection);
-    if (dbus_connection_get_dispatch_status(mDbusConnection) == DBUS_DISPATCH_DATA_REMAINS)
+    dbus_connection_ref(mpDbusConnection);
+    if (dbus_connection_get_dispatch_status(mpDbusConnection) == DBUS_DISPATCH_DATA_REMAINS)
         returnVal = true;
-    dbus_connection_unref(mDbusConnection);
+    dbus_connection_unref(mpDbusConnection);
 //    logInfo("DBusWrapper::dbusCheckCallback was called");
     return returnVal;
 }
 
-void am::DBusWrapper::dbusFireCallback(const pollfd pollfd, const sh_pollHandle_t handle, void *userData)
+void am::CAmDbusWrapper::dbusFireCallback(const pollfd pollfd, const sh_pollHandle_t handle, void *userData)
 {
     (void) handle;
     (void) userData;
@@ -388,13 +389,13 @@ void am::DBusWrapper::dbusFireCallback(const pollfd pollfd, const sh_pollHandle_
 
     DBusWatch *watch = (DBusWatch*) userData;
 
-    dbus_connection_ref(mDbusConnection);
+    dbus_connection_ref(mpDbusConnection);
     dbus_watch_handle(watch, flags);
-    dbus_connection_unref(mDbusConnection);
+    dbus_connection_unref(mpDbusConnection);
 //    logInfo("DBusWrapper::dbusFireCallback was called");
 }
 
-void DBusWrapper::toggleTimeoutDelegate(DBusTimeout *timeout, void* userData)
+void CAmDbusWrapper::toggleTimeoutDelegate(DBusTimeout *timeout, void* userData)
 {
     (void) userData;
     //get the pointer to the handle and remove the timer
@@ -408,15 +409,15 @@ void DBusWrapper::toggleTimeoutDelegate(DBusTimeout *timeout, void* userData)
         int localTimeout = dbus_timeout_get_interval(timeout);
         pollTimeout.tv_sec = localTimeout / 1000;
         pollTimeout.tv_nsec = (localTimeout % 1000) * 1000000;
-        mSocketHandler->restartTimer(*handle, pollTimeout);
+        mpSocketHandler->restartTimer(*handle, pollTimeout);
     }
     else
     {
-        mSocketHandler->stopTimer(*handle);
+        mpSocketHandler->stopTimer(*handle);
     }logInfo("DBusWrapper::toggleTimeoutDelegate was called");
 }
 
-void DBusWrapper::dbusTimerCallback(sh_timerHandle_t handle, void *userData)
+void CAmDbusWrapper::dbusTimerCallback(sh_timerHandle_t handle, void *userData)
 {
     assert(userData!=NULL);
     if (dbus_timeout_get_enabled((DBusTimeout*) userData))
@@ -424,9 +425,10 @@ void DBusWrapper::dbusTimerCallback(sh_timerHandle_t handle, void *userData)
         timespec ts;
         ts.tv_nsec = -1;
         ts.tv_sec = -1;
-        mSocketHandler->restartTimer(handle, ts);
+        mpSocketHandler->restartTimer(handle, ts);
     }
     dbus_timeout_handle((DBusTimeout*) userData);
     logInfo("DBusWrapper::dbusTimerCallback was called");
 }
+}
 
diff --git a/AudioManagerDaemon/src/DLTWrapper.cpp b/AudioManagerDaemon/src/CAmDltWrapper.cpp
index ad03692..968f911 100644
--- a/AudioManagerDaemon/src/DLTWrapper.cpp
+++ b/AudioManagerDaemon/src/CAmDltWrapper.cpp
@@ -3,7 +3,7 @@
  *
  * GeniviAudioMananger AudioManagerDaemon
  *
- * \file DLTWrapper.cpp
+ * \file CAmDltWrapper.cpp
  *
  * \date 20-Oct-2011 3:42:04 PM
  * \author Christian Mueller (christian.ei.mueller@bmw.de)
@@ -23,44 +23,48 @@
  */
 
 
-#include "DLTWrapper.h"
+#include "shared/CAmDltWrapper.h"
 #include <string.h>
 #include <sstream>
 #include <iostream>
 
-DLTWrapper* DLTWrapper::mDLTWrapper = NULL;
+namespace am
+{
+
+CAmDltWrapper* CAmDltWrapper::mpDLTWrapper = NULL;
 
-DLTWrapper *DLTWrapper::instance(const bool enableNoDLTDebug)
+CAmDltWrapper *CAmDltWrapper::instance(const bool enableNoDLTDebug)
 {
-    if (!mDLTWrapper)
-        mDLTWrapper = new DLTWrapper(enableNoDLTDebug);
+    if (!mpDLTWrapper)
+        mpDLTWrapper = new CAmDltWrapper(enableNoDLTDebug);
 #ifndef WITH_DLT
     if(enableNoDLTDebug)
-        mDLTWrapper->enableNoDLTDebug(true);
+        mpDLTWrapper->enableNoDLTDebug(true);
 #endif        
-    return mDLTWrapper;
+    return mpDLTWrapper;
 }
 
-void DLTWrapper::unregisterContext(DltContext & handle)
+void CAmDltWrapper::unregisterContext(DltContext & handle)
 {
 #ifdef WITH_DLT
     dlt_unregister_context(&handle);
 #endif
 }
 
-DLTWrapper::DLTWrapper(const bool enableNoDLTDebug) :
+CAmDltWrapper::CAmDltWrapper(const bool enableNoDLTDebug) :
 #ifndef WITH_DLT
         mEnableNoDLTDebug(enableNoDLTDebug),
 #endif
         mDltContext(), //
         mDltContextData()
 {
+    (void) enableNoDLTDebug;
 #ifndef WITH_DLT
     std::cout << "[DLT] Running without DLT-support" << std::endl;
 #endif
 }
 
-void DLTWrapper::registerApp(const char *appid, const char *description)
+void CAmDltWrapper::registerApp(const char *appid, const char *description)
 {
 #ifdef WITH_DLT
     dlt_register_app(appid, description);
@@ -69,7 +73,7 @@ void DLTWrapper::registerApp(const char *appid, const char *description)
 #endif
 }
 
-void DLTWrapper::registerContext(DltContext& handle, const char *contextid, const char *description)
+void CAmDltWrapper::registerContext(DltContext& handle, const char *contextid, const char *description)
 {
 #ifdef WITH_DLT
     dlt_register_context(&handle, contextid, description);
@@ -85,7 +89,7 @@ void DLTWrapper::registerContext(DltContext& handle, const char *contextid, cons
 #endif
 }
 
-void DLTWrapper::init(DltLogLevelType loglevel, DltContext* context)
+void CAmDltWrapper::init(DltLogLevelType loglevel, DltContext* context)
 {
     if (!context)
         context = &mDltContext;
@@ -95,7 +99,7 @@ void DLTWrapper::init(DltLogLevelType loglevel, DltContext* context)
 
 }
 
-void DLTWrapper::send()
+void CAmDltWrapper::send()
 {
 #ifdef WITH_DLT
     dlt_user_log_write_finish(&mDltContextData);
@@ -107,7 +111,7 @@ void DLTWrapper::send()
 #endif
 }
 
-void DLTWrapper::append(const int8_t value)
+void CAmDltWrapper::append(const int8_t value)
 {
 #ifdef WITH_DLT
     dlt_user_log_write_int8(&mDltContextData, value);
@@ -116,7 +120,7 @@ void DLTWrapper::append(const int8_t value)
 #endif
 }
 
-void DLTWrapper::append(const uint8_t value)
+void CAmDltWrapper::append(const uint8_t value)
 {
 #ifdef WITH_DLT
     dlt_user_log_write_uint8(&mDltContextData, value);
@@ -125,7 +129,7 @@ void DLTWrapper::append(const uint8_t value)
 #endif
 }
 
-void DLTWrapper::append(const int16_t value)
+void CAmDltWrapper::append(const int16_t value)
 {
 #ifdef WITH_DLT
     dlt_user_log_write_int16(&mDltContextData, value);
@@ -134,7 +138,7 @@ void DLTWrapper::append(const int16_t value)
 #endif
 }
 
-void DLTWrapper::append(const uint16_t value)
+void CAmDltWrapper::append(const uint16_t value)
 {
 #ifdef WITH_DLT
     dlt_user_log_write_uint16(&mDltContextData, value);
@@ -143,7 +147,7 @@ void DLTWrapper::append(const uint16_t value)
 #endif
 }
 
-void DLTWrapper::append(const int32_t value)
+void CAmDltWrapper::append(const int32_t value)
 {
 #ifdef WITH_DLT
     dlt_user_log_write_int32(&mDltContextData, value);
@@ -152,7 +156,7 @@ void DLTWrapper::append(const int32_t value)
 #endif
 }
 
-void DLTWrapper::append(const uint32_t value)
+void CAmDltWrapper::append(const uint32_t value)
 {
 #ifdef WITH_DLT
     dlt_user_log_write_uint32(&mDltContextData, value);
@@ -161,7 +165,7 @@ void DLTWrapper::append(const uint32_t value)
 #endif
 }
 
-void DLTWrapper::append(const char*& value)
+void CAmDltWrapper::append(const char*& value)
 {
 #ifdef WITH_DLT
     dlt_user_log_write_string(&mDltContextData, value);
@@ -171,7 +175,7 @@ void DLTWrapper::append(const char*& value)
 #endif
 }
 
-void DLTWrapper::append(const std::string& value)
+void CAmDltWrapper::append(const std::string& value)
 {
 #ifdef WITH_DLT
     dlt_user_log_write_string(&mDltContextData, value.c_str());
@@ -181,7 +185,7 @@ void DLTWrapper::append(const std::string& value)
 #endif
 }
 
-void DLTWrapper::append(const bool value)
+void CAmDltWrapper::append(const bool value)
 {
 #ifdef WITH_DLT
     dlt_user_log_write_bool(&mDltContextData, static_cast<uint8_t>(value));
@@ -191,7 +195,7 @@ void DLTWrapper::append(const bool value)
 }
 
 #ifndef WITH_DLT
-template<class T> void DLTWrapper::appendNoDLT(T value)
+template<class T> void CAmDltWrapper::appendNoDLT(T value)
 {
     if((mDltContextData.size + sizeof(value)) < DLT_USER_BUF_MAX_SIZE)
     {
@@ -200,15 +204,16 @@ template<class T> void DLTWrapper::appendNoDLT(T value)
     }
 }
 
-void DLTWrapper::enableNoDLTDebug(const bool enableNoDLTDebug)
+void CAmDltWrapper::enableNoDLTDebug(const bool enableNoDLTDebug)
 {
     mEnableNoDLTDebug = enableNoDLTDebug;
 }
 #endif
 
-DLTWrapper::~DLTWrapper()
+CAmDltWrapper::~CAmDltWrapper()
 {
-    if (mDLTWrapper)
-        delete mDLTWrapper;
+    if (mpDLTWrapper)
+        delete mpDLTWrapper;
+}
 }
 
diff --git a/AudioManagerDaemon/src/Router.cpp b/AudioManagerDaemon/src/CAmRouter.cpp
index c74989a..265f77d 100644
--- a/AudioManagerDaemon/src/Router.cpp
+++ b/AudioManagerDaemon/src/CAmRouter.cpp
@@ -3,7 +3,7 @@
  *
  * GeniviAudioMananger AudioManagerDaemon
  *
- * \file Router.cpp
+ * \file CAmRouter.cpp
  *
  * \date 20-Oct-2011 3:42:04 PM
  * \author Christian Mueller (christian.ei.mueller@bmw.de)
@@ -22,17 +22,17 @@
  *
  */
 
-#include "Router.h"
-#include "DatabaseHandler.h"
-#include "ControlSender.h"
+#include "CAmRouter.h"
 #include <cassert>
 #include <algorithm>
 #include <vector>
 #include <iterator>
+#include "CAmDatabaseHandler.h"
+#include "CAmControlSender.h"
 
-using namespace am;
+namespace am {
 
-Router::Router(DatabaseHandler* iDatabaseHandler, ControlSender* iSender) :
+CAmRouter::CAmRouter(CAmDatabaseHandler* iDatabaseHandler, CAmControlSender* iSender) :
         mDatabaseHandler(iDatabaseHandler), //
         mControlSender(iSender)
 {
@@ -40,7 +40,7 @@ Router::Router(DatabaseHandler* iDatabaseHandler, ControlSender* iSender) :
     assert(mControlSender);
 }
 
-am_Error_e Router::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s> & returnList)
+am_Error_e CAmRouter::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s> & returnList)
 {
     returnList.clear();
     //first find out in which domains the source and sink are
@@ -88,9 +88,9 @@ am_Error_e Router::getRoute(const bool onlyfree, const am_sourceID_t sourceID, c
         return E_OK;
 
     }
-    RoutingTree routingtree(sourceDomainID); //Build up a Tree from the Source_Domain to every other domain.
-    std::vector<RoutingTreeItem*> flattree; //This list is the flat tree
-    std::vector<RoutingTreeItem*> matchtree;
+    CAmRoutingTree routingtree(sourceDomainID); //Build up a Tree from the Source_Domain to every other domain.
+    std::vector<CAmRoutingTreeItem*> flattree; //This list is the flat tree
+    std::vector<CAmRoutingTreeItem*> matchtree;
     std::vector<am_gatewayID_t> listGatewayID; //holds all gateway ids of the route
     am_RoutingElement_s routingElement;
     am_Route_s actualRoute; //holds the actual Route
@@ -99,7 +99,7 @@ am_Error_e Router::getRoute(const bool onlyfree, const am_sourceID_t sourceID, c
     mDatabaseHandler->getRoutingTree(onlyfree, routingtree, flattree); //Build up the tree out of the database as
 
     //we go through the returned flattree and look for our sink, after that flattree holds only treeItems that match
-    std::vector<RoutingTreeItem*>::iterator iterator = flattree.begin();
+    std::vector<CAmRoutingTreeItem*>::iterator iterator = flattree.begin();
     for (; iterator != flattree.end(); ++iterator)
     {
         if ((*iterator)->returnDomainID() == sinkDomainID)
@@ -164,7 +164,7 @@ am_Error_e Router::getRoute(const bool onlyfree, const am_sourceID_t sourceID, c
     return (E_OK);
 }
 
-void Router::listPossibleConnectionFormats(const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_ConnectionFormat_e>& listFormats) const
+void CAmRouter::listPossibleConnectionFormats(const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_ConnectionFormat_e>& listFormats) const
 {
     std::vector<am_ConnectionFormat_e> listSourceFormats;
     std::vector<am_ConnectionFormat_e> listSinkFormats;
@@ -176,7 +176,7 @@ void Router::listPossibleConnectionFormats(const am_sourceID_t sourceID, const a
     set_intersection(listSourceFormats.begin(), listSourceFormats.end(), listSinkFormats.begin(), listSinkFormats.end(), inserter);
 }
 
-am_Error_e Router::findBestWay(am_sinkID_t sinkID, am_sourceID_t sourceID, std::vector<am_RoutingElement_s> & listRoute, std::vector<am_RoutingElement_s>::iterator routeIterator, std::vector<am_gatewayID_t>::iterator gatewayIterator)
+am_Error_e CAmRouter::findBestWay(am_sinkID_t sinkID, am_sourceID_t sourceID, std::vector<am_RoutingElement_s> & listRoute, std::vector<am_RoutingElement_s>::iterator routeIterator, std::vector<am_gatewayID_t>::iterator gatewayIterator)
 {
     am_Error_e returnError = E_NOT_POSSIBLE;
     std::vector<am_ConnectionFormat_e> listConnectionFormats;
@@ -239,7 +239,7 @@ am_Error_e Router::findBestWay(am_sinkID_t sinkID, am_sourceID_t sourceID, std::
     return (returnError);
 }
 
-void Router::listRestrictedOutputFormatsGateways(const am_gatewayID_t gatewayID, const am_ConnectionFormat_e sinkConnectionFormat, std::vector<am_ConnectionFormat_e> & listFormats) const
+void CAmRouter::listRestrictedOutputFormatsGateways(const am_gatewayID_t gatewayID, const am_ConnectionFormat_e sinkConnectionFormat, std::vector<am_ConnectionFormat_e> & listFormats) const
 {
     listFormats.clear();
     am_Gateway_s gatewayData;
@@ -265,11 +265,11 @@ void Router::listRestrictedOutputFormatsGateways(const am_gatewayID_t gatewayID,
     } while (gatewayData.convertionMatrix.end() - matrixIterator > 0);
 }
 
-Router::~Router()
+CAmRouter::~CAmRouter()
 {
 }
 
-RoutingTreeItem::RoutingTreeItem(const am_domainID_t domainID, const am_gatewayID_t gatewayID, RoutingTreeItem *parent) :
+CAmRoutingTreeItem::CAmRoutingTreeItem(const am_domainID_t domainID, const am_gatewayID_t gatewayID, CAmRoutingTreeItem *parent) :
         mDomainID(domainID), //
         mGatewayID(gatewayID), //
         mParentItem(parent)
@@ -277,54 +277,54 @@ RoutingTreeItem::RoutingTreeItem(const am_domainID_t domainID, const am_gatewayI
     assert(mDomainID!=0);
 }
 
-void RoutingTreeItem::appendChild(RoutingTreeItem *newChild)
+void CAmRoutingTreeItem::appendChild(CAmRoutingTreeItem *newChild)
 {
     assert(newChild);
     mListChildItems.push_back(newChild);
 }
 
-void RoutingTreeItem::returnChildItems(std::vector<RoutingTreeItem*> listChildItems)
+void CAmRoutingTreeItem::returnChildItems(std::vector<CAmRoutingTreeItem*> listChildItems)
 {
     listChildItems = mListChildItems;
 }
 
-am_domainID_t RoutingTreeItem::returnDomainID() const
+am_domainID_t CAmRoutingTreeItem::returnDomainID() const
 {
     return (mDomainID);
 }
 
-am_gatewayID_t RoutingTreeItem::returnGatewayID() const
+am_gatewayID_t CAmRoutingTreeItem::returnGatewayID() const
 {
     return (mGatewayID);
 }
 
-RoutingTreeItem* RoutingTreeItem::returnParent() const
+CAmRoutingTreeItem* CAmRoutingTreeItem::returnParent() const
 {
     return (mParentItem);
 }
 
-RoutingTreeItem::~RoutingTreeItem()
+CAmRoutingTreeItem::~CAmRoutingTreeItem()
 {
 }
 
-RoutingTree::RoutingTree(const am_domainID_t rootDomainID) :
-        mRootItem(RoutingTreeItem(rootDomainID))
+CAmRoutingTree::CAmRoutingTree(const am_domainID_t rootDomainID) :
+        mRootItem(CAmRoutingTreeItem(rootDomainID))
 {
     assert(rootDomainID!=0);
 }
 
-RoutingTreeItem *RoutingTree::insertItem(const am_domainID_t domainID, const am_gatewayID_t gatewayID, RoutingTreeItem *parent)
+CAmRoutingTreeItem *CAmRoutingTree::insertItem(const am_domainID_t domainID, const am_gatewayID_t gatewayID, CAmRoutingTreeItem *parent)
 {
-    RoutingTreeItem *newTree = new RoutingTreeItem(domainID, gatewayID, parent);
+    CAmRoutingTreeItem *newTree = new CAmRoutingTreeItem(domainID, gatewayID, parent);
     parent->appendChild(newTree);
     mListChild.push_back(newTree);
     return newTree;
 }
 
-void RoutingTree::getRoute(RoutingTreeItem *targetItem, std::vector<am_gatewayID_t>& listGateways)
+void CAmRoutingTree::getRoute(CAmRoutingTreeItem *targetItem, std::vector<am_gatewayID_t>& listGateways)
 {
     listGateways.clear();
-    RoutingTreeItem *parentItem = targetItem;
+    CAmRoutingTreeItem *parentItem = targetItem;
     while (parentItem != &mRootItem)
     {
         listGateways.push_back(parentItem->returnGatewayID());
@@ -333,22 +333,22 @@ void RoutingTree::getRoute(RoutingTreeItem *targetItem, std::vector<am_gatewayID
     std::reverse(listGateways.begin(), listGateways.end());
 }
 
-am_domainID_t RoutingTree::returnRootDomainID() const
+am_domainID_t CAmRoutingTree::returnRootDomainID() const
 {
     return (mRootItem.returnDomainID());
 }
 
-RoutingTreeItem *RoutingTree::returnRootItem()
+CAmRoutingTreeItem *CAmRoutingTree::returnRootItem()
 {
     return (&mRootItem);
 }
 
-RoutingTree::~RoutingTree()
+CAmRoutingTree::~CAmRoutingTree()
 {
-    std::vector<RoutingTreeItem*>::iterator it = mListChild.begin();
+    std::vector<CAmRoutingTreeItem*>::iterator it = mListChild.begin();
     for (; it != mListChild.end(); ++it)
     {
         delete *it;
     }
 }
-
+}
diff --git a/AudioManagerDaemon/src/RoutingReceiver.cpp b/AudioManagerDaemon/src/CAmRoutingReceiver.cpp
index 715fa36..8f489fb 100644
--- a/AudioManagerDaemon/src/RoutingReceiver.cpp
+++ b/AudioManagerDaemon/src/CAmRoutingReceiver.cpp
@@ -3,12 +3,12 @@
  *
  * GeniviAudioMananger AudioManagerDaemon
  *
- * \file RoutingReceiver.cpp
+ * \file CAmRoutingReceiver.cpp
  *
  * \date 20-Oct-2011 3:42:04 PM
  * \author Christian Mueller (christian.ei.mueller@bmw.de)
  *
- * \section LicenseRoutingReceiver.h
+ * \section LicenseCAmRoutingReceiver.h
  *
  * GNU Lesser General Public License, version 2.1, with special exception (GENIVI clause)
  * Copyright (C) 2011, BMW AG Christian Mueller  Christian.ei.mueller@bmw.de
@@ -23,19 +23,19 @@
  *
  */
 
-#include "RoutingReceiver.h"
-#include "DatabaseHandler.h"
-#include "RoutingSender.h"
-#include "ControlSender.h"
-#include "DLTWrapper.h"
-#include <SocketHandler.h>
+#include "CAmRoutingReceiver.h"
 #include <cassert>
 #include <algorithm>
+#include "CAmDatabaseHandler.h"
+#include "CAmRoutingSender.h"
+#include "CAmControlSender.h"
+#include "shared/CAmDltWrapper.h"
+#include "shared/CAmSocketHandler.h"
 
+namespace am
+{
 
-using namespace am;
-
-RoutingReceiver::RoutingReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, ControlSender *iControlSender, SocketHandler *iSocketHandler) :
+CAmRoutingReceiver::CAmRoutingReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler) :
         mDatabaseHandler(iDatabaseHandler), //
         mRoutingSender(iRoutingSender), //
         mControlSender(iControlSender), //
@@ -51,7 +51,7 @@ RoutingReceiver::RoutingReceiver(DatabaseHandler *iDatabaseHandler, RoutingSende
     assert(mSocketHandler!=NULL);
 }
 
-RoutingReceiver::RoutingReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, ControlSender *iControlSender, SocketHandler *iSocketHandler, DBusWrapper *iDBusWrapper) :
+CAmRoutingReceiver::CAmRoutingReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper) :
         mDatabaseHandler(iDatabaseHandler), //
         mRoutingSender(iRoutingSender), //
         mControlSender(iControlSender), //
@@ -69,11 +69,11 @@ RoutingReceiver::RoutingReceiver(DatabaseHandler *iDatabaseHandler, RoutingSende
     assert(mDBusWrapper!=NULL);
 }
 
-RoutingReceiver::~RoutingReceiver()
+CAmRoutingReceiver::~CAmRoutingReceiver()
 {
 }
 
-void RoutingReceiver::ackConnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_Error_e error)
+void CAmRoutingReceiver::ackConnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_Error_e error)
 {
     mRoutingSender->removeHandle(handle);
     if (error == E_OK)
@@ -87,7 +87,7 @@ void RoutingReceiver::ackConnect(const am_Handle_s handle, const am_connectionID
     mControlSender->cbAckConnect(handle, error);
 }
 
-void RoutingReceiver::ackDisconnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_Error_e error)
+void CAmRoutingReceiver::ackDisconnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_Error_e error)
 {
     mRoutingSender->removeHandle(handle);
     if (error == E_OK)
@@ -97,9 +97,9 @@ void RoutingReceiver::ackDisconnect(const am_Handle_s handle, const am_connectio
     mControlSender->cbAckDisconnect(handle, error);
 }
 
-void RoutingReceiver::ackSetSinkVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
+void CAmRoutingReceiver::ackSetSinkVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
 {
-    RoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
+    CAmRoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
     if (error == E_OK && handleData.sinkID != 0)
     {
         //todo: check if volume in handleData is same than volume. React to it.
@@ -109,9 +109,9 @@ void RoutingReceiver::ackSetSinkVolumeChange(const am_Handle_s handle, const am_
     mControlSender->cbAckSetSinkVolumeChange(handle, volume, error);
 }
 
-void RoutingReceiver::ackSetSourceVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
+void CAmRoutingReceiver::ackSetSourceVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
 {
-    RoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
+    CAmRoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
     if (error == E_OK && handleData.sourceID != 0)
     {
         //todo: check if volume in handleData is same than volume. React to it.
@@ -121,9 +121,9 @@ void RoutingReceiver::ackSetSourceVolumeChange(const am_Handle_s handle, const a
     mControlSender->cbAckSetSourceVolumeChange(handle, volume, error);
 }
 
-void RoutingReceiver::ackSetSourceState(const am_Handle_s handle, const am_Error_e error)
+void CAmRoutingReceiver::ackSetSourceState(const am_Handle_s handle, const am_Error_e error)
 {
-    RoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
+    CAmRoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
     if (error == E_OK && handleData.sourceID != 0)
     {
         //todo: check if volume in handleData is same than volume. React to it.
@@ -133,9 +133,9 @@ void RoutingReceiver::ackSetSourceState(const am_Handle_s handle, const am_Error
     mControlSender->cbAckSetSourceState(handle, error);
 }
 
-void RoutingReceiver::ackSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error)
+void CAmRoutingReceiver::ackSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error)
 {
-    RoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
+    CAmRoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
     if (error == E_OK && handleData.sinkID != 0)
     {
         mDatabaseHandler->changeSinkSoundPropertyDB(handleData.soundPropery, handleData.sinkID);
@@ -145,9 +145,9 @@ void RoutingReceiver::ackSetSinkSoundProperty(const am_Handle_s handle, const am
 
 }
 
-void am::RoutingReceiver::ackSetSinkSoundProperties(const am_Handle_s handle, const am_Error_e error)
+void am::CAmRoutingReceiver::ackSetSinkSoundProperties(const am_Handle_s handle, const am_Error_e error)
 {
-    RoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
+    CAmRoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
     if (error == E_OK && handleData.sinkID != 0)
     {
         std::vector<am_SoundProperty_s>::const_iterator it = handleData.soundProperties->begin();
@@ -161,9 +161,9 @@ void am::RoutingReceiver::ackSetSinkSoundProperties(const am_Handle_s handle, co
     mControlSender->cbAckSetSinkSoundProperties(handle, error);
 }
 
-void RoutingReceiver::ackSetSourceSoundProperty(const am_Handle_s handle, const am_Error_e error)
+void CAmRoutingReceiver::ackSetSourceSoundProperty(const am_Handle_s handle, const am_Error_e error)
 {
-    RoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
+    CAmRoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
     if (error == E_OK && handleData.sourceID != 0)
     {
         mDatabaseHandler->changeSourceSoundPropertyDB(handleData.soundPropery, handleData.sourceID);
@@ -172,9 +172,9 @@ void RoutingReceiver::ackSetSourceSoundProperty(const am_Handle_s handle, const
     mControlSender->cbAckSetSourceSoundProperty(handle, error);
 }
 
-void am::RoutingReceiver::ackSetSourceSoundProperties(const am_Handle_s handle, const am_Error_e error)
+void am::CAmRoutingReceiver::ackSetSourceSoundProperties(const am_Handle_s handle, const am_Error_e error)
 {
-    RoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
+    CAmRoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
     if (error == E_OK && handleData.sourceID != 0)
     {
         std::vector<am_SoundProperty_s>::const_iterator it = handleData.soundProperties->begin();
@@ -188,9 +188,9 @@ void am::RoutingReceiver::ackSetSourceSoundProperties(const am_Handle_s handle,
     mControlSender->cbAckSetSourceSoundProperties(handle, error);
 }
 
-void RoutingReceiver::ackCrossFading(const am_Handle_s handle, const am_HotSink_e hotSink, const am_Error_e error)
+void CAmRoutingReceiver::ackCrossFading(const am_Handle_s handle, const am_HotSink_e hotSink, const am_Error_e error)
 {
-    RoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
+    CAmRoutingSender::am_handleData_c handleData = mRoutingSender->returnHandleData(handle);
     if (error == E_OK && handleData.crossfaderID != 0)
     {
         //todo: check if volume in handleData is same than volume. React to it.
@@ -200,128 +200,128 @@ void RoutingReceiver::ackCrossFading(const am_Handle_s handle, const am_HotSink_
     mControlSender->cbAckCrossFade(handle, hotSink, error);
 }
 
-void RoutingReceiver::ackSourceVolumeTick(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume)
+void CAmRoutingReceiver::ackSourceVolumeTick(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume)
 {
     mControlSender->hookSystemSourceVolumeTick(handle, sourceID, volume);
 }
 
-void RoutingReceiver::ackSinkVolumeTick(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume)
+void CAmRoutingReceiver::ackSinkVolumeTick(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume)
 {
     mControlSender->hookSystemSinkVolumeTick(handle, sinkID, volume);
 }
 
-am_Error_e RoutingReceiver::peekDomain(const std::string & name, am_domainID_t & domainID)
+am_Error_e CAmRoutingReceiver::peekDomain(const std::string & name, am_domainID_t & domainID)
 {
     return mDatabaseHandler->peekDomain(name, domainID);
 
 }
 
-am_Error_e RoutingReceiver::registerDomain(const am_Domain_s & domainData, am_domainID_t & domainID)
+am_Error_e CAmRoutingReceiver::registerDomain(const am_Domain_s & domainData, am_domainID_t & domainID)
 {
     return mControlSender->hookSystemRegisterDomain(domainData, domainID);
 }
 
-am_Error_e RoutingReceiver::deregisterDomain(const am_domainID_t domainID)
+am_Error_e CAmRoutingReceiver::deregisterDomain(const am_domainID_t domainID)
 {
     return mControlSender->hookSystemDeregisterDomain(domainID);
 }
 
-am_Error_e RoutingReceiver::registerGateway(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
+am_Error_e CAmRoutingReceiver::registerGateway(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
 {
     return mControlSender->hookSystemRegisterGateway(gatewayData, gatewayID);
 }
 
-am_Error_e RoutingReceiver::deregisterGateway(const am_gatewayID_t gatewayID)
+am_Error_e CAmRoutingReceiver::deregisterGateway(const am_gatewayID_t gatewayID)
 {
     return mControlSender->hookSystemDeregisterGateway(gatewayID);
 }
 
-am_Error_e RoutingReceiver::peekSink(const std::string& name, am_sinkID_t & sinkID)
+am_Error_e CAmRoutingReceiver::peekSink(const std::string& name, am_sinkID_t & sinkID)
 {
     return mDatabaseHandler->peekSink(name, sinkID);
 }
 
-am_Error_e RoutingReceiver::registerSink(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
+am_Error_e CAmRoutingReceiver::registerSink(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
 {
     return mControlSender->hookSystemRegisterSink(sinkData, sinkID);
 }
 
-am_Error_e RoutingReceiver::deregisterSink(const am_sinkID_t sinkID)
+am_Error_e CAmRoutingReceiver::deregisterSink(const am_sinkID_t sinkID)
 {
     return mControlSender->hookSystemDeregisterSink(sinkID);
 }
 
-am_Error_e RoutingReceiver::peekSource(const std::string & name, am_sourceID_t & sourceID)
+am_Error_e CAmRoutingReceiver::peekSource(const std::string & name, am_sourceID_t & sourceID)
 {
     return mDatabaseHandler->peekSource(name, sourceID);
 }
 
-am_Error_e RoutingReceiver::registerSource(const am_Source_s & sourceData, am_sourceID_t & sourceID)
+am_Error_e CAmRoutingReceiver::registerSource(const am_Source_s & sourceData, am_sourceID_t & sourceID)
 {
     return mControlSender->hookSystemRegisterSource(sourceData, sourceID);
 }
 
-am_Error_e RoutingReceiver::deregisterSource(const am_sourceID_t sourceID)
+am_Error_e CAmRoutingReceiver::deregisterSource(const am_sourceID_t sourceID)
 {
     return mControlSender->hookSystemDeregisterSource(sourceID);
 }
 
-am_Error_e RoutingReceiver::registerCrossfader(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
+am_Error_e CAmRoutingReceiver::registerCrossfader(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
 {
     return mControlSender->hookSystemRegisterCrossfader(crossfaderData, crossfaderID);
 }
 
-am_Error_e RoutingReceiver::deregisterCrossfader(const am_crossfaderID_t crossfaderID)
+am_Error_e CAmRoutingReceiver::deregisterCrossfader(const am_crossfaderID_t crossfaderID)
 {
     return mControlSender->hookSystemDeregisterCrossfader(crossfaderID);
 }
 
-void RoutingReceiver::hookInterruptStatusChange(const am_sourceID_t sourceID, const am_InterruptState_e interruptState)
+void CAmRoutingReceiver::hookInterruptStatusChange(const am_sourceID_t sourceID, const am_InterruptState_e interruptState)
 {
     return mControlSender->hookSystemInterruptStateChange(sourceID, interruptState);
 }
 
-void RoutingReceiver::hookDomainRegistrationComplete(const am_domainID_t domainID)
+void CAmRoutingReceiver::hookDomainRegistrationComplete(const am_domainID_t domainID)
 {
     mControlSender->hookSystemDomainRegistrationComplete(domainID);
 }
 
-void RoutingReceiver::hookSinkAvailablityStatusChange(const am_sinkID_t sinkID, const am_Availability_s & availability)
+void CAmRoutingReceiver::hookSinkAvailablityStatusChange(const am_sinkID_t sinkID, const am_Availability_s & availability)
 {
     mControlSender->hookSystemSinkAvailablityStateChange(sinkID, availability);
 }
 
-void RoutingReceiver::hookSourceAvailablityStatusChange(const am_sourceID_t sourceID, const am_Availability_s & availability)
+void CAmRoutingReceiver::hookSourceAvailablityStatusChange(const am_sourceID_t sourceID, const am_Availability_s & availability)
 {
     mControlSender->hookSystemSourceAvailablityStateChange(sourceID, availability);
 }
 
-void RoutingReceiver::hookDomainStateChange(const am_domainID_t domainID, const am_DomainState_e domainState)
+void CAmRoutingReceiver::hookDomainStateChange(const am_domainID_t domainID, const am_DomainState_e domainState)
 {
     mControlSender->hookSystemDomainStateChange(domainID, domainState);
 }
 
-void RoutingReceiver::hookTimingInformationChanged(const am_connectionID_t connectionID, const am_timeSync_t delay)
+void CAmRoutingReceiver::hookTimingInformationChanged(const am_connectionID_t connectionID, const am_timeSync_t delay)
 {
     mDatabaseHandler->changeConnectionTimingInformation(connectionID, delay);
 }
 
-void RoutingReceiver::sendChangedData(const std::vector<am_EarlyData_s> & earlyData)
+void CAmRoutingReceiver::sendChangedData(const std::vector<am_EarlyData_s> & earlyData)
 {
     mControlSender->hookSystemReceiveEarlyData(earlyData);
 }
 
-am_Error_e RoutingReceiver::peekSinkClassID(const std::string& name, am_sinkClass_t& sinkClassID)
+am_Error_e CAmRoutingReceiver::peekSinkClassID(const std::string& name, am_sinkClass_t& sinkClassID)
 {
     return mDatabaseHandler->peekSinkClassID(name, sinkClassID);
 }
 
-am_Error_e RoutingReceiver::peekSourceClassID(const std::string& name, am_sourceClass_t& sourceClassID)
+am_Error_e CAmRoutingReceiver::peekSourceClassID(const std::string& name, am_sourceClass_t& sourceClassID)
 {
     return mDatabaseHandler->peekSourceClassID(name, sourceClassID);
 }
 
-am_Error_e RoutingReceiver::getDBusConnectionWrapper(DBusWrapper *& dbusConnectionWrapper) const
+am_Error_e CAmRoutingReceiver::getDBusConnectionWrapper(CAmDbusWrapper *& dbusConnectionWrapper) const
 {
 #ifdef WITH_DBUS_WRAPPER
     dbusConnectionWrapper = mDBusWrapper;
@@ -331,52 +331,52 @@ am_Error_e RoutingReceiver::getDBusConnectionWrapper(DBusWrapper *& dbusConnecti
 #endif
 }
 
-am_Error_e RoutingReceiver::getSocketHandler(SocketHandler *& socketHandler) const
+am_Error_e CAmRoutingReceiver::getSocketHandler(CAmSocketHandler *& socketHandler) const
 {
     socketHandler = mSocketHandler;
     return E_OK;
 }
 
-void RoutingReceiver::getInterfaceVersion(std::string & version) const
+void CAmRoutingReceiver::getInterfaceVersion(std::string & version) const
 {
     version = RoutingReceiveVersion;
 }
 
-void RoutingReceiver::confirmRoutingReady(const uint16_t handle)
+void CAmRoutingReceiver::confirmRoutingReady(const uint16_t handle)
 {
     mListStartupHandles.erase(std::remove(mListStartupHandles.begin(), mListStartupHandles.end(), handle), mListStartupHandles.end());
     if (mWaitStartup && mListStartupHandles.empty())
         mControlSender->confirmRoutingReady();
 }
 
-void RoutingReceiver::confirmRoutingRundown(const uint16_t handle)
+void CAmRoutingReceiver::confirmRoutingRundown(const uint16_t handle)
 {
     mListRundownHandles.erase(std::remove(mListRundownHandles.begin(), mListRundownHandles.end(), handle), mListRundownHandles.end());
     if (mWaitRundown && mListRundownHandles.empty())
         mControlSender->confirmCommandRundown();
 }
 
-uint16_t am::RoutingReceiver::getStartupHandle()
+uint16_t am::CAmRoutingReceiver::getStartupHandle()
 {
     uint16_t handle = ++handleCount; //todo: handle overflow
     mListStartupHandles.push_back(handle);
     return handle;
 }
 
-uint16_t am::RoutingReceiver::getRundownHandle()
+uint16_t am::CAmRoutingReceiver::getRundownHandle()
 {
     uint16_t handle = ++handleCount; //todo: handle overflow
     mListRundownHandles.push_back(handle);
     return handle;
 }
 
-void am::RoutingReceiver::waitOnStartup(bool startup)
+void am::CAmRoutingReceiver::waitOnStartup(bool startup)
 {
     mWaitStartup = startup;
 }
 
-void am::RoutingReceiver::waitOnRundown(bool rundown)
+void am::CAmRoutingReceiver::waitOnRundown(bool rundown)
 {
     mWaitRundown = rundown;
 }
-
+}
diff --git a/AudioManagerDaemon/src/RoutingSender.cpp b/AudioManagerDaemon/src/CAmRoutingSender.cpp
index c59641d..c134c3f 100644
--- a/AudioManagerDaemon/src/RoutingSender.cpp
+++ b/AudioManagerDaemon/src/CAmRoutingSender.cpp
@@ -3,7 +3,7 @@
  *
  * GeniviAudioMananger AudioManagerDaemon
  *
- * \file RoutingSender.h
+ * \file CAmRoutingSender.h
  *
  * \date 20-Oct-2011 3:42:04 PM
  * \author Christian Mueller (christian.ei.mueller@bmw.de)
@@ -22,19 +22,19 @@
  *
  */
 
-#include "RoutingSender.h"
+#include "CAmRoutingSender.h"
 #include <utility>
 #include <dirent.h>
 #include <dlfcn.h>
 #include <cassert>
 #include <iostream>
 #include <sstream>
+#include "CAmRoutingReceiver.h"
+#include "TAmPluginTemplate.h"
+#include "shared/CAmDltWrapper.h"
 
-#include "RoutingReceiver.h"
-#include "PluginTemplate.h"
-#include "DLTWrapper.h"
-
-using namespace am;
+namespace am
+{
 
 #define REQUIRED_INTERFACE_VERSION_MAJOR 1
 #define REQUIRED_INTERFACE_VERSION_MINOR 0
@@ -47,7 +47,7 @@ using namespace am;
 			(*iter).routingInterface->__VA_ARGS__;										 \
 		}
 
-RoutingSender::RoutingSender(const std::vector<std::string>& listOfPluginDirectories) :
+CAmRoutingSender::CAmRoutingSender(const std::vector<std::string>& listOfPluginDirectories) :
         mHandleCount(0), //
         mlistActiveHandles(), //
         mListInterfaces(), //
@@ -109,9 +109,9 @@ RoutingSender::RoutingSender(const std::vector<std::string>& listOfPluginDirecto
     {
         logInfo("RoutingSender::RoutingSender try loading: ", *iter);
 
-        RoutingSendInterface* (*createFunc)();
+        IAmRoutingSend* (*createFunc)();
         void* tempLibHandle = NULL;
-        createFunc = getCreateFunction<RoutingSendInterface*()>(*iter, tempLibHandle);
+        createFunc = getCreateFunction<IAmRoutingSend*()>(*iter, tempLibHandle);
 
         if (!createFunc)
         {
@@ -119,7 +119,7 @@ RoutingSender::RoutingSender(const std::vector<std::string>& listOfPluginDirecto
             continue;
         }
 
-        RoutingSendInterface* router = createFunc();
+        IAmRoutingSend* router = createFunc();
 
         if (!router)
         {
@@ -150,7 +150,7 @@ RoutingSender::RoutingSender(const std::vector<std::string>& listOfPluginDirecto
     }
 }
 
-RoutingSender::~RoutingSender()
+CAmRoutingSender::~CAmRoutingSender()
 {
     unloadLibraries();
     HandlesMap::iterator it = mlistActiveHandles.begin();
@@ -165,7 +165,7 @@ RoutingSender::~RoutingSender()
     }
 }
 
-am_Error_e RoutingSender::startupInterfaces(RoutingReceiver *iRoutingReceiver)
+am_Error_e CAmRoutingSender::startupInterfaces(CAmRoutingReceiver *iRoutingReceiver)
 {
     mRoutingReceiver = iRoutingReceiver;
     am_Error_e returnError = E_OK;
@@ -183,7 +183,7 @@ am_Error_e RoutingSender::startupInterfaces(RoutingReceiver *iRoutingReceiver)
     return returnError;
 }
 
-am_Error_e RoutingSender::asyncAbort(const am_Handle_s& handle)
+am_Error_e CAmRoutingSender::asyncAbort(const am_Handle_s& handle)
 {
     HandleInterfaceMap::iterator iter = mMapHandleInterface.begin();
     iter = mMapHandleInterface.find(handle.handle);
@@ -195,7 +195,7 @@ am_Error_e RoutingSender::asyncAbort(const am_Handle_s& handle)
     return E_NON_EXISTENT;
 }
 
-am_Error_e RoutingSender::asyncConnect(am_Handle_s& handle, const am_connectionID_t connectionID, const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_ConnectionFormat_e connectionFormat)
+am_Error_e CAmRoutingSender::asyncConnect(am_Handle_s& handle, const am_connectionID_t connectionID, const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_ConnectionFormat_e connectionFormat)
 {
     am_handleData_c handleData;
     SinkInterfaceMap::iterator iter = mMapSinkInterface.begin();
@@ -212,11 +212,11 @@ am_Error_e RoutingSender::asyncConnect(am_Handle_s& handle, const am_connectionI
     return E_NON_EXISTENT;
 }
 
-am_Error_e RoutingSender::asyncDisconnect(am_Handle_s& handle, const am_connectionID_t connectionID)
+am_Error_e CAmRoutingSender::asyncDisconnect(am_Handle_s& handle, const am_connectionID_t connectionID)
 {
     am_handleData_c handleData;
     ConnectionInterfaceMap::iterator iter = mMapConnectionInterface.begin();
-    mMapConnectionInterface.find(connectionID);
+    iter = mMapConnectionInterface.find(connectionID);
     if (iter != mMapConnectionInterface.end())
     {
         handleData.connectionID = connectionID;
@@ -230,120 +230,136 @@ am_Error_e RoutingSender::asyncDisconnect(am_Handle_s& handle, const am_connecti
     return E_NON_EXISTENT;
 }
 
-am_Error_e RoutingSender::asyncSetSinkVolume(am_Handle_s& handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time)
+am_Error_e CAmRoutingSender::asyncSetSinkVolume(am_Handle_s& handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time)
 {
     am_handleData_c handleData;
     SinkInterfaceMap::iterator iter = mMapSinkInterface.begin();
     iter = mMapSinkInterface.find(sinkID);
     if (iter != mMapSinkInterface.end())
+    {
         handleData.sinkID = sinkID;
-    handleData.volume = volume;
-    handle = createHandle(handleData, H_SETSINKVOLUME);
-    mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
-    return iter->second->asyncSetSinkVolume(handle, sinkID, volume, ramp, time);
+        handleData.volume = volume;
+        handle = createHandle(handleData, H_SETSINKVOLUME);
+        mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
+        return iter->second->asyncSetSinkVolume(handle, sinkID, volume, ramp, time);
+    }
     return E_NON_EXISTENT;
 }
 
-am_Error_e RoutingSender::asyncSetSourceVolume(am_Handle_s& handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time)
+am_Error_e CAmRoutingSender::asyncSetSourceVolume(am_Handle_s& handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time)
 {
     am_handleData_c handleData;
     SourceInterfaceMap::iterator iter = mMapSourceInterface.begin();
     iter = mMapSourceInterface.find(sourceID);
     if (iter != mMapSourceInterface.end())
+    {
         handleData.sourceID = sourceID;
-    handleData.volume = volume;
-    handle = createHandle(handleData, H_SETSOURCEVOLUME);
-    mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
-    return iter->second->asyncSetSourceVolume(handle, sourceID, volume, ramp, time);
+        handleData.volume = volume;
+        handle = createHandle(handleData, H_SETSOURCEVOLUME);
+        mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
+        return iter->second->asyncSetSourceVolume(handle, sourceID, volume, ramp, time);
+    }
     return E_NON_EXISTENT;
 }
 
-am_Error_e RoutingSender::asyncSetSourceState(am_Handle_s& handle, const am_sourceID_t sourceID, const am_SourceState_e state)
+am_Error_e CAmRoutingSender::asyncSetSourceState(am_Handle_s& handle, const am_sourceID_t sourceID, const am_SourceState_e state)
 {
     am_handleData_c handleData;
     SourceInterfaceMap::iterator iter = mMapSourceInterface.begin();
     iter = mMapSourceInterface.find(sourceID);
     if (iter != mMapSourceInterface.end())
+    {
         handleData.sourceID = sourceID;
-    handleData.sourceState = state;
-    handle = createHandle(handleData, H_SETSOURCESTATE);
-    mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
-    return iter->second->asyncSetSourceState(handle, sourceID, state);
+        handleData.sourceState = state;
+        handle = createHandle(handleData, H_SETSOURCESTATE);
+        mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
+        return iter->second->asyncSetSourceState(handle, sourceID, state);
+    }
     return E_NON_EXISTENT;
 }
 
-am_Error_e RoutingSender::asyncSetSinkSoundProperty(am_Handle_s& handle, const am_sinkID_t sinkID, const am_SoundProperty_s & soundProperty)
+am_Error_e CAmRoutingSender::asyncSetSinkSoundProperty(am_Handle_s& handle, const am_sinkID_t sinkID, const am_SoundProperty_s & soundProperty)
 {
     am_handleData_c handleData;
     SinkInterfaceMap::iterator iter = mMapSinkInterface.begin();
     iter = mMapSinkInterface.find(sinkID);
     if (iter != mMapSinkInterface.end())
+    {
         handleData.sinkID = sinkID;
-    handleData.soundPropery = soundProperty;
-    handle = createHandle(handleData, H_SETSINKSOUNDPROPERTY);
-    mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
-    return iter->second->asyncSetSinkSoundProperty(handle, sinkID, soundProperty);
+        handleData.soundPropery = soundProperty;
+        handle = createHandle(handleData, H_SETSINKSOUNDPROPERTY);
+        mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
+        return iter->second->asyncSetSinkSoundProperty(handle, sinkID, soundProperty);
+    }
     return (E_NON_EXISTENT);
 }
 
-am_Error_e RoutingSender::asyncSetSourceSoundProperty(am_Handle_s& handle, const am_sourceID_t sourceID, const am_SoundProperty_s & soundProperty)
+am_Error_e CAmRoutingSender::asyncSetSourceSoundProperty(am_Handle_s& handle, const am_sourceID_t sourceID, const am_SoundProperty_s & soundProperty)
 {
     am_handleData_c handleData;
     SourceInterfaceMap::iterator iter = mMapSourceInterface.begin();
     iter = mMapSourceInterface.find(sourceID);
     if (iter != mMapSourceInterface.end())
+    {
         handleData.sourceID = sourceID;
-    handleData.soundPropery = soundProperty;
-    handle = createHandle(handleData, H_SETSOURCESOUNDPROPERTY);
-    mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
-    return iter->second->asyncSetSourceSoundProperty(handle, sourceID, soundProperty);
+        handleData.soundPropery = soundProperty;
+        handle = createHandle(handleData, H_SETSOURCESOUNDPROPERTY);
+        mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
+        return iter->second->asyncSetSourceSoundProperty(handle, sourceID, soundProperty);
+    }
     return (E_NON_EXISTENT);
 }
 
-am_Error_e RoutingSender::asyncSetSourceSoundProperties(am_Handle_s& handle, const std::vector<am_SoundProperty_s> & listSoundProperties, const am_sourceID_t sourceID)
+am_Error_e CAmRoutingSender::asyncSetSourceSoundProperties(am_Handle_s& handle, const std::vector<am_SoundProperty_s> & listSoundProperties, const am_sourceID_t sourceID)
 {
     am_handleData_c handleData;
     SourceInterfaceMap::iterator iter = mMapSourceInterface.begin();
     iter = mMapSourceInterface.find(sourceID);
     if (iter != mMapSourceInterface.end())
+    {
         handleData.sourceID = sourceID;
-    handleData.soundProperties = new std::vector<am_SoundProperty_s>(listSoundProperties);
-    handle = createHandle(handleData, H_SETSOURCESOUNDPROPERTIES);
-    mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
-    return iter->second->asyncSetSourceSoundProperties(handle, sourceID, listSoundProperties);
+        handleData.soundProperties = new std::vector<am_SoundProperty_s>(listSoundProperties);
+        handle = createHandle(handleData, H_SETSOURCESOUNDPROPERTIES);
+        mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
+        return iter->second->asyncSetSourceSoundProperties(handle, sourceID, listSoundProperties);
+    }
     return (E_NON_EXISTENT);
 }
 
-am_Error_e RoutingSender::asyncSetSinkSoundProperties(am_Handle_s& handle, const std::vector<am_SoundProperty_s> & listSoundProperties, const am_sinkID_t sinkID)
+am_Error_e CAmRoutingSender::asyncSetSinkSoundProperties(am_Handle_s& handle, const std::vector<am_SoundProperty_s> & listSoundProperties, const am_sinkID_t sinkID)
 {
     am_handleData_c handleData;
     SinkInterfaceMap::iterator iter = mMapSinkInterface.begin();
     iter = mMapSinkInterface.find(sinkID);
     if (iter != mMapSinkInterface.end())
+    {
         handleData.sinkID = sinkID;
-    handleData.soundProperties = new std::vector<am_SoundProperty_s>(listSoundProperties);
-    handle = createHandle(handleData, H_SETSINKSOUNDPROPERTIES);
-    mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
-    return iter->second->asyncSetSinkSoundProperties(handle, sinkID, listSoundProperties);
+        handleData.soundProperties = new std::vector<am_SoundProperty_s>(listSoundProperties);
+        handle = createHandle(handleData, H_SETSINKSOUNDPROPERTIES);
+        mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
+        return iter->second->asyncSetSinkSoundProperties(handle, sinkID, listSoundProperties);
+    }
     return (E_NON_EXISTENT);
 
 }
 
-am_Error_e RoutingSender::asyncCrossFade(am_Handle_s& handle, const am_crossfaderID_t crossfaderID, const am_HotSink_e hotSink, const am_RampType_e rampType, const am_time_t time)
+am_Error_e CAmRoutingSender::asyncCrossFade(am_Handle_s& handle, const am_crossfaderID_t crossfaderID, const am_HotSink_e hotSink, const am_RampType_e rampType, const am_time_t time)
 {
     am_handleData_c handleData;
     CrossfaderInterfaceMap::iterator iter = mMapCrossfaderInterface.begin();
     iter = mMapCrossfaderInterface.find(crossfaderID);
     if (iter != mMapCrossfaderInterface.end())
+    {
         handleData.crossfaderID = crossfaderID;
-    handleData.hotSink = hotSink;
-    handle = createHandle(handleData, H_CROSSFADE);
-    mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
-    return iter->second->asyncCrossFade(handle, crossfaderID, hotSink, rampType, time);
+        handleData.hotSink = hotSink;
+        handle = createHandle(handleData, H_CROSSFADE);
+        mMapHandleInterface.insert(std::make_pair(handle.handle, iter->second));
+        return iter->second->asyncCrossFade(handle, crossfaderID, hotSink, rampType, time);
+    }
     return E_NON_EXISTENT;
 }
 
-am_Error_e RoutingSender::setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState)
+am_Error_e CAmRoutingSender::setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState)
 {
     DomainInterfaceMap::iterator iter = mMapDomainInterface.begin();
     iter = mMapDomainInterface.find(domainID);
@@ -352,7 +368,7 @@ am_Error_e RoutingSender::setDomainState(const am_domainID_t domainID, const am_
     return E_NON_EXISTENT;
 }
 
-am_Error_e RoutingSender::addDomainLookup(const am_Domain_s& domainData)
+am_Error_e CAmRoutingSender::addDomainLookup(const am_Domain_s& domainData)
 {
     std::vector<InterfaceNamePairs>::iterator iter = mListInterfaces.begin();
     std::vector<InterfaceNamePairs>::iterator iterEnd = mListInterfaces.end();
@@ -368,7 +384,7 @@ am_Error_e RoutingSender::addDomainLookup(const am_Domain_s& domainData)
     return E_UNKNOWN;
 }
 
-am_Error_e RoutingSender::addSourceLookup(const am_Source_s& sourceData)
+am_Error_e CAmRoutingSender::addSourceLookup(const am_Source_s& sourceData)
 {
     DomainInterfaceMap::iterator iter = mMapDomainInterface.begin();
     iter = mMapDomainInterface.find(sourceData.domainID);
@@ -381,7 +397,7 @@ am_Error_e RoutingSender::addSourceLookup(const am_Source_s& sourceData)
     return E_UNKNOWN;
 }
 
-am_Error_e RoutingSender::addSinkLookup(const am_Sink_s& sinkData)
+am_Error_e CAmRoutingSender::addSinkLookup(const am_Sink_s& sinkData)
 {
     DomainInterfaceMap::iterator iter = mMapDomainInterface.begin();
     iter = mMapDomainInterface.find(sinkData.domainID);
@@ -394,7 +410,7 @@ am_Error_e RoutingSender::addSinkLookup(const am_Sink_s& sinkData)
     return E_UNKNOWN;
 }
 
-am_Error_e RoutingSender::addCrossfaderLookup(const am_Crossfader_s& crossfaderData)
+am_Error_e CAmRoutingSender::addCrossfaderLookup(const am_Crossfader_s& crossfaderData)
 {
     DomainInterfaceMap::iterator iter = mMapSourceInterface.begin();
     iter = mMapSourceInterface.find(crossfaderData.sourceID);
@@ -407,7 +423,7 @@ am_Error_e RoutingSender::addCrossfaderLookup(const am_Crossfader_s& crossfaderD
     return E_UNKNOWN;
 }
 
-am_Error_e RoutingSender::removeDomainLookup(const am_domainID_t domainID)
+am_Error_e CAmRoutingSender::removeDomainLookup(const am_domainID_t domainID)
 {
     DomainInterfaceMap::iterator iter = mMapDomainInterface.begin();
     iter = mMapDomainInterface.find(domainID);
@@ -420,7 +436,7 @@ am_Error_e RoutingSender::removeDomainLookup(const am_domainID_t domainID)
     return E_NON_EXISTENT;
 }
 
-am_Error_e RoutingSender::removeSourceLookup(const am_sourceID_t sourceID)
+am_Error_e CAmRoutingSender::removeSourceLookup(const am_sourceID_t sourceID)
 {
     SourceInterfaceMap::iterator iter = mMapSourceInterface.begin();
     iter = mMapSourceInterface.find(sourceID);
@@ -433,7 +449,7 @@ am_Error_e RoutingSender::removeSourceLookup(const am_sourceID_t sourceID)
     return E_NON_EXISTENT;
 }
 
-am_Error_e RoutingSender::removeSinkLookup(const am_sinkID_t sinkID)
+am_Error_e CAmRoutingSender::removeSinkLookup(const am_sinkID_t sinkID)
 {
     SinkInterfaceMap::iterator iter = mMapSinkInterface.begin();
     iter = mMapSinkInterface.find(sinkID);
@@ -446,7 +462,7 @@ am_Error_e RoutingSender::removeSinkLookup(const am_sinkID_t sinkID)
     return E_NON_EXISTENT;
 }
 
-am_Error_e RoutingSender::removeCrossfaderLookup(const am_crossfaderID_t crossfaderID)
+am_Error_e CAmRoutingSender::removeCrossfaderLookup(const am_crossfaderID_t crossfaderID)
 {
     CrossfaderInterfaceMap::iterator iter = mMapCrossfaderInterface.begin();
     iter = mMapCrossfaderInterface.find(crossfaderID);
@@ -459,14 +475,14 @@ am_Error_e RoutingSender::removeCrossfaderLookup(const am_crossfaderID_t crossfa
     return E_NON_EXISTENT;
 }
 
-am_Error_e RoutingSender::removeHandle(const am_Handle_s& handle)
+am_Error_e CAmRoutingSender::removeHandle(const am_Handle_s& handle)
 {
     if (mlistActiveHandles.erase(handle))
         return E_OK;
     return E_UNKNOWN;
 }
 
-am_Error_e RoutingSender::getListHandles(std::vector<am_Handle_s> & listHandles) const
+am_Error_e CAmRoutingSender::getListHandles(std::vector<am_Handle_s> & listHandles) const
 {
     listHandles.clear();
     HandlesMap::const_iterator it = mlistActiveHandles.begin();
@@ -477,7 +493,7 @@ am_Error_e RoutingSender::getListHandles(std::vector<am_Handle_s> & listHandles)
     return E_OK;
 }
 
-am_Handle_s RoutingSender::createHandle(const am_handleData_c& handleData, const am_Handle_e type)
+am_Handle_s CAmRoutingSender::createHandle(const am_handleData_c& handleData, const am_Handle_e type)
 {
     am_Handle_s handle;
     handle.handle = ++mHandleCount; //todo: handle overflows here...
@@ -486,14 +502,14 @@ am_Handle_s RoutingSender::createHandle(const am_handleData_c& handleData, const
     return handle;
 }
 
-RoutingSender::am_handleData_c RoutingSender::returnHandleData(const am_Handle_s handle) const
+CAmRoutingSender::am_handleData_c CAmRoutingSender::returnHandleData(const am_Handle_s handle) const
 {
     HandlesMap::const_iterator it = mlistActiveHandles.begin();
     it = mlistActiveHandles.find(handle);
     return (it->second);
 }
 
-void RoutingSender::setRoutingReady()
+void CAmRoutingSender::setRoutingReady()
 {
     mRoutingReceiver->waitOnStartup(false);
     std::vector<InterfaceNamePairs>::iterator iter = mListInterfaces.begin();
@@ -505,7 +521,7 @@ void RoutingSender::setRoutingReady()
     mRoutingReceiver->waitOnStartup(true);
 }
 
-void RoutingSender::setRoutingRundown()
+void CAmRoutingSender::setRoutingRundown()
 {
     mRoutingReceiver->waitOnRundown(false);
     std::vector<InterfaceNamePairs>::iterator iter = mListInterfaces.begin();
@@ -517,7 +533,7 @@ void RoutingSender::setRoutingRundown()
     mRoutingReceiver->waitOnRundown(true);
 }
 
-void RoutingSender::unloadLibraries(void)
+void CAmRoutingSender::unloadLibraries(void)
 {
     std::vector<void*>::iterator iterator = mListLibraryHandles.begin();
     for (; iterator < mListLibraryHandles.end(); ++iterator)
@@ -527,7 +543,7 @@ void RoutingSender::unloadLibraries(void)
     mListLibraryHandles.clear();
 }
 
-am_Error_e RoutingSender::getListPlugins(std::vector<std::string>& interfaces) const
+am_Error_e CAmRoutingSender::getListPlugins(std::vector<std::string>& interfaces) const
 {
     std::vector<InterfaceNamePairs>::const_iterator it = mListInterfaces.begin();
     for (; it != mListInterfaces.end(); ++it)
@@ -537,8 +553,8 @@ am_Error_e RoutingSender::getListPlugins(std::vector<std::string>& interfaces) c
     return E_OK;
 }
 
-void RoutingSender::getInterfaceVersion(std::string & version) const
+void CAmRoutingSender::getInterfaceVersion(std::string & version) const
 {
     version = RoutingSendVersion;
 }
-
+}
diff --git a/AudioManagerDaemon/src/SocketHandler.cpp b/AudioManagerDaemon/src/CAmSocketHandler.cpp
index 444289f..2d5c7d7 100644
--- a/AudioManagerDaemon/src/SocketHandler.cpp
+++ b/AudioManagerDaemon/src/CAmSocketHandler.cpp
@@ -3,7 +3,7 @@
  *
  * GeniviAudioMananger AudioManagerDaemon
  *
- * \file DBusWrapper.cpp
+ * \file CAmDbusWrapper.cpp
  *
  * \date 20-Oct-2011 3:42:04 PM
  * \author Christian Mueller (christian.ei.mueller@bmw.de)
@@ -22,7 +22,7 @@
  *
  */
 
-#include "SocketHandler.h"
+#include "shared/CAmSocketHandler.h"
 #include <config.h>
 #include <cassert>
 #include <sys/fcntl.h>
@@ -32,14 +32,14 @@
 #include <time.h>
 #include <features.h>
 #include <csignal>
-#include "DLTWrapper.h"
+#include "shared/CAmDltWrapper.h"
 
 //todo: implement time correction if timer was interrupted by call
 //todo: change hitlist to a list that holds all information, because entering and removing items will be cheaper than with std::vector
 
-using namespace am;
+namespace am {
 
-SocketHandler::SocketHandler() :
+CAmSocketHandler::CAmSocketHandler() :
         mListPoll(), //
         mListTimer(), //
         mListActiveTimer(), //
@@ -54,7 +54,7 @@ SocketHandler::SocketHandler() :
     gDispatchDone = 0;
 }
 
-SocketHandler::~SocketHandler()
+CAmSocketHandler::~CAmSocketHandler()
 {
 }
 
@@ -62,7 +62,7 @@ SocketHandler::~SocketHandler()
 /**
  * start the block listening for filedescriptors. This is the mainloop.
  */
-void SocketHandler::start_listenting()
+void CAmSocketHandler::start_listenting()
 {
     gDispatchDone=0;
     int16_t pollStatus;
@@ -84,7 +84,7 @@ void SocketHandler::start_listenting()
     {
         //first we go through the registered filedescriptors and check if someone needs preparation:
         mListPoll_t::iterator prepIter = mListPoll.begin();
-        shPollPrepare *prep = NULL;
+        CAmShPollPrepare *prep = NULL;
         for (; prepIter != mListPoll.end(); ++prepIter)
         {
             if ((prep = prepIter->prepareCB) != NULL)
@@ -95,7 +95,7 @@ void SocketHandler::start_listenting()
         {
             mfdPollingArray.clear();
             //there was a change in the setup, so we need to recreate the fdarray from the list
-            std::for_each(mListPoll.begin(), mListPoll.end(), CopyPollfd(mfdPollingArray));
+            std::for_each(mListPoll.begin(), mListPoll.end(), CAmShCopyPollfd(mfdPollingArray));
             mRecreatePollfds = false;
         }
 
@@ -156,7 +156,7 @@ void SocketHandler::start_listenting()
             std::list<int16_t>::iterator hListIt = hitList.begin();
             for (; hListIt != hitList.end(); ++hListIt)
             {
-                shPollFired* fire = NULL;
+                CAmShPollFired* fire = NULL;
                 if ((fire = listPoll.at(*hListIt).firedCB) != NULL)
                     fire->Call(mfdPollingArray.at(*hListIt), listPoll.at(*hListIt).handle, listPoll.at(*hListIt).userData);
             }
@@ -165,7 +165,7 @@ void SocketHandler::start_listenting()
             hListIt = hitList.begin();
             for (; hListIt != hitList.end(); ++hListIt)
             {
-                shPollCheck* check = NULL;
+                CAmShPollCheck* check = NULL;
                 if ((check = listPoll.at(*hListIt).checkCB) != NULL)
                 {
                     if (!check->Call(listPoll.at(*hListIt).handle, listPoll.at(*hListIt).userData))
@@ -181,7 +181,7 @@ void SocketHandler::start_listenting()
                 hListIt = hitList.begin();
                 for (; hListIt != hitList.end(); ++hListIt)
                 {
-                    shPollDispatch *dispatch = NULL;
+                    CAmShPollDispatch *dispatch = NULL;
                     if ((dispatch = listPoll.at(*hListIt).dispatchCB) != NULL)
                     {
                         if (!dispatch->Call(listPoll.at(*hListIt).handle, listPoll.at(*hListIt).userData))
@@ -208,7 +208,7 @@ void SocketHandler::start_listenting()
 /**
  * exits the loop
  */
-void SocketHandler::stop_listening()
+void CAmSocketHandler::stop_listening()
 {
     gDispatchDone = 1;
 }
@@ -220,8 +220,7 @@ void SocketHandler::stop_listening()
  * @param callback the callback that shall be called if the filedescriptor poll succeeded
  * @return E_OK if the descriptor was added, E_NON_EXISTENT if the fd is not valid
  */
-
-am_Error_e SocketHandler::addFDPoll(const int fd, const short  event, shPollPrepare *prepare, shPollFired *fired, shPollCheck *check, shPollDispatch *dispatch, void *userData, sh_pollHandle_t & handle)
+am_Error_e CAmSocketHandler::addFDPoll(const int fd, const short  event, CAmShPollPrepare *prepare, CAmShPollFired *fired, CAmShPollCheck *check, CAmShPollDispatch *dispatch, void *userData, sh_pollHandle_t & handle)
 {
     if (!fdIsValid(fd))
         return E_NON_EXISTENT;
@@ -251,7 +250,7 @@ am_Error_e SocketHandler::addFDPoll(const int fd, const short  event, shPollPrep
  * @param fd the filedescriptor to be removed
  * @return E_OK in case of sucess, E_NON_EXISTENT or E_UNKNOWN if the fd in not registered
  */
-am_Error_e SocketHandler::removeFDPoll(const sh_pollHandle_t handle)
+am_Error_e CAmSocketHandler::removeFDPoll(const sh_pollHandle_t handle)
 {
     mListPoll_t::iterator iterator = mListPoll.begin();
 
@@ -277,12 +276,12 @@ am_Error_e SocketHandler::removeFDPoll(const sh_pollHandle_t handle)
  * @param handle the handle that is created for the timer is returned. Can be used to remove the timer
  * @return E_OK in case of success
  */
-am_Error_e SocketHandler::addTimer(const timespec timeouts, shTimerCallBack*& callback, sh_timerHandle_t& handle, void * userData)
+am_Error_e CAmSocketHandler::addTimer(const timespec timeouts, CAmShTimerCallBack*& callback, sh_timerHandle_t& handle, void * userData)
 {
     assert(!((timeouts.tv_sec==0) && (timeouts.tv_nsec==0)));
     assert(callback!=NULL);
 
-    timer_s timerItem;
+    sh_timer_s timerItem;
 
     //create a new handle for the timer
     handle = ++mLastInsertedHandle; //todo: overflow ruling !
@@ -307,14 +306,14 @@ am_Error_e SocketHandler::addTimer(const timespec timeouts, shTimerCallBack*& ca
  * @param handle the handle to the timer
  * @return E_OK in case of success, E_UNKNOWN if timer was not found.
  */
-am_Error_e SocketHandler::removeTimer(const sh_timerHandle_t handle)
+am_Error_e CAmSocketHandler::removeTimer(const sh_timerHandle_t handle)
 {
     assert(handle!=0);
 
     //stop the current timer
     stopTimer(handle);
 
-    std::list<timer_s>::iterator it = mListTimer.begin();
+    std::list<sh_timer_s>::iterator it = mListTimer.begin();
     for (; it != mListTimer.end(); ++it)
     {
         if (it->handle == handle)
@@ -332,10 +331,10 @@ am_Error_e SocketHandler::removeTimer(const sh_timerHandle_t handle)
  * @param timeouts new timout time
  * @return E_OK on success, E_NON_EXISTENT if the handle was not found
  */
-am_Error_e SocketHandler::restartTimer(const sh_timerHandle_t handle, const timespec timeouts)
+am_Error_e CAmSocketHandler::restartTimer(const sh_timerHandle_t handle, const timespec timeouts)
 {
-    timer_s timerItem;
-    std::list<timer_s>::iterator it = mListTimer.begin();
+    sh_timer_s timerItem;
+    std::list<sh_timer_s>::iterator it = mListTimer.begin();
     for (; it != mListTimer.end(); ++it)
     {
         if (it->handle == handle)
@@ -358,10 +357,10 @@ am_Error_e SocketHandler::restartTimer(const sh_timerHandle_t handle, const time
     return E_OK;
 }
 
-am_Error_e SocketHandler::stopTimer(const sh_timerHandle_t handle)
+am_Error_e CAmSocketHandler::stopTimer(const sh_timerHandle_t handle)
 {
     //go through the list and remove the timer with the handle
-    std::list<timer_s>::iterator it = mListActiveTimer.begin();
+    std::list<sh_timer_s>::iterator it = mListActiveTimer.begin();
     for (; it != mListActiveTimer.end(); ++it)
     {
         if (it->handle == handle)
@@ -388,7 +387,7 @@ am_Error_e SocketHandler::stopTimer(const sh_timerHandle_t handle)
  * @param event the event flags
  * @return E_OK on succsess, E_NON_EXISTENT if fd was not found
  */
-am_Error_e SocketHandler::updateEventFlags(const sh_pollHandle_t handle, const short events)
+am_Error_e CAmSocketHandler::updateEventFlags(const sh_pollHandle_t handle, const short events)
 {
     mListPoll_t::iterator iterator = mListPoll.begin();
 
@@ -409,7 +408,7 @@ am_Error_e SocketHandler::updateEventFlags(const sh_pollHandle_t handle, const s
  * @param fd the filedescriptor
  * @return true if the fd is valid
  */
-bool SocketHandler::fdIsValid(const int fd) const
+bool CAmSocketHandler::fdIsValid(const int fd) const
 {
     return (fcntl(fd, F_GETFL) != -1 || errno != EBADF);
 }
@@ -418,7 +417,7 @@ bool SocketHandler::fdIsValid(const int fd) const
  * whenever a timer is up, this function needs to be called.
  * Removes the fired timer, calls the callback and resets mTimeout
  */
-void SocketHandler::timerUp()
+void CAmSocketHandler::timerUp()
 {
     //first fire the event
     mListActiveTimer.front().callback->Call(mListActiveTimer.front().handle, mListActiveTimer.front().userData);
@@ -428,7 +427,7 @@ void SocketHandler::timerUp()
     if (!mListActiveTimer.empty())
     {
         //substract the old value from all timers in the list
-        std::for_each(mListActiveTimer.begin(), mListActiveTimer.end(), SubstractTime(mTimeout));
+        std::for_each(mListActiveTimer.begin(), mListActiveTimer.end(), CAmShSubstractTime(mTimeout));
         mTimeout = mListActiveTimer.front().countdown;
     }
     else
@@ -441,7 +440,7 @@ void SocketHandler::timerUp()
 /**
  * init the timers
  */
-void SocketHandler::initTimer()
+void CAmSocketHandler::initTimer()
 {
     if (!mListActiveTimer.empty())
     {
@@ -459,12 +458,12 @@ void SocketHandler::initTimer()
  * @param time time in timespec
  * @return time in milliseconds
  */
-inline int SocketHandler::timespec2ms(const timespec & time)
+inline int CAmSocketHandler::timespec2ms(const timespec & time)
 {
     return (time.tv_nsec == -1 && time.tv_sec == -1) ? -1 : time.tv_sec * 1000 + time.tv_nsec / 1000000;
 }
 
-inline timespec* am::SocketHandler::insertTime(timespec& buffertime)
+inline timespec* CAmSocketHandler::insertTime(timespec& buffertime)
 {
     buffertime.tv_nsec = mTimeout.tv_nsec;
     buffertime.tv_sec = mTimeout.tv_sec;
@@ -475,7 +474,7 @@ inline timespec* am::SocketHandler::insertTime(timespec& buffertime)
  * functor to easy substract from each countdown
  * @param t value to substract from
  */
-void SocketHandler::SubstractTime::operator ()(timer_s & t) const
+void CAmSocketHandler::CAmShSubstractTime::operator ()(sh_timer_s & t) const
 {
     int val = 0;
     if ((val = t.countdown.tv_nsec - param.tv_nsec) < 0)
@@ -490,10 +489,10 @@ void SocketHandler::SubstractTime::operator ()(timer_s & t) const
     (t.countdown.tv_sec - param.tv_sec) < 0 ? 0 : (t.countdown.tv_sec -= param.tv_sec);
 }
 
-void SocketHandler::CopyPollfd::operator ()(const sh_poll_s & row)
+void CAmSocketHandler::CAmShCopyPollfd::operator ()(const sh_poll_s & row)
 {
     pollfd temp = row.pollfdValue;
     temp.revents = 0;
     mArray.push_back(temp);
 }
-
+}
diff --git a/AudioManagerDaemon/src/CAmTelnetMenuHelper.cpp b/AudioManagerDaemon/src/CAmTelnetMenuHelper.cpp
index 9e052cc..92fb09d 100644
--- a/AudioManagerDaemon/src/CAmTelnetMenuHelper.cpp
+++ b/AudioManagerDaemon/src/CAmTelnetMenuHelper.cpp
@@ -23,30 +23,30 @@
  */
 
 #include "CAmTelnetMenuHelper.h"
-#include "TelnetServer.h"
-#include "DatabaseHandler.h"
-#include "ControlSender.h"
-#include "CommandSender.h"
-#include "RoutingSender.h"
-#include "RoutingReceiver.h"
-#include "CommandReceiver.h"
-#include "ControlReceiver.h"
-#include "Router.h"
-#include "config.h"
-#include "DLTWrapper.h"
 #include <cassert>
+#include "config.h"
+#include "CAmRouter.h"
+#include "CAmTelnetServer.h"
+#include "CAmDatabaseHandler.h"
+#include "CAmControlSender.h"
+#include "CAmCommandSender.h"
+#include "CAmRoutingSender.h"
+#include "CAmRoutingReceiver.h"
+#include "CAmCommandReceiver.h"
+#include "CAmControlReceiver.h"
+#include "shared/CAmDltWrapper.h"
 
 static const std::string COLOR_WELCOME("\033[1;33m\033[44m");
 static const std::string COLOR_HEAD("\033[1m\033[42m");
 static const std::string COLOR_DEFAULT("\033[0m");
 
 
-using namespace am;
+namespace am {
 
 CAmTelnetMenuHelper* CAmTelnetMenuHelper::instance = NULL;
 
 /****************************************************************************/
-CAmTelnetMenuHelper::CAmTelnetMenuHelper(SocketHandler *iSocketHandler, CommandSender *iCommandSender, CommandReceiver *iCommandReceiver, RoutingSender *iRoutingSender, RoutingReceiver *iRoutingReceiver, ControlSender *iControlSender, ControlReceiver *iControlReceiver, DatabaseHandler *iDatabasehandler, Router *iRouter, TelnetServer *iTelnetServer)
+CAmTelnetMenuHelper::CAmTelnetMenuHelper(CAmSocketHandler *iSocketHandler, CAmCommandSender *iCommandSender, CAmCommandReceiver *iCommandReceiver, CAmRoutingSender *iRoutingSender, CAmRoutingReceiver *iRoutingReceiver, CAmControlSender *iControlSender, CAmControlReceiver *iControlReceiver, CAmDatabaseHandler *iDatabasehandler, CAmRouter *iRouter, CAmTelnetServer *iTelnetServer)
 /****************************************************************************/
 :mpTelenetServer(iTelnetServer), mpSocketHandler(iSocketHandler), mpCommandSender(iCommandSender), mpCommandReceiver(iCommandReceiver), mpRoutingSender(iRoutingSender), mpRoutingReceiver(iRoutingReceiver), mpControlSender(iControlSender), mpControlReceiver(iControlReceiver), mpDatabasehandler(iDatabasehandler), mpRouter(iRouter)
 {
@@ -1296,7 +1296,7 @@ void CAmTelnetMenuHelper::listMainConnectionsCommandExec(std::queue<std::string>
         sendError(filedescriptor,"ERROR: mDatabasehandler->getListMainSinks");
     }
 }
-
+}
 
 
 
diff --git a/AudioManagerDaemon/src/TelnetServer.cpp b/AudioManagerDaemon/src/CAmTelnetServer.cpp
index 1cae985..1274a8d 100644
--- a/AudioManagerDaemon/src/TelnetServer.cpp
+++ b/AudioManagerDaemon/src/CAmTelnetServer.cpp
@@ -3,7 +3,7 @@
  *
  * GeniviAudioMananger AudioManagerDaemon
  *
- * \file TelnetServer.cpp
+ * \file CAmTelnetServer.cpp
  *
  * \date 20-Oct-2011 3:42:04 PM
  * \author Christian Mueller (christian.ei.mueller@bmw.de)
@@ -22,7 +22,7 @@
  *
  */
 
-#include "TelnetServer.h"
+#include "CAmTelnetServer.h"
 #include <cassert>
 #include <sys/socket.h>
 #include <arpa/inet.h>
@@ -35,22 +35,22 @@
 #include <istream>
 #include <iostream>
 #include <iterator>
-#include "DatabaseHandler.h"
-#include "RoutingSender.h"
-#include "DLTWrapper.h"
+#include "CAmDatabaseHandler.h"
+#include "CAmRoutingSender.h"
+#include "shared/CAmDltWrapper.h"
 #include "CAmTelnetMenuHelper.h"
 
-using namespace am;
+namespace am {
 
-TelnetServer* TelnetServer::instance = NULL;
+CAmTelnetServer* CAmTelnetServer::instance = NULL;
 
 #define PRINT_BOOL(var) var ? output+="true\t\t" : output+="false\t\t";
 
-TelnetServer::TelnetServer(SocketHandler *iSocketHandler, CommandSender *iCommandSender, CommandReceiver *iCommandReceiver, RoutingSender *iRoutingSender, RoutingReceiver *iRoutingReceiver, ControlSender *iControlSender, ControlReceiver *iControlReceiver, DatabaseHandler *iDatabasehandler, Router *iRouter, unsigned int servPort, unsigned int maxConnections)
-   :telnetConnectFiredCB(this,&TelnetServer::connectSocket),
-   telnetReceiveFiredCB(this,&TelnetServer::receiveData),
-   telnetDispatchCB(this,&TelnetServer::dispatchData),
-   telnetCheckCB(this,&TelnetServer::check),
+CAmTelnetServer::CAmTelnetServer(CAmSocketHandler *iSocketHandler, CAmCommandSender *iCommandSender, CAmCommandReceiver *iCommandReceiver, CAmRoutingSender *iRoutingSender, CAmRoutingReceiver *iRoutingReceiver, CAmControlSender *iControlSender, CAmControlReceiver *iControlReceiver, CAmDatabaseHandler *iDatabasehandler, CAmRouter *iRouter, unsigned int servPort, unsigned int maxConnections)
+   :telnetConnectFiredCB(this,&CAmTelnetServer::connectSocket),
+   telnetReceiveFiredCB(this,&CAmTelnetServer::receiveData),
+   telnetDispatchCB(this,&CAmTelnetServer::dispatchData),
+   telnetCheckCB(this,&CAmTelnetServer::check),
    mSocketHandler(iSocketHandler),
    mCommandSender(iCommandSender),
    mCommandReceiver(iCommandReceiver),
@@ -111,11 +111,11 @@ TelnetServer::TelnetServer(SocketHandler *iSocketHandler, CommandSender *iComman
     mSocketHandler->addFDPoll(mConnectFD, events, NULL, &telnetConnectFiredCB, NULL, NULL, NULL, mConnecthandle);
 }
 
-TelnetServer::~TelnetServer()
+CAmTelnetServer::~CAmTelnetServer()
 {
 }
 
-void TelnetServer::connectSocket(const pollfd pfd, const sh_pollHandle_t handle, void *userData)
+void CAmTelnetServer::connectSocket(const pollfd pfd, const sh_pollHandle_t handle, void *userData)
 {
     (void) handle;
     (void) userData;
@@ -138,7 +138,7 @@ void TelnetServer::connectSocket(const pollfd pfd, const sh_pollHandle_t handle,
 	mListConnections.push_back(connection);
 }
 
-void TelnetServer::disconnectClient(int filedescriptor)
+void CAmTelnetServer::disconnectClient(int filedescriptor)
 {
    std::vector<connection_s>::iterator iter = mListConnections.begin();
    while(iter != mListConnections.end())
@@ -161,7 +161,7 @@ void TelnetServer::disconnectClient(int filedescriptor)
    }
 }
 
-void TelnetServer::receiveData(const pollfd pollfd, const sh_pollHandle_t handle, void *userData)
+void CAmTelnetServer::receiveData(const pollfd pollfd, const sh_pollHandle_t handle, void *userData)
 {
     (void) handle;
     (void) userData;
@@ -177,7 +177,7 @@ void TelnetServer::receiveData(const pollfd pollfd, const sh_pollHandle_t handle
 	}
 }
 
-bool TelnetServer::dispatchData(const sh_pollHandle_t handle, void *userData)
+bool CAmTelnetServer::dispatchData(const sh_pollHandle_t handle, void *userData)
 {
     (void) userData;
 	std::vector<connection_s>::iterator iterator=mListConnections.begin();
@@ -219,7 +219,7 @@ bool TelnetServer::dispatchData(const sh_pollHandle_t handle, void *userData)
 	*/
 }
 
-bool TelnetServer::check(const sh_pollHandle_t handle, void *userData)
+bool CAmTelnetServer::check(const sh_pollHandle_t handle, void *userData)
 {
     (void)handle;
     (void)userData;
@@ -227,7 +227,7 @@ bool TelnetServer::check(const sh_pollHandle_t handle, void *userData)
     return false;
 }
 
-void am::TelnetServer::sliceCommand(const std::string & string, std::string & command, std::queue<std::string> & MsgQueue)
+void am::CAmTelnetServer::sliceCommand(const std::string & string, std::string & command, std::queue<std::string> & MsgQueue)
 {
     (void) command;
     std::stringstream stream(string);
@@ -257,5 +257,6 @@ void am::TelnetServer::sliceCommand(const std::string & string, std::string & co
     msg = std::vector<std::string>(begin, end);
     */
 }
+}
 
 
diff --git a/AudioManagerDaemon/src/DatabaseObserver.cpp b/AudioManagerDaemon/src/DatabaseObserver.cpp
deleted file mode 100644
index 93031ef..0000000
--- a/AudioManagerDaemon/src/DatabaseObserver.cpp
+++ /dev/null
@@ -1,206 +0,0 @@
-/**
- * Copyright (C) 2011, BMW AG
- *
- * GeniviAudioMananger AudioManagerDaemon
- *
- * \file DatabaseObserver.cpp
- *
- * \date 20-Oct-2011 3:42:04 PM
- * \author Christian Mueller (christian.ei.mueller@bmw.de)
- *
- * \section License
- * GNU Lesser General Public License, version 2.1, with special exception (GENIVI clause)
- * Copyright (C) 2011, BMW AG Christian Mueller  Christian.ei.mueller@bmw.de
- *
- * This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License, version 2.1, as published by the Free Software Foundation.
- * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License, version 2.1, for more details.
- * You should have received a copy of the GNU Lesser General Public License, version 2.1, along with this program; if not, see <http://www.gnu.org/licenses/lgpl-2.1.html>.
- * Note that the copyright holders assume that the GNU Lesser General Public License, version 2.1, may also be applicable to programs even in cases in which the program is not a library in the technical sense.
- * Linking AudioManager statiasyncCally or dynamiasyncCally with other modules is making a combined work based on AudioManager. You may license such other modules under the GNU Lesser General Public License, version 2.1. If you do not want to license your linked modules under the GNU Lesser General Public License, version 2.1, you may use the program under the following exception.
- * As a special exception, the copyright holders of AudioManager give you permission to combine AudioManager with software programs or libraries that are released under any license unless such a combination is not permitted by the license of such a software program or library. You may copy and distribute such a system following the terms of the GNU Lesser General Public License, version 2.1, including this special exception, for AudioManager and the licenses of the other code concerned.
- * Note that people who make modified versions of AudioManager are not obligated to grant this special exception for their modified versions; it is their choice whether to do so. The GNU Lesser General Public License, version 2.1, gives permission to release a modified version without this exception; this exception also makes it possible to release a modified version which carries forward this exception.
- *
- */
-
-#include "DatabaseObserver.h"
-#include <string.h>
-#include <cassert>
-#include <errno.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include "CommandSender.h"
-#include "RoutingSender.h"
-#include "TelnetServer.h"
-#include "DLTWrapper.h"
-//#include "CAmSerializer.h"
-
-using namespace am;
-
-DatabaseObserver::DatabaseObserver(CommandSender *iCommandSender, RoutingSender *iRoutingSender, SocketHandler *iSocketHandler) :
-        mCommandSender(iCommandSender), //
-        mRoutingSender(iRoutingSender), //
-        mSerializer(iSocketHandler) //
-{
-    assert(mCommandSender!=0);
-    assert(mRoutingSender!=0);
-    assert(iSocketHandler!=0);
-}
-
-DatabaseObserver::DatabaseObserver(CommandSender *iCommandSender, RoutingSender *iRoutingSender, SocketHandler *iSocketHandler, TelnetServer *iTelnetServer) :
-        mCommandSender(iCommandSender), //
-        mRoutingSender(iRoutingSender), //
-        mTelnetServer(iTelnetServer), //
-        mSerializer(iSocketHandler) //
-{
-    assert(mTelnetServer!=0);
-    assert(mCommandSender!=0);
-    assert(mRoutingSender!=0);
-    assert(iSocketHandler!=0);
-}
-
-DatabaseObserver::~DatabaseObserver()
-{
-}
-
-void DatabaseObserver::newMainConnection(const am_MainConnectionType_s& mainConnection)
-{
-    mSerializer.asyncCall<CommandSender, const am_MainConnectionType_s>(mCommandSender, &CommandSender::cbNewMainConnection, mainConnection);
-}
-
-void DatabaseObserver::removedMainConnection(const am_mainConnectionID_t mainConnection)
-{
-    mSerializer.asyncCall<CommandSender, const am_mainConnectionID_t>(mCommandSender, &CommandSender::cbRemovedMainConnection, mainConnection);
-}
-
-void DatabaseObserver::newSink(const am_Sink_s& sink)
-{
-    mRoutingSender->addSinkLookup(sink);
-    if (sink.visible)
-    {
-        am_SinkType_s s;
-        s.availability = sink.available;
-        s.muteState = sink.muteState;
-        s.name = sink.name;
-        s.sinkClassID = sink.sinkClassID;
-        s.sinkID = sink.sinkID;
-        s.volume = sink.mainVolume;
-        mSerializer.asyncCall<CommandSender, const am_SinkType_s>(mCommandSender, &CommandSender::cbNewSink, s);
-    }
-}
-
-void DatabaseObserver::newSource(const am_Source_s& source)
-{
-    mRoutingSender->addSourceLookup(source);
-    if (source.visible)
-    {
-        am_SourceType_s s;
-        s.availability = source.available;
-        s.name = source.name;
-        s.sourceClassID = source.sourceClassID;
-        s.sourceID = source.sourceID;
-        mSerializer.asyncCall<CommandSender, const am_SourceType_s>(mCommandSender, &CommandSender::cbNewSource, s);
-    }
-}
-
-void DatabaseObserver::newDomain(const am_Domain_s& domain)
-{
-    mRoutingSender->addDomainLookup(domain);
-}
-
-void DatabaseObserver::newGateway(const am_Gateway_s& gateway)
-{
-    (void) gateway;
-    //todo: implement something
-}
-
-void DatabaseObserver::newCrossfader(const am_Crossfader_s& crossfader)
-{
-    mRoutingSender->addCrossfaderLookup(crossfader);
-}
-
-void DatabaseObserver::removedSink(const am_sinkID_t sinkID, const bool visible)
-{
-    mRoutingSender->removeSinkLookup(sinkID);
-
-    if (visible)
-        mSerializer.asyncCall<CommandSender, const am_sinkID_t>(mCommandSender, &CommandSender::cbRemovedSink, sinkID);
-}
-
-void DatabaseObserver::removedSource(const am_sourceID_t sourceID, const bool visible)
-{
-    mRoutingSender->removeSourceLookup(sourceID);
-
-    if (visible)
-        mSerializer.asyncCall<CommandSender, const am_sourceID_t>(mCommandSender, &CommandSender::cbRemovedSource, sourceID);
-}
-
-void DatabaseObserver::removeDomain(const am_domainID_t domainID)
-{
-    mRoutingSender->removeDomainLookup(domainID);
-}
-
-void DatabaseObserver::removeGateway(const am_gatewayID_t gatewayID)
-{
-    (void) gatewayID;
-    //todo: implement something?
-}
-
-void DatabaseObserver::removeCrossfader(const am_crossfaderID_t crossfaderID)
-{
-    mRoutingSender->removeCrossfaderLookup(crossfaderID);
-}
-
-void DatabaseObserver::numberOfSinkClassesChanged()
-{
-    mSerializer.asyncCall<CommandSender>(mCommandSender, &CommandSender::cbNumberOfSinkClassesChanged);
-}
-
-void DatabaseObserver::numberOfSourceClassesChanged()
-{
-    mSerializer.asyncCall<CommandSender>(mCommandSender, &CommandSender::cbNumberOfSourceClassesChanged);
-}
-
-void DatabaseObserver::mainConnectionStateChanged(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState)
-{
-    mSerializer.asyncCall<CommandSender, const am_connectionID_t, const am_ConnectionState_e>(mCommandSender, &CommandSender::cbMainConnectionStateChanged, connectionID, connectionState);
-}
-
-void DatabaseObserver::mainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty)
-{
-    mSerializer.asyncCall<CommandSender, const am_sinkID_t, const am_MainSoundProperty_s&>(mCommandSender, &CommandSender::cbMainSinkSoundPropertyChanged, sinkID, SoundProperty);
-}
-
-void DatabaseObserver::mainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s & SoundProperty)
-{
-    mSerializer.asyncCall<CommandSender, const am_sourceID_t, const am_MainSoundProperty_s&>(mCommandSender, &CommandSender::cbMainSourceSoundPropertyChanged, sourceID, SoundProperty);
-}
-
-void DatabaseObserver::sinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s & availability)
-{
-    mSerializer.asyncCall<CommandSender, const am_sinkID_t, const am_Availability_s&>(mCommandSender, &CommandSender::cbSinkAvailabilityChanged, sinkID, availability);
-}
-
-void DatabaseObserver::sourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s & availability)
-{
-    mSerializer.asyncCall<CommandSender, const am_sourceID_t, const am_Availability_s&>(mCommandSender, &CommandSender::cbSourceAvailabilityChanged, sourceID, availability);
-}
-
-void DatabaseObserver::volumeChanged(const am_sinkID_t sinkID, const am_mainVolume_t volume)
-{
-    mSerializer.asyncCall<CommandSender, const am_sinkID_t, const am_mainVolume_t>(mCommandSender, &CommandSender::cbVolumeChanged, sinkID, volume);
-}
-
-void DatabaseObserver::sinkMuteStateChanged(const am_sinkID_t sinkID, const am_MuteState_e muteState)
-{
-    mSerializer.asyncCall<CommandSender, const am_sinkID_t, const am_MuteState_e>(mCommandSender, &CommandSender::cbSinkMuteStateChanged, sinkID, muteState);
-}
-
-void DatabaseObserver::systemPropertyChanged(const am_SystemProperty_s& SystemProperty)
-{
-    mSerializer.asyncCall<CommandSender, const am_SystemProperty_s&>(mCommandSender, &CommandSender::cbSystemPropertyChanged, SystemProperty);
-}
-
-void DatabaseObserver::timingInformationChanged(const am_mainConnectionID_t mainConnection, const am_timeSync_t time)
-{
-    mSerializer.asyncCall<CommandSender, const am_mainConnectionID_t, const am_timeSync_t>(mCommandSender, &CommandSender::cbTimingInformationChanged, mainConnection, time);
-}
diff --git a/AudioManagerDaemon/src/main.cpp b/AudioManagerDaemon/src/main.cpp
index dee5edb..b6acf5d 100644
--- a/AudioManagerDaemon/src/main.cpp
+++ b/AudioManagerDaemon/src/main.cpp
@@ -35,22 +35,22 @@
 
 #include <config.h>
 #ifdef  WITH_TELNET
-#include "TelnetServer.h"
+#include "CAmTelnetServer.h"
 #endif
 #ifdef WITH_DBUS_WRAPPER
-#include <dbus/DBusWrapper.h>
+#include <shared/CAmDbusWrapper.h>
 #endif
-#include <SocketHandler.h>
-#include "DatabaseHandler.h"
-#include "ControlSender.h"
-#include "CommandSender.h"
-#include "RoutingSender.h"
-#include "RoutingReceiver.h"
-#include "CommandReceiver.h"
-#include "ControlReceiver.h"
-#include "DatabaseObserver.h"
-#include "Router.h"
-#include "DLTWrapper.h"
+#include <shared/CAmSocketHandler.h>
+#include "CAmDatabaseHandler.h"
+#include "CAmControlSender.h"
+#include "CAmCommandSender.h"
+#include "CAmRoutingSender.h"
+#include "CAmRoutingReceiver.h"
+#include "CAmCommandReceiver.h"
+#include "CAmControlReceiver.h"
+#include "CAmDatabaseObserver.h"
+#include "CAmRouter.h"
+#include "shared/CAmDltWrapper.h"
 #include <sys/resource.h>
 #include <sys/stat.h>
 #include <unistd.h>
@@ -219,16 +219,15 @@ static void signalHandler(int sig, siginfo_t *siginfo, void *context)
     logError("signal handler was called, exit now...");
     gDispatchDone = 1;
     //todo: maually fire the mainloop
-    //todo: ifdef no sockethandler
     exit(1);
 }
 
 int main(int argc, char *argv[])
 {
-    DLTWrapper::instance()->registerApp("AudioManagerDeamon", "AudioManagerDeamon");
-    DLTWrapper::instance()->registerContext(AudioManager, "Main", "Main Context");
+    CAmDltWrapper::instance(true)->registerApp("AudioManagerDeamon", "AudioManagerDeamon");
+    CAmDltWrapper::instance()->registerContext(AudioManager, "Main", "Main Context");
     logInfo("The Audiomanager is started");
-    log(&AudioManager, DLT_LOG_ERROR, "The version of the Audiomanager", DAEMONVERSION);
+    logInfo("The version of the Audiomanager", DAEMONVERSION);
 
     listCommandPluginDirs.push_back(std::string(DEFAULT_PLUGIN_COMMAND_DIR));
     listRoutingPluginDirs.push_back(std::string(DEFAULT_PLUGIN_ROUTING_DIR));
@@ -256,40 +255,36 @@ int main(int argc, char *argv[])
     std::set_new_handler(&OutOfMemoryHandler);
 
     //Instantiate all classes. Keep in same order !
-    SocketHandler iSocketHandler;
+    CAmSocketHandler iSocketHandler;
 
 
 #ifdef WITH_DBUS_WRAPPER
-    DBusWrapper iDBusWrapper(&iSocketHandler);
+    CAmDbusWrapper iDBusWrapper(&iSocketHandler);
 #endif /*WITH_DBUS_WRAPPER */
 
-    DatabaseHandler iDatabaseHandler(databasePath);
-    RoutingSender iRoutingSender(listRoutingPluginDirs);
-    CommandSender iCommandSender(listCommandPluginDirs);
-    ControlSender iControlSender(controllerPlugin);
-    Router iRouter(&iDatabaseHandler, &iControlSender);
+    CAmDatabaseHandler iDatabaseHandler(databasePath);
+    CAmRoutingSender iRoutingSender(listRoutingPluginDirs);
+    CAmCommandSender iCommandSender(listCommandPluginDirs);
+    CAmControlSender iControlSender(controllerPlugin);
+    CAmRouter iRouter(&iDatabaseHandler, &iControlSender);
 
 #ifdef WITH_DBUS_WRAPPER
-    CommandReceiver iCommandReceiver(&iDatabaseHandler, &iControlSender, &iSocketHandler, &iDBusWrapper);
-    RoutingReceiver iRoutingReceiver(&iDatabaseHandler, &iRoutingSender, &iControlSender, &iSocketHandler, &iDBusWrapper);
-    ControlReceiver iControlReceiver(&iDatabaseHandler, &iRoutingSender, &iCommandSender, &iSocketHandler, &iRouter);
-#ifdef WITH_TELNET
-    TelnetServer iTelnetServer(&iSocketHandler, &iCommandSender, &iCommandReceiver, &iRoutingSender, &iRoutingReceiver, &iControlSender, &iControlReceiver, &iDatabaseHandler, &iRouter, telnetport, maxConnections);
-    DatabaseObserver iObserver(&iCommandSender, &iRoutingSender, &iSocketHandler, &iTelnetServer);
-#else /*WITH_TELNET*/
-    DatabaseObserver iObserver(&iCommandSender,&iRoutingSender, &iSocketHandler);
-#endif
+    CAmCommandReceiver iCommandReceiver(&iDatabaseHandler, &iControlSender, &iSocketHandler, &iDBusWrapper);
+    CAmRoutingReceiver iRoutingReceiver(&iDatabaseHandler, &iRoutingSender, &iControlSender, &iSocketHandler, &iDBusWrapper);
+    CAmControlReceiver iControlReceiver(&iDatabaseHandler, &iRoutingSender, &iCommandSender, &iSocketHandler, &iRouter);
 #else /*WITH_DBUS_WRAPPER*/
-    CommandReceiver iCommandReceiver(&iDatabaseHandler,&iControlSender,&iSocketHandler);
-    RoutingReceiver iRoutingReceiver(&iDatabaseHandler,&iRoutingSender,&iControlSender,&iSocketHandler);
+    CAmCommandReceiver iCommandReceiver(&iDatabaseHandler,&iControlSender,&iSocketHandler);
+    CAmRoutingReceiver iRoutingReceiver(&iDatabaseHandler,&iRoutingSender,&iControlSender,&iSocketHandler);
     ControlReceiver iControlReceiver(&iDatabaseHandler,&iRoutingSender,&iCommandSender,&iSocketHandler, &iRouter);
+#endif /*WITH_DBUS_WRAPPER*/
+
 #ifdef WITH_TELNET
-    TelnetServer iTelnetServer(&iSocketHandler,telnetport,maxConnections);
-    DatabaseObserver iObserver(&iCommandSender, &iRoutingSender, &iSocketHandler, &iTelnetServer);
+    CAmTelnetServer iTelnetServer(&iSocketHandler, &iCommandSender, &iCommandReceiver, &iRoutingSender, &iRoutingReceiver, &iControlSender, &iControlReceiver, &iDatabaseHandler, &iRouter, telnetport, maxConnections);
+    CAmDatabaseObserver iObserver(&iCommandSender, &iRoutingSender, &iSocketHandler, &iTelnetServer);
 #else /*WITH_TELNET*/
-    DatabaseObserver iObserver(&iCommandSender, &iSocketHandler, &iRoutingSender);
+    CAmDatabaseObserver iObserver(&iCommandSender,&iRoutingSender, &iSocketHandler);
 #endif
-#endif /*WITH_DBUS_WRAPPER*/
+
 
     iDatabaseHandler.registerObserver(&iObserver);