logging beautifying

Signed-off-by: Christian as GENIVI Maintainer <genivi-maint-audiomanager@genivi.org>

6 files changed, 281 insertions, 270 deletions

diff --git a/AudioManagerCore/src/CAmCommandReceiver.cpp b/AudioManagerCore/src/CAmCommandReceiver.cpp
index d903384..0c6338a 100644
--- a/AudioManagerCore/src/CAmCommandReceiver.cpp
+++ b/AudioManagerCore/src/CAmCommandReceiver.cpp
@@ -29,6 +29,8 @@
 #include "CAmDltWrapper.h"
 #include "CAmSocketHandler.h"
 
+#define __METHOD_NAME__ std::string (std::string("CAmCommandReceiver::") + __func__)
+
 namespace am
 {
 
@@ -76,49 +78,49 @@ CAmCommandReceiver::~CAmCommandReceiver()
 
 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);
+    logInfo(__METHOD_NAME__,"sourceID=", sourceID, "sinkID=", sinkID);
     return (mControlSender->hookUserConnectionRequest(sourceID, sinkID, mainConnectionID));
 }
 
 am_Error_e CAmCommandReceiver::disconnect(const am_mainConnectionID_t mainConnectionID)
 {
-    logInfo("CommandReceiver::disconnect got called, mainConnectionID=", mainConnectionID);
+    logInfo(__METHOD_NAME__,"mainConnectionID=", mainConnectionID);
     return (mControlSender->hookUserDisconnectionRequest(mainConnectionID));
 }
 
 am_Error_e CAmCommandReceiver::setVolume(const am_sinkID_t sinkID, const am_mainVolume_t volume)
 {
-    logInfo("CommandReceiver::setVolume got called, sinkID=", sinkID, "volume=", volume);
+    logInfo(__METHOD_NAME__,"sinkID=", sinkID, "volume=", volume);
     return (mControlSender->hookUserVolumeChange(sinkID, volume));
 }
 
 am_Error_e CAmCommandReceiver::volumeStep(const am_sinkID_t sinkID, const int16_t volumeStep)
 {
-    logInfo("CommandReceiver::volumeStep got called, sinkID=", sinkID, "volumeStep=", volumeStep);
+    logInfo(__METHOD_NAME__,"sinkID=", sinkID, "volumeStep=", volumeStep);
     return (mControlSender->hookUserVolumeStep(sinkID, volumeStep));
 }
 
 am_Error_e CAmCommandReceiver::setSinkMuteState(const am_sinkID_t sinkID, const am_MuteState_e muteState)
 {
-    logInfo("CommandReceiver::setSinkMuteState got called, sinkID=", sinkID, "muteState=", muteState);
+    logInfo(__METHOD_NAME__,"sinkID=", sinkID, "muteState=", muteState);
     return (mControlSender->hookUserSetSinkMuteState(sinkID, muteState));
 }
 
 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);
+    logInfo(__METHOD_NAME__,"sinkID=", sinkID, "soundPropertyType=", soundProperty.type, "soundPropertyValue=", soundProperty.value);
     return (mControlSender->hookUserSetMainSinkSoundProperty(sinkID, soundProperty));
 }
 
 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);
+    logInfo(__METHOD_NAME__,"sourceID=", sourceID, "soundPropertyType=", soundProperty.type, "soundPropertyValue=", soundProperty.value);
     return (mControlSender->hookUserSetMainSourceSoundProperty(sourceID, soundProperty));
 }
 
 am_Error_e CAmCommandReceiver::setSystemProperty(const am_SystemProperty_s & property)
 {
-    logInfo("CommandReceiver::setSystemProperty got called", "type=", property.type, "soundPropertyValue=", property.value);
+    logInfo(__METHOD_NAME__,"type=", property.type, "soundPropertyValue=", property.value);
     return (mControlSender->hookUserSetSystemProperty(property));
 }
 
@@ -130,7 +132,6 @@ am_Error_e CAmCommandReceiver::getVolume(const am_sinkID_t sinkID, am_mainVolume
 am_Error_e CAmCommandReceiver::getListMainConnections(std::vector<am_MainConnectionType_s> & listConnections) const
 {
     return (mDatabaseHandler->getListVisibleMainConnections(listConnections));
-
 }
 
 am_Error_e CAmCommandReceiver::getListMainSinks(std::vector<am_SinkType_s>& listMainSinks) const
@@ -245,13 +246,13 @@ am_Error_e CAmCommandReceiver::getListMainSourceNotificationConfigurations(const
 
 am_Error_e CAmCommandReceiver::setMainSinkNotificationConfiguration(const am_sinkID_t sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration)
 {
-    logInfo("CommandReceiver::setMainSinkNotificationConfiguration got called, sinkID=", sinkID, " type=",mainNotificationConfiguration.type, " parameter=", mainNotificationConfiguration.parameter, "status=",mainNotificationConfiguration.status);
+    logInfo(__METHOD_NAME__,"sinkID=", sinkID, " type=",mainNotificationConfiguration.type, " parameter=", mainNotificationConfiguration.parameter, "status=",mainNotificationConfiguration.status);
     return (mControlSender->hookUserSetMainSinkNotificationConfiguration(sinkID,mainNotificationConfiguration));
 }
 
 am_Error_e CAmCommandReceiver::setMainSourceNotificationConfiguration(const am_sourceID_t sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration)
 {
-    logInfo("CommandReceiver::setMainSourceNotificationConfiguration got called, sourceID=", sourceID, " type=",mainNotificationConfiguration.type, " parameter=", mainNotificationConfiguration.parameter, "status=",mainNotificationConfiguration.status);
+    logInfo(__METHOD_NAME__,"sourceID=", sourceID, " type=",mainNotificationConfiguration.type, " parameter=", mainNotificationConfiguration.parameter, "status=",mainNotificationConfiguration.status);
     return (mControlSender->hookUserSetMainSourceNotificationConfiguration(sourceID,mainNotificationConfiguration));
 }
 
diff --git a/AudioManagerCore/src/CAmCommandSender.cpp b/AudioManagerCore/src/CAmCommandSender.cpp
index da064cc..2e60109 100644
--- a/AudioManagerCore/src/CAmCommandSender.cpp
+++ b/AudioManagerCore/src/CAmCommandSender.cpp
@@ -35,6 +35,8 @@
 #include "CAmDltWrapper.h"
 #include "audiomanagerconfig.h"
 
+#define __METHOD_NAME__ std::string (std::string("CAmCommandSender::") + __func__)
+
 namespace am
 {
 
@@ -57,7 +59,7 @@ CAmCommandSender::CAmCommandSender(const std::vector<std::string>& listOfPluginD
 {
     if (listOfPluginDirectories.empty())
     {
-        logError("CAmCommandSender::CAmCommandSender: List of commandplugins is empty");
+        logError(__METHOD_NAME__,"List of commandplugins is empty");
     }
 
     std::vector<std::string> sharedLibraryNameList;
@@ -68,12 +70,12 @@ CAmCommandSender::CAmCommandSender(const std::vector<std::string>& listOfPluginD
     for (; dirIter < dirIterEnd; ++dirIter)
     {
         const char* directoryName = dirIter->c_str();
-        logInfo("Searching for CommandPlugins in", *dirIter);
+        logInfo(__METHOD_NAME__,"Searching for CommandPlugins in", *dirIter);
         DIR *directory = opendir(directoryName);
 
         if (!directory)
         {
-            logError("Error opening directory ", *dirIter);
+            logError(__METHOD_NAME__,"Error opening directory ", *dirIter);
             continue;
         }
 
@@ -93,7 +95,7 @@ CAmCommandSender::CAmCommandSender(const std::vector<std::string>& listOfPluginD
 	            struct stat buf;
 
 	            if (stat(fullName.c_str(), &buf)) {
-	                logInfo(__PRETTY_FUNCTION__,"Failed to stat file: ", entryName, errno);
+	                logInfo(__METHOD_NAME__,"Failed to stat file: ", entryName, errno);
 	                continue;
 	            }
 
@@ -115,14 +117,14 @@ CAmCommandSender::CAmCommandSender(const std::vector<std::string>& listOfPluginD
 
     for (; iter < iterEnd; ++iter)
     {
-        logInfo("Loading CommandSender plugin", *iter);
+        logInfo(__METHOD_NAME__,"Loading CommandSender plugin", *iter);
         IAmCommandSend* (*createFunc)();
         void* tempLibHandle = NULL;
         createFunc = getCreateFunction<IAmCommandSend*()>(*iter, tempLibHandle);
 
         if (!createFunc)
         {
-            logInfo("Entry point of CommandPlugin not found", *iter);
+            logInfo(__METHOD_NAME__,"Entry point of CommandPlugin not found", *iter);
             continue;
         }
 
@@ -130,7 +132,7 @@ CAmCommandSender::CAmCommandSender(const std::vector<std::string>& listOfPluginD
 
         if (!commander)
         {
-            logInfo("CommandPlugin initialization failed. Entry Function not callable");
+            logInfo(__METHOD_NAME__,"CommandPlugin initialization failed. Entry Function not callable");
             dlclose(tempLibHandle);
             continue;
         }
@@ -148,7 +150,7 @@ CAmCommandSender::CAmCommandSender(const std::vector<std::string>& listOfPluginD
 
         if (majorVersion < cMajorVersion || ((majorVersion == cMajorVersion) && (minorVersion > cMinorVersion)))
         {
-            logError("CommandInterface initialization failed. Version of Interface to old");
+            logError(__METHOD_NAME__,"CommandInterface initialization failed. Version of Interface to old");
             dlclose(tempLibHandle);
             continue;
         }
diff --git a/AudioManagerCore/src/CAmControlReceiver.cpp b/AudioManagerCore/src/CAmControlReceiver.cpp
index 44ccb96..b1738e0 100644
--- a/AudioManagerCore/src/CAmControlReceiver.cpp
+++ b/AudioManagerCore/src/CAmControlReceiver.cpp
@@ -35,6 +35,8 @@
 
 namespace am {
 
+#define __METHOD_NAME__ std::string (std::string("CAmControlReceiver::") + __func__)
+
 CAmControlReceiver::CAmControlReceiver(IAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmCommandSender *iCommandSender, CAmSocketHandler *iSocketHandler, CAmRouter* iRouter) :
         mDatabaseHandler(iDatabaseHandler), //
         mRoutingSender(iRoutingSender), //
@@ -402,32 +404,32 @@ am_Error_e CAmControlReceiver::removeSourceClassDB(const am_sourceClass_t source
 
 void CAmControlReceiver::setCommandReady()
 {
-    logInfo("CAmControlReceiver::setCommandReady got called");
+    logVerbose(__METHOD_NAME__);
     mCommandSender->setCommandReady();
 }
 
 void CAmControlReceiver::setRoutingReady()
 {
-    logInfo("CAmControlReceiver::setRoutingReady got called");
+	logVerbose(__METHOD_NAME__);
     mRoutingSender->setRoutingReady();
 }
 
 void CAmControlReceiver::confirmControllerReady(const am_Error_e error)
 {
 	if (error!=E_OK)
-		logError("CAmControlReceiver::confirmControllerReady controller reported error", error);
+		logError(__METHOD_NAME__,"controller reported error", error);
 }
 
 void CAmControlReceiver::confirmControllerRundown(const am_Error_e error)
 {
 	if (error!=E_OK)
 	{
-		logError("CAmControlReceiver::confirmControllerRundown() exited with error ",error);
+		logError(__METHOD_NAME__,"exited with error ",error);
 		//we might be blocked here -> so lets better exit right away
 		throw std::runtime_error("controller Confirmed with error");
 	}
 
-	logInfo ("CAmControlReceiver::confirmControllerRundown(), will exit now");
+	logVerbose (__METHOD_NAME__,"will exit now");
 
 	//end the mainloop here...
 	mSocketHandler->exit_mainloop();
@@ -441,13 +443,13 @@ am_Error_e CAmControlReceiver::getSocketHandler(CAmSocketHandler *& socketHandle
 
 void CAmControlReceiver::setCommandRundown()
 {
-    logInfo("CAmControlReceiver::setCommandRundown got called");
+	logInfo(__METHOD_NAME__);
     mCommandSender->setCommandRundown();
 }
 
 void CAmControlReceiver::setRoutingRundown()
 {
-    logInfo("CAmControlReceiver::setRoutingRundown got called");
+    logInfo(__METHOD_NAME__);
     mRoutingSender->setRoutingRundown();
 }
 
@@ -493,85 +495,85 @@ am_Error_e CAmControlReceiver::setSourceNotificationConfiguration(am_Handle_s& h
 
 void CAmControlReceiver::sendMainSinkNotificationPayload(const am_sinkID_t sinkID, const am_NotificationPayload_s& notificationPayload)
 {
-    logInfo(__func__,"sinkID=",sinkID,"type=",notificationPayload.type,"value=",notificationPayload.value);
+	logVerbose(__METHOD_NAME__,"sinkID=",sinkID,"type=",notificationPayload.type,"value=",notificationPayload.value);
     mCommandSender->cbSinkNotification(sinkID,notificationPayload);
 }
 
 void CAmControlReceiver::sendMainSourceNotificationPayload(const am_sourceID_t sourceID, const am_NotificationPayload_s& notificationPayload)
 {
-    logInfo(__func__,"sourceID=",sourceID,"type=",notificationPayload.type,"value=",notificationPayload.value);
+	logVerbose(__METHOD_NAME__,"sourceID=",sourceID,"type=",notificationPayload.type,"value=",notificationPayload.value);
     mCommandSender->cbSourceNotification(sourceID,notificationPayload);
 }
 
 am_Error_e CAmControlReceiver::changeMainSinkNotificationConfigurationDB(const am_sinkID_t sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration)
 {
-    logVerbose(__func__,"sinkID", sinkID);
+    logVerbose(__METHOD_NAME__,"sinkID", sinkID);
     return (mDatabaseHandler->changeMainSinkNotificationConfigurationDB(sinkID,mainNotificationConfiguration));
 }
 
 am_Error_e CAmControlReceiver::changeMainSourceNotificationConfigurationDB(const am_sourceID_t sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration)
 {
-    logVerbose(__func__,"sourceID", sourceID);
+    logVerbose(__METHOD_NAME__,"sourceID", sourceID);
     return (mDatabaseHandler->changeMainSourceNotificationConfigurationDB(sourceID,mainNotificationConfiguration));
 }
 
 am_Error_e CAmControlReceiver::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_MainSoundProperty_s>& listSoundproperties) const
 {
-	logVerbose(__func__,"sinkID", sinkID);
+	logVerbose(__METHOD_NAME__,"sinkID", sinkID);
 	return (mDatabaseHandler->getListMainSinkSoundProperties(sinkID,listSoundproperties));
 }
 
 am_Error_e CAmControlReceiver::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_MainSoundProperty_s>& listSoundproperties) const
 {
-	 logVerbose(__func__,"sourceID", sourceID);
+	 logVerbose(__METHOD_NAME__,"sourceID", sourceID);
 	 return (mDatabaseHandler->getListMainSourceSoundProperties(sourceID, listSoundproperties));
 }
 
 am_Error_e CAmControlReceiver::getListSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_SoundProperty_s>& listSoundproperties) const
 {
-	logVerbose(__func__,"sinkID", sinkID);
+	logVerbose(__METHOD_NAME__,"sinkID", sinkID);
 	return (mDatabaseHandler->getListSinkSoundProperties(sinkID,listSoundproperties));
 }
 
 am_Error_e CAmControlReceiver::getListSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_SoundProperty_s>& listSoundproperties) const
 {
-	 logVerbose(__func__,"sourceID", sourceID);
+	 logVerbose(__METHOD_NAME__,"sourceID", sourceID);
 	 return (mDatabaseHandler->getListSourceSoundProperties(sourceID, listSoundproperties));
 }
 
 am_Error_e CAmControlReceiver::getMainSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomMainSoundPropertyType_t propertyType, int16_t& value) const
 {
-	logVerbose(__func__,"sinkID", sinkID);
+	logVerbose(__METHOD_NAME__,"sinkID", sinkID);
 	return (mDatabaseHandler->getMainSinkSoundPropertyValue(sinkID,propertyType,value));
 }
 
 am_Error_e CAmControlReceiver::getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomSoundPropertyType_t propertyType, int16_t& value) const
 {
-	logVerbose(__func__,"sinkID", sinkID);
+	logVerbose(__METHOD_NAME__,"sinkID", sinkID);
 	return (mDatabaseHandler->getSinkSoundPropertyValue(sinkID,propertyType,value));
 }
 
 am_Error_e CAmControlReceiver::getMainSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomMainSoundPropertyType_t propertyType, int16_t& value) const
 {
-	logVerbose(__func__,"sourceID", sourceID);
+	logVerbose(__METHOD_NAME__,"sourceID", sourceID);
 	return (mDatabaseHandler->getMainSourceSoundPropertyValue(sourceID,propertyType,value));
 }
 
 am_Error_e CAmControlReceiver::getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomSoundPropertyType_t propertyType, int16_t& value) const
 {
-	 logVerbose(__func__,"sourceID", sourceID);
+	 logVerbose(__METHOD_NAME__,"sourceID", sourceID);
 	 return (mDatabaseHandler->getSourceSoundPropertyValue(sourceID,propertyType,value));
 }
 
 am_Error_e CAmControlReceiver::resyncConnectionState(const am_domainID_t domainID,std::vector<am_Connection_s>& listOfExistingConnections)
 {
-	logInfo(__func__,"domainID", domainID);
+	logInfo(__METHOD_NAME__,"domainID", domainID);
 	return (mRoutingSender->resyncConnectionState(domainID,listOfExistingConnections));
 }
 
 am_Error_e CAmControlReceiver::removeHandle(const am_Handle_s handle)
 {
-	logInfo(__func__,"handle", handle.handle);
+	logInfo(__METHOD_NAME__,"handle", handle.handle);
 	return (mRoutingSender->removeHandle(handle));
 }
 
diff --git a/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp b/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp
index 187d165..0965a1d 100644
--- a/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp
+++ b/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp
@@ -34,6 +34,8 @@
 #include "CAmRouter.h"
 #include "CAmDltWrapper.h"
 
+#define __METHOD_NAME__ std::string (std::string("CAmDatabaseHandlerMap::") + __func__)
+
 
 #ifdef WITH_DATABASE_CHANGE_CHECK
 #	define DB_COND_UPDATE_RIE(x,y) \
@@ -413,12 +415,12 @@ CAmDatabaseHandlerMap::CAmDatabaseHandlerMap():	mFirstStaticSink(true), //
 														mListConnectionFormat(), //
 														mMappedData()
 {
-	logVerbose(__func__,"Init ");
+	logVerbose(__METHOD_NAME__,"Init ");
 }
 
 CAmDatabaseHandlerMap::~CAmDatabaseHandlerMap()
 {
-    logVerbose(__func__,"Destroy");
+    logVerbose(__METHOD_NAME__,"Destroy");
     mpDatabaseObserver = NULL;
 }
 
@@ -426,17 +428,17 @@ am_Error_e CAmDatabaseHandlerMap::enterDomainDB(const am_Domain_s & domainData,
 {
     if(domainData.name.empty())
     {
-    	logError(__func__,"DomainName must not be emtpy!");
+    	logError(__METHOD_NAME__,"DomainName must not be emtpy!");
     	return (E_NOT_POSSIBLE);
     }
     if(domainData.busname.empty())
     {
-    	logError(__func__,"Busname must not be emtpy!");
+    	logError(__METHOD_NAME__,"Busname must not be emtpy!");
     	return (E_NOT_POSSIBLE);
     }
     if(!(domainData.state>=DS_UNKNOWN && domainData.state<=DS_MAX))
     {
-    	logError(__func__,"State must not be valid!");
+    	logError(__METHOD_NAME__,"State must not be valid!");
     	return (E_NOT_POSSIBLE);
     }
     //first check for a reserved domain
@@ -473,7 +475,7 @@ am_Error_e CAmDatabaseHandlerMap::enterDomainDB(const am_Domain_s & domainData,
 		else
 		{
 			domainID = 0;
-			logVerbose(__func__,"Max limit reached.");
+			logVerbose(__METHOD_NAME__,"Max limit reached.");
 			return (E_UNKNOWN);
 		}
     }
@@ -503,22 +505,22 @@ am_Error_e CAmDatabaseHandlerMap::enterMainConnectionDB(const am_MainConnection_
 {
     if(mainConnectionData.mainConnectionID!=0)
     {
-    	logError(__func__,"mainConnectionID must be 0!");
+    	logError(__METHOD_NAME__,"mainConnectionID must be 0!");
     	return (E_NOT_POSSIBLE);
     }
     if(!(mainConnectionData.connectionState>=CS_UNKNOWN && mainConnectionData.connectionState<=CS_MAX))
     {
-    	logError(__func__,"connectionState must be valid!");
+    	logError(__METHOD_NAME__,"connectionState must be valid!");
     	return (E_NOT_POSSIBLE);
     }
     if(!existSink(mainConnectionData.sinkID))
     {
-    	logError(__func__,"sinkID must be valid!");
+    	logError(__METHOD_NAME__,"sinkID must be valid!");
     	return (E_NOT_POSSIBLE);
     }
     if(!existSource(mainConnectionData.sourceID))
     {
-    	logError(__func__,"sourceID must be valid!");
+    	logError(__METHOD_NAME__,"sourceID must be valid!");
     	return (E_NOT_POSSIBLE);
     }
 
@@ -533,7 +535,7 @@ am_Error_e CAmDatabaseHandlerMap::enterMainConnectionDB(const am_MainConnection_
 	else
 	{
 		connectionID = 0;
-		logVerbose(__func__,"Max limit reached.");
+		logVerbose(__METHOD_NAME__,"Max limit reached.");
 		return (E_UNKNOWN);
 	}
 
@@ -576,7 +578,7 @@ bool CAmDatabaseHandlerMap::insertSinkDB(const am_Sink_s & sinkData, am_sinkID_t
 	else
 	{
 		sinkID = 0;
-		logVerbose(__func__,"Max limit reached!");
+		logVerbose(__METHOD_NAME__,"Max limit reached!");
 		return (false);
 	}
 }
@@ -585,28 +587,28 @@ am_Error_e CAmDatabaseHandlerMap::enterSinkDB(const am_Sink_s & sinkData, am_sin
 {
     if(sinkData.sinkID>DYNAMIC_ID_BOUNDARY)
     {
-    	logError(__func__,"sinkID must be below:",DYNAMIC_ID_BOUNDARY);
+    	logError(__METHOD_NAME__,"sinkID must be below:",DYNAMIC_ID_BOUNDARY);
     	return (E_NOT_POSSIBLE);
     }
     if(!existDomain(sinkData.domainID))
     {
-    	logError(__func__,"domainID must be valid");
+    	logError(__METHOD_NAME__,"domainID must be valid");
     	return (E_NOT_POSSIBLE);
     }
     if(sinkData.name.empty())
     {
-    	logError(__func__,"sinkName must not be zero");
+    	logError(__METHOD_NAME__,"sinkName must not be zero");
     	return (E_NOT_POSSIBLE);
     }
     if(!existSinkClass(sinkData.sinkClassID))
     {
-    	logError(__func__,"sinkClass must be valid");
+    	logError(__METHOD_NAME__,"sinkClass must be valid");
     	return (E_NOT_POSSIBLE);
     }
 
     if(!(sinkData.muteState>=MS_UNKNOWN && sinkData.muteState<=MS_MAX))
     {
-    	logError(__func__,"muteState must be valid");
+    	logError(__METHOD_NAME__,"muteState must be valid");
     	return (E_NOT_POSSIBLE);
     }
 
@@ -673,7 +675,7 @@ bool CAmDatabaseHandlerMap::insertCrossfaderDB(const am_Crossfader_s & crossfade
 	else
 	{
 		crossfaderID = 0;
-		logVerbose(__func__,"Max limit reached.");
+		logVerbose(__METHOD_NAME__,"Max limit reached.");
 		return (false);
 	}
 }
@@ -682,34 +684,34 @@ am_Error_e CAmDatabaseHandlerMap::enterCrossfaderDB(const am_Crossfader_s & cros
 {
     if(crossfaderData.crossfaderID>DYNAMIC_ID_BOUNDARY)
     {
-    	logError(__func__,"crossfaderID must be below:",DYNAMIC_ID_BOUNDARY);
+    	logError(__METHOD_NAME__,"crossfaderID must be below:",DYNAMIC_ID_BOUNDARY);
     	return (E_NOT_POSSIBLE);
     }
 
     if(!(crossfaderData.hotSink>=HS_UNKNOWN && crossfaderData.hotSink<=HS_MAX))
     {
-    	logError(__func__,"hotSink must be valid");
+    	logError(__METHOD_NAME__,"hotSink must be valid");
     	return (E_NOT_POSSIBLE);
     }
     if(crossfaderData.name.empty())
     {
-    	logError(__func__,"crossfaderName must not be zero");
+    	logError(__METHOD_NAME__,"crossfaderName must not be zero");
     	return (E_NOT_POSSIBLE);
     }
 
     if(!existSink(crossfaderData.sinkID_A))
     {
-    	logError(__func__,"sinkID_A must exist");
+    	logError(__METHOD_NAME__,"sinkID_A must exist");
     	return (E_NOT_POSSIBLE);
     }
     if(!existSink(crossfaderData.sinkID_B))
     {
-    	logError(__func__,"sinkID_B must exist");
+    	logError(__METHOD_NAME__,"sinkID_B must exist");
     	return (E_NOT_POSSIBLE);
     }
     if(!existSource(crossfaderData.sourceID))
     {
-    	logError(__func__,"sourceID must exist");
+    	logError(__METHOD_NAME__,"sourceID must exist");
     	return (E_NOT_POSSIBLE);
     }
 
@@ -760,7 +762,7 @@ bool CAmDatabaseHandlerMap::insertGatewayDB(const am_Gateway_s & gatewayData, am
 	else
 	{
 		gatewayID = 0;
-		logVerbose(__func__,"Max limit reached.");
+		logVerbose(__METHOD_NAME__,"Max limit reached.");
 		return (false);
 	}
 }
@@ -770,19 +772,19 @@ am_Error_e CAmDatabaseHandlerMap::enterGatewayDB(const am_Gateway_s & gatewayDat
 
     if(gatewayData.gatewayID>DYNAMIC_ID_BOUNDARY)
     {
-    	logError(__func__,"gatewayID must be below:",DYNAMIC_ID_BOUNDARY);
+    	logError(__METHOD_NAME__,"gatewayID must be below:",DYNAMIC_ID_BOUNDARY);
     	return (E_NOT_POSSIBLE);
     }
 
     if(!existDomain(gatewayData.controlDomainID))
     {
-    	logError(__func__,"controlDomainID must be exist");
+    	logError(__METHOD_NAME__,"controlDomainID must be exist");
     	return (E_NOT_POSSIBLE);
     }
 
     if(gatewayData.name.empty())
     {
-    	logError(__func__,"gatewayName must not be empty");
+    	logError(__METHOD_NAME__,"gatewayName must not be empty");
     	return (E_NOT_POSSIBLE);
     }
 
@@ -835,7 +837,7 @@ bool CAmDatabaseHandlerMap::insertConverterDB(const am_Converter_s & converteDat
 	else
 	{
 		converterID = 0;
-		logVerbose(__func__,"Max limit reached.");
+		logVerbose(__METHOD_NAME__,"Max limit reached.");
 		return (false);
 	}
 }
@@ -844,31 +846,31 @@ am_Error_e CAmDatabaseHandlerMap::enterConverterDB(const am_Converter_s & conver
 {
     if(converterData.converterID>DYNAMIC_ID_BOUNDARY)
     {
-    	logError(__func__,"converterID must be below:",DYNAMIC_ID_BOUNDARY);
+    	logError(__METHOD_NAME__,"converterID must be below:",DYNAMIC_ID_BOUNDARY);
     	return (E_NOT_POSSIBLE);
     }
 
     if(!existSink(converterData.sinkID))
     {
-    	logError(__func__,"sinkID must exists");
+    	logError(__METHOD_NAME__,"sinkID must exists");
     	return (E_NOT_POSSIBLE);
     }
 
     if(!existSource(converterData.sourceID))
     {
-    	logError(__func__,"sourceID must exists");
+    	logError(__METHOD_NAME__,"sourceID must exists");
     	return (E_NOT_POSSIBLE);
     }
 
     if(!existDomain(converterData.domainID))
     {
-    	logError(__func__,"domainID must exists");
+    	logError(__METHOD_NAME__,"domainID must exists");
     	return (E_NOT_POSSIBLE);
     }
 
     if(converterData.name.empty())
     {
-    	logError(__func__,"converterName must not be empty");
+    	logError(__METHOD_NAME__,"converterName must not be empty");
     	return (E_NOT_POSSIBLE);
     }
 
@@ -942,7 +944,7 @@ bool CAmDatabaseHandlerMap::insertSourceDB(const am_Source_s & sourceData, am_so
 	else
 	{
 		sourceID = 0;
-		logVerbose(__func__,"Max limit reached.");
+		logVerbose(__METHOD_NAME__,"Max limit reached.");
 		return (false);
 	}
 }
@@ -951,28 +953,28 @@ am_Error_e CAmDatabaseHandlerMap::enterSourceDB(const am_Source_s & sourceData,
 {
     if(sourceData.sourceID>DYNAMIC_ID_BOUNDARY)
     {
-    	logError(__func__,"sourceID must be below:",DYNAMIC_ID_BOUNDARY);
+    	logError(__METHOD_NAME__,"sourceID must be below:",DYNAMIC_ID_BOUNDARY);
     	return (E_NOT_POSSIBLE);
     }
     if(!existDomain(sourceData.domainID))
     {
-    	logError(__func__,"domainID must be valid");
+    	logError(__METHOD_NAME__,"domainID must be valid");
     	return (E_NOT_POSSIBLE);
     }
     if(sourceData.name.empty())
     {
-    	logError(__func__,"sourceName must not be zero");
+    	logError(__METHOD_NAME__,"sourceName must not be zero");
     	return (E_NOT_POSSIBLE);
     }
     if(!existSourceClass(sourceData.sourceClassID))
     {
-    	logError(__func__,"sourceClassID must be valid");
+    	logError(__METHOD_NAME__,"sourceClassID must be valid");
     	return (E_NOT_POSSIBLE);
     }
 
     if(!(sourceData.sourceState>=SS_UNKNNOWN && sourceData.sourceState<=SS_MAX))
     {
-    	logError(__func__,"sourceState must be valid");
+    	logError(__METHOD_NAME__,"sourceState must be valid");
     	return (E_NOT_POSSIBLE);
     }
 
@@ -1027,19 +1029,19 @@ am_Error_e CAmDatabaseHandlerMap::enterConnectionDB(const am_Connection_s& conne
 {
     if(connection.connectionID!=0)
     {
-    	logError(__func__,"connectionID must be 0!");
+    	logError(__METHOD_NAME__,"connectionID must be 0!");
     	return (E_NOT_POSSIBLE);
     }
 
     if(!existSink(connection.sinkID))
     {
-    	logError(__func__,"sinkID must exist!");
+    	logError(__METHOD_NAME__,"sinkID must exist!");
     	return (E_NOT_POSSIBLE);
     }
 
     if(!existSource(connection.sourceID))
     {
-    	logError(__func__,"sourceID must exist!");
+    	logError(__METHOD_NAME__,"sourceID must exist!");
     	return (E_NOT_POSSIBLE);
     }
     //connection format is not checked, because it's project specific
@@ -1054,7 +1056,7 @@ am_Error_e CAmDatabaseHandlerMap::enterConnectionDB(const am_Connection_s& conne
 	else
 	{
 		connectionID = 0;
-		logVerbose(__func__,"Max limit reached.");
+		logVerbose(__METHOD_NAME__,"Max limit reached.");
 		return (E_UNKNOWN);
 	}
 
@@ -1075,7 +1077,7 @@ bool CAmDatabaseHandlerMap::insertSinkClassDB(const am_SinkClass_s & sinkClass,
 	else
 	{
 		sinkClassID = 0;
-		logVerbose(__func__,"Max limit reached.");
+		logVerbose(__METHOD_NAME__,"Max limit reached.");
 		return (false);
 	}
 }
@@ -1084,13 +1086,13 @@ am_Error_e CAmDatabaseHandlerMap::enterSinkClassDB(const am_SinkClass_s & sinkCl
 {
     if(sinkClass.sinkClassID>DYNAMIC_ID_BOUNDARY)
     {
-    	logError(__func__,"sinkClassID must be <",DYNAMIC_ID_BOUNDARY);
+    	logError(__METHOD_NAME__,"sinkClassID must be <",DYNAMIC_ID_BOUNDARY);
     	return (E_NOT_POSSIBLE);
     }
 
     if(sinkClass.name.empty())
     {
-    	logError(__func__,"name must not be empty");
+    	logError(__METHOD_NAME__,"name must not be empty");
     	return (E_NOT_POSSIBLE);
     }
 
@@ -1140,7 +1142,7 @@ bool CAmDatabaseHandlerMap::insertSourceClassDB(am_sourceClass_t & sourceClassID
 	else
 	{
 		sourceClassID = 0;
-		logVerbose(__func__,"Max limit reached.");
+		logVerbose(__METHOD_NAME__,"Max limit reached.");
 		return (false);
 	}
 }
@@ -1149,13 +1151,13 @@ am_Error_e CAmDatabaseHandlerMap::enterSourceClassDB(am_sourceClass_t & sourceCl
 {
     if(sourceClass.sourceClassID>DYNAMIC_ID_BOUNDARY)
     {
-    	logError(__func__,"sourceClassID must be <",DYNAMIC_ID_BOUNDARY);
+    	logError(__METHOD_NAME__,"sourceClassID must be <",DYNAMIC_ID_BOUNDARY);
     	return (E_NOT_POSSIBLE);
     }
 
     if(sourceClass.name.empty())
     {
-    	logError(__func__,"name must not be empty");
+    	logError(__METHOD_NAME__,"name must not be empty");
     	return (E_NOT_POSSIBLE);
     }
 
@@ -1199,7 +1201,7 @@ am_Error_e CAmDatabaseHandlerMap::enterSystemProperties(const std::vector<am_Sys
 {
     if(listSystemProperties.empty())
 	{
-    	logError(__func__,"listSystemProperties must not be empty");
+    	logError(__METHOD_NAME__,"listSystemProperties must not be empty");
     	return (E_NOT_POSSIBLE);
 	}
 
@@ -1213,13 +1215,13 @@ am_Error_e CAmDatabaseHandlerMap::changeMainConnectionRouteDB(const am_mainConne
 {
     if(mainconnectionID==0)
     {
-    	logError(__func__,"mainconnectionID must not be 0");
+    	logError(__METHOD_NAME__,"mainconnectionID must not be 0");
     	return (E_NOT_POSSIBLE);
     }
 
     if (!existMainConnection(mainconnectionID))
     {
-    	logError(__func__,"existMainConnection must exist");
+    	logError(__METHOD_NAME__,"existMainConnection must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1239,19 +1241,19 @@ am_Error_e CAmDatabaseHandlerMap::changeMainConnectionStateDB(const am_mainConne
 {
     if(mainconnectionID==0)
     {
-    	logError(__func__,"mainconnectionID must not be 0");
+    	logError(__METHOD_NAME__,"mainconnectionID must not be 0");
     	return (E_NOT_POSSIBLE);
     }
 
     if(!(connectionState>=CS_UNKNOWN && connectionState<=CS_MAX))
     {
-    	logError(__func__,"connectionState must be valid");
+    	logError(__METHOD_NAME__,"connectionState must be valid");
     	return (E_NOT_POSSIBLE);
     }
 
     if (!existMainConnection(mainconnectionID))
     {
-    	logError(__func__,"existMainConnection must exist");
+    	logError(__METHOD_NAME__,"existMainConnection must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1267,7 +1269,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkMainVolumeDB(const am_mainVolume_t m
 {
     if (!existSink(sinkID))
     {
-    	logError(__func__,"sinkID must exist");
+    	logError(__METHOD_NAME__,"sinkID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1285,13 +1287,13 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkAvailabilityDB(const am_Availability
 {
     if (!(availability.availability>=A_UNKNOWN && availability.availability<=A_MAX))
     {
-    	logError(__func__,"availability must be valid");
+    	logError(__METHOD_NAME__,"availability must be valid");
     	return (E_NOT_POSSIBLE);
     }
 
     if (!existSink(sinkID))
     {
-    	logError(__func__,"sinkID must exist");
+    	logError(__METHOD_NAME__,"sinkID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1309,13 +1311,13 @@ am_Error_e CAmDatabaseHandlerMap::changeDomainStateDB(const am_DomainState_e dom
 
     if(!(domainState>=DS_UNKNOWN && domainState<=DS_MAX))
     {
-    	logError(__func__,"domainState must be valid");
+    	logError(__METHOD_NAME__,"domainState must be valid");
     	return (E_NOT_POSSIBLE);
     }
 
     if (!existDomain(domainID))
     {
-    	logError(__func__,"domainID must exist");
+    	logError(__METHOD_NAME__,"domainID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1330,13 +1332,13 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkMuteStateDB(const am_MuteState_e mut
 
     if(!(muteState>=MS_UNKNOWN && muteState<=MS_MAX))
     {
-    	logError(__func__,"muteState must be valid");
+    	logError(__METHOD_NAME__,"muteState must be valid");
     	return (E_NOT_POSSIBLE);
     }
 
     if (!existSink(sinkID))
     {
-    	logError(__func__,"sinkID must exist");
+    	logError(__METHOD_NAME__,"sinkID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1355,7 +1357,7 @@ am_Error_e CAmDatabaseHandlerMap::changeMainSinkSoundPropertyDB(const am_MainSou
 
     if (!existSink(sinkID))
     {
-    	logError(__func__,"sinkID must exist");
+    	logError(__METHOD_NAME__,"sinkID must exist");
         return (E_NON_EXISTENT);
     }
     am_Sink_Database_s & sink = mMappedData.mSinkMap[sinkID];
@@ -1382,7 +1384,7 @@ am_Error_e CAmDatabaseHandlerMap::changeMainSourceSoundPropertyDB(const am_MainS
 
     if (!existSource(sourceID))
     {
-    	logError(__func__,"sourceID must exist");
+    	logError(__METHOD_NAME__,"sourceID must exist");
         return (E_NON_EXISTENT);
     }
     am_Source_Database_s & source = mMappedData.mSourceMap.at(sourceID);
@@ -1409,13 +1411,13 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceAvailabilityDB(const am_Availabili
 {
     if(!(availability.availability>=A_UNKNOWN && availability.availability<=A_MAX))
     {
-    	logError(__func__,"availability must be valid");
+    	logError(__METHOD_NAME__,"availability must be valid");
     	return (E_NOT_POSSIBLE);
     }
 
     if (!existSource(sourceID))
     {
-    	logError(__func__,"sourceID must exist");
+    	logError(__METHOD_NAME__,"sourceID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1450,7 +1452,7 @@ am_Error_e CAmDatabaseHandlerMap::removeMainConnectionDB(const am_mainConnection
 
     if (!existMainConnection(mainConnectionID))
     {
-    	logError(__func__,"mainConnectionID must exist");
+    	logError(__METHOD_NAME__,"mainConnectionID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1470,7 +1472,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSinkDB(const am_sinkID_t sinkID)
 
     if (!existSink(sinkID))
     {
-    	logError(__func__,"sinkID must exist");
+    	logError(__METHOD_NAME__,"sinkID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1492,7 +1494,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSourceDB(const am_sourceID_t sourceID)
 
     if (!existSource(sourceID))
     {
-    	logError(__func__,"sourceID must exist");
+    	logError(__METHOD_NAME__,"sourceID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1514,7 +1516,7 @@ am_Error_e CAmDatabaseHandlerMap::removeGatewayDB(const am_gatewayID_t gatewayID
 
     if (!existGateway(gatewayID))
     {
-    	logError(__func__,"gatewayID must exist");
+    	logError(__METHOD_NAME__,"gatewayID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1531,7 +1533,7 @@ am_Error_e CAmDatabaseHandlerMap::removeConverterDB(const am_converterID_t conve
 
     if (!existConverter(converterID))
     {
-    	logError(__func__,"converterID must exist");
+    	logError(__METHOD_NAME__,"converterID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1548,7 +1550,7 @@ am_Error_e CAmDatabaseHandlerMap::removeCrossfaderDB(const am_crossfaderID_t cro
 
     if (!existCrossFader(crossfaderID))
     {
-    	logError(__func__,"crossfaderID must exist");
+    	logError(__METHOD_NAME__,"crossfaderID must exist");
         return (E_NON_EXISTENT);
     }
     mMappedData.mCrossfaderMap.erase(crossfaderID);
@@ -1564,7 +1566,7 @@ am_Error_e CAmDatabaseHandlerMap::removeDomainDB(const am_domainID_t domainID)
 
     if (!existDomain(domainID))
     {
-    	logError(__func__,"domainID must exist");
+    	logError(__METHOD_NAME__,"domainID must exist");
         return (E_NON_EXISTENT);
     }
     mMappedData.mDomainMap.erase(domainID);
@@ -1580,7 +1582,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSinkClassDB(const am_sinkClass_t sinkCla
 
     if (!existSinkClass(sinkClassID))
     {
-    	logError(__func__,"sinkClassID must exist");
+    	logError(__METHOD_NAME__,"sinkClassID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1598,7 +1600,7 @@ am_Error_e CAmDatabaseHandlerMap::removeSourceClassDB(const am_sourceClass_t sou
 
     if (!existSourceClass(sourceClassID))
     {
-    	logError(__func__,"sourceClassID must exist");
+    	logError(__METHOD_NAME__,"sourceClassID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1613,7 +1615,7 @@ am_Error_e CAmDatabaseHandlerMap::removeConnection(const am_connectionID_t conne
 {
     if (!existConnectionID(connectionID))
     {
-    	logError(__func__,"connectionID must exist",connectionID);
+    	logError(__METHOD_NAME__,"connectionID must exist",connectionID);
         return (E_NON_EXISTENT);
     }
 
@@ -1628,7 +1630,7 @@ am_Error_e CAmDatabaseHandlerMap::getSourceClassInfoDB(const am_sourceID_t sourc
 
     if (!existSource(sourceID))
     {
-    	logWarning(__func__,"sourceID must exist");
+    	logWarning(__METHOD_NAME__,"sourceID must exist");
         return (E_NON_EXISTENT);
     }
     am_Source_Database_s source = mMappedData.mSourceMap.at(sourceID);
@@ -1649,7 +1651,7 @@ am_Error_e CAmDatabaseHandlerMap::getSinkInfoDB(const am_sinkID_t sinkID, am_Sin
 
     if (!existSink(sinkID))
     {
-    	logWarning(__func__,"sinkID",sinkID,"does not exist");
+    	logWarning(__METHOD_NAME__,"sinkID",sinkID,"does not exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1666,7 +1668,7 @@ am_Error_e CAmDatabaseHandlerMap::getSourceInfoDB(const am_sourceID_t sourceID,
 
     if (!existSource(sourceID))
     {
-    	logWarning(__func__,"sourceID",sourceID,"does not exist");
+    	logWarning(__METHOD_NAME__,"sourceID",sourceID,"does not exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1683,7 +1685,7 @@ am_Error_e am::CAmDatabaseHandlerMap::getMainConnectionInfoDB(const am_mainConne
 {
     if (!existMainConnection(mainConnectionID))
     {
-    	logError(__func__,"mainConnectionID must exist");
+    	logError(__METHOD_NAME__,"mainConnectionID must exist");
         return (E_NON_EXISTENT);
     }
     am_MainConnection_s temp = mMappedData.mMainConnectionMap.at(mainConnectionID);
@@ -1696,14 +1698,14 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkClassInfoDB(const am_SinkClass_s& si
 {
     if(sinkClass.listClassProperties.empty())
     {
-    	logError(__func__,"listClassProperties must not be empty");
+    	logError(__METHOD_NAME__,"listClassProperties must not be empty");
     	return (E_NOT_POSSIBLE);
     }
 
     //check if the ID already exists
     if (!existSinkClass(sinkClass.sinkClassID))
     {
-    	logError(__func__,"sinkClassID must exist");
+    	logError(__METHOD_NAME__,"sinkClassID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1717,14 +1719,14 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceClassInfoDB(const am_SourceClass_s
 {
     if(sourceClass.listClassProperties.empty())
     {
-		logError(__func__,"listClassProperties must not be empty");
+		logError(__METHOD_NAME__,"listClassProperties must not be empty");
 		return (E_NOT_POSSIBLE);
     }
 
     //check if the ID already exists
     if (!existSourceClass(sourceClass.sourceClassID))
     {
-    	logError(__func__,"sourceClassID must exist");
+    	logError(__METHOD_NAME__,"sourceClassID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1739,7 +1741,7 @@ am_Error_e CAmDatabaseHandlerMap::getSinkClassInfoDB(const am_sinkID_t sinkID, a
 
     if (!existSink(sinkID))
     {
-    	logWarning(__func__,"sinkID must exist");
+    	logWarning(__METHOD_NAME__,"sinkID must exist");
         return (E_NON_EXISTENT);
     }
     am_Sink_Database_s sink = mMappedData.mSinkMap.at(sinkID);
@@ -1747,7 +1749,7 @@ am_Error_e CAmDatabaseHandlerMap::getSinkClassInfoDB(const am_sinkID_t sinkID, a
 
     if (!existSinkClass(sinkClass.sinkClassID))
     {
-    	logWarning(__func__,"sinkClassID must exist");
+    	logWarning(__METHOD_NAME__,"sinkClassID must exist");
         return (E_NON_EXISTENT);
     }
     am_SinkClass_s tmpSinkClass = mMappedData.mSinkClassesMap.at(sinkClass.sinkClassID);
@@ -1760,7 +1762,7 @@ am_Error_e CAmDatabaseHandlerMap::getGatewayInfoDB(const am_gatewayID_t gatewayI
 {
     if (!existGateway(gatewayID))
     {
-    	logWarning(__func__,"gatewayID must exist");
+    	logWarning(__METHOD_NAME__,"gatewayID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1774,7 +1776,7 @@ am_Error_e CAmDatabaseHandlerMap::getConverterInfoDB(const am_converterID_t conv
 {
     if (!existConverter(converterID))
     {
-    	logWarning(__func__,"converterID must exist");
+    	logWarning(__METHOD_NAME__,"converterID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1788,7 +1790,7 @@ am_Error_e CAmDatabaseHandlerMap::getCrossfaderInfoDB(const am_crossfaderID_t cr
 {
     if (!existCrossFader(crossfaderID))
     {
-    	logWarning(__func__,"crossfaderID must exist");
+    	logWarning(__METHOD_NAME__,"crossfaderID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1802,7 +1804,7 @@ am_Error_e CAmDatabaseHandlerMap::getListSinksOfDomain(const am_domainID_t domai
     listSinkID.clear();
     if (!existDomain(domainID))
     {
-    	logWarning(__func__,"domainID must exist");
+    	logWarning(__METHOD_NAME__,"domainID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1820,7 +1822,7 @@ am_Error_e CAmDatabaseHandlerMap::getListSourcesOfDomain(const am_domainID_t dom
     listSourceID.clear();
     if (!existDomain(domainID))
     {
-    	logWarning(__func__,"domainID must exist");
+    	logWarning(__METHOD_NAME__,"domainID must exist");
         return (E_NON_EXISTENT);
     }
      CAmMapSource::const_iterator elementIterator = mMappedData.mSourceMap.begin();
@@ -1838,7 +1840,7 @@ am_Error_e CAmDatabaseHandlerMap::getListCrossfadersOfDomain(const am_domainID_t
     listCrossfader.clear();
     if (!existDomain(domainID))
     {
-    	logWarning(__func__,"domainID must exist");
+    	logWarning(__METHOD_NAME__,"domainID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1865,7 +1867,7 @@ am_Error_e CAmDatabaseHandlerMap::getListGatewaysOfDomain(const am_domainID_t do
     listGatewaysID.clear();
     if (!existDomain(domainID))
     {
-    	logWarning(__func__,"domainID must exist");
+    	logWarning(__METHOD_NAME__,"domainID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1883,7 +1885,7 @@ am_Error_e CAmDatabaseHandlerMap::getListConvertersOfDomain(const am_domainID_t
     listConvertersID.clear();
     if (!existDomain(domainID))
     {
-    	logWarning(__func__,"domainID must exist");
+    	logWarning(__METHOD_NAME__,"domainID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -2074,7 +2076,7 @@ am_Error_e CAmDatabaseHandlerMap::getListMainSinkSoundProperties(const am_sinkID
 {
     if (!existSink(sinkID))
     {
-    	logWarning(__func__,"sinkID must exist");
+    	logWarning(__METHOD_NAME__,"sinkID must exist");
     	return E_NON_EXISTENT;
     }
 
@@ -2088,7 +2090,7 @@ am_Error_e CAmDatabaseHandlerMap::getListMainSourceSoundProperties(const am_sour
 {
     if (!existSource(sourceID))
     {
-    	logWarning(__func__,"sourceID must exist");
+    	logWarning(__METHOD_NAME__,"sourceID must exist");
     	return E_NON_EXISTENT;
     }
     const am_Source_s & source = mMappedData.mSourceMap.at(sourceID);
@@ -2101,7 +2103,7 @@ am_Error_e CAmDatabaseHandlerMap::getListSinkSoundProperties(const am_sinkID_t s
 {
     if (!existSink(sinkID))
     {
-    	logWarning(__func__,"sinkID must exist");
+    	logWarning(__METHOD_NAME__,"sinkID must exist");
     	return E_NON_EXISTENT;
     }
 
@@ -2115,7 +2117,7 @@ am_Error_e CAmDatabaseHandlerMap::getListSourceSoundProperties(const am_sourceID
 {
 	if (!existSource(sourceID))
     {
-		logWarning(__func__,"sourceID must exist");
+		logWarning(__METHOD_NAME__,"sourceID must exist");
     	return E_NON_EXISTENT;
     }
 
@@ -2135,7 +2137,7 @@ am_Error_e am::CAmDatabaseHandlerMap::getListSinkConnectionFormats(const am_sink
 {
    if (!existSink(sinkID))
    {
-	   logWarning(__func__,"sinkID must exist");
+	   logWarning(__METHOD_NAME__,"sinkID must exist");
 		return E_NON_EXISTENT;
    }
 	const am_Sink_s & sink = mMappedData.mSinkMap.at(sinkID);
@@ -2148,7 +2150,7 @@ am_Error_e am::CAmDatabaseHandlerMap::getListSourceConnectionFormats(const am_so
 {
    if (!existSource(sourceID))
    {
-	   logWarning(__func__,"sourceID must exist");
+	   logWarning(__METHOD_NAME__,"sourceID must exist");
 		return E_NON_EXISTENT;
    }
     const am_Source_s & source = mMappedData.mSourceMap.at(sourceID);
@@ -2161,7 +2163,7 @@ am_Error_e am::CAmDatabaseHandlerMap::getListGatewayConnectionFormats(const am_g
 {
    if (!existGateway(gatewayID))
    {
-	   logWarning(__func__,"gatewayID must exist");
+	   logWarning(__METHOD_NAME__,"gatewayID must exist");
 		return E_NON_EXISTENT;
    }
     ListConnectionFormat::const_iterator iter = mListConnectionFormat.begin();
@@ -2181,7 +2183,7 @@ am_Error_e CAmDatabaseHandlerMap::getTimingInformation(const am_mainConnectionID
 {
     if (!existMainConnection(mainConnectionID))
     {
-    	logWarning(__func__,"mainConnectionID must exist");
+    	logWarning(__METHOD_NAME__,"mainConnectionID must exist");
  		return E_NON_EXISTENT;
     }
     delay = -1;
@@ -2199,7 +2201,7 @@ am_Error_e CAmDatabaseHandlerMap::changeDelayMainConnection(const am_timeSync_t
 {
     if (!existMainConnection(connectionID))
     {
- 		logError(__func__,"connectionID must exist");
+ 		logError(__METHOD_NAME__,"connectionID must exist");
  		return E_NON_EXISTENT;
     }
     DB_COND_UPDATE_RIE(mMappedData.mMainConnectionMap[connectionID].delay, delay);
@@ -2417,7 +2419,7 @@ am_Error_e CAmDatabaseHandlerMap::changeConnectionTimingInformation(const am_con
 {
      if(!existConnectionID(connectionID))
      {
-     	logError(__func__,"connectionID must exist");
+     	logError(__METHOD_NAME__,"connectionID must exist");
          return (E_NON_EXISTENT);
      }
 
@@ -2449,7 +2451,7 @@ am_Error_e CAmDatabaseHandlerMap::changeConnectionFinal(const am_connectionID_t
     	mMappedData.mConnectionMap.at(connectionID).reserved = false;
     	return E_OK;
     }
-	logError(__func__,"connectionID must exist");
+	logError(__METHOD_NAME__,"connectionID must exist");
     return (E_NON_EXISTENT);
 }
 
@@ -2490,7 +2492,7 @@ bool CAmDatabaseHandlerMap::sourceVisible(const am_sourceID_t sourceID) const
 {
     if (!existSource(sourceID))
     {
-    	logError(__func__,"sourceID must exist");
+    	logError(__METHOD_NAME__,"sourceID must exist");
     	return false;
     }
     am_Source_Database_s source = mMappedData.mSourceMap.at(sourceID);
@@ -2574,7 +2576,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceState(const am_sourceID_t sourceID
 {
     if(!(sourceState>=SS_UNKNNOWN && sourceState<=SS_MAX))
 	{
-		logError(__func__,"sourceState must be valid");
+		logError(__METHOD_NAME__,"sourceState must be valid");
 		return (E_NOT_POSSIBLE);
 	}
 
@@ -2583,7 +2585,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceState(const am_sourceID_t sourceID
     	mMappedData.mSourceMap.at(sourceID).sourceState = sourceState;
 		return (E_OK);
 	}
-    logError(__func__,"sourceID must exist");
+    logError(__METHOD_NAME__,"sourceID must exist");
 	return (E_NON_EXISTENT);
 }
 
@@ -2597,7 +2599,7 @@ am_Error_e CAmDatabaseHandlerMap::getSinkMainVolume(const am_sinkID_t sinkID, am
 		return (E_OK);
 	}
 	mainVolume = -1;
-	logWarning(__func__,"sinkID must be valid");
+	logWarning(__METHOD_NAME__,"sinkID must be valid");
 	return (E_NON_EXISTENT);
 }
 
@@ -2611,7 +2613,7 @@ am_Error_e CAmDatabaseHandlerMap::getSinkVolume(const am_sinkID_t sinkID, am_vol
 		return (E_OK);
 	}
 	volume = -1;
-	logWarning(__func__,"sinkID must be valid");
+	logWarning(__METHOD_NAME__,"sinkID must be valid");
 	return (E_NON_EXISTENT);
 }
 
@@ -2624,7 +2626,7 @@ am_Error_e CAmDatabaseHandlerMap::getSourceVolume(const am_sourceID_t sourceID,
 		return (E_OK);
 	}
 	volume = -1;
-	logWarning(__func__,"sourceID must be valid");
+	logWarning(__METHOD_NAME__,"sourceID must be valid");
 	return (E_NON_EXISTENT);
 }
 
@@ -2648,7 +2650,7 @@ am_Error_e CAmDatabaseHandlerMap::getSinkSoundPropertyValue(const am_sinkID_t si
 		}
 	}
 	value = -1;
-	logWarning(__func__,"sinkID must be valid");
+	logWarning(__METHOD_NAME__,"sinkID must be valid");
 	return (E_NON_EXISTENT);
 }
 
@@ -2671,7 +2673,7 @@ am_Error_e CAmDatabaseHandlerMap::getSourceSoundPropertyValue(const am_sourceID_
 		}
 	}
 	value = -1;
-	logWarning(__func__,"sourceID must be valid");
+	logWarning(__METHOD_NAME__,"sourceID must be valid");
 	return (E_NON_EXISTENT);
 }
 
@@ -2694,7 +2696,7 @@ am_Error_e CAmDatabaseHandlerMap::getMainSinkSoundPropertyValue(const am_sinkID_
 		}
 	}
 	value = -1;
-	logWarning(__func__,"sinkID must be valid");
+	logWarning(__METHOD_NAME__,"sinkID must be valid");
 	return (E_NON_EXISTENT);
 }
 
@@ -2719,7 +2721,7 @@ am_Error_e CAmDatabaseHandlerMap::getMainSourceSoundPropertyValue(const am_sourc
 	}
 
 	value = -1;
-	logWarning(__func__,"sourceID must be valid");
+	logWarning(__METHOD_NAME__,"sourceID must be valid");
 	return (E_NON_EXISTENT);
 }
 
@@ -2733,7 +2735,7 @@ am_Error_e CAmDatabaseHandlerMap::getDomainState(const am_domainID_t domainID, a
 		return (E_OK);
 	}
 	state = DS_UNKNOWN;
-	logWarning(__func__,"domainID must be valid");
+	logWarning(__METHOD_NAME__,"domainID must be valid");
 	return (E_NON_EXISTENT);
 }
 
@@ -2837,7 +2839,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkVolume(const am_sinkID_t sinkID, con
 {
     if (!existSink(sinkID))
     {
-    	logError(__func__,"sinkID must be valid");
+    	logError(__METHOD_NAME__,"sinkID must be valid");
         return (E_NON_EXISTENT);
     }
 
@@ -2849,7 +2851,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceVolume(const am_sourceID_t sourceI
 {
     if (!existSource(sourceID))
     {
-    	logError(__func__,"sourceID must be valid");
+    	logError(__METHOD_NAME__,"sourceID must be valid");
         return (E_NON_EXISTENT);
     }
     mMappedData.mSourceMap[sourceID].volume = volume;
@@ -2861,7 +2863,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceSoundPropertyDB(const am_SoundProp
 {
     if (!existSource(sourceID))
     {
-    	logError(__func__,"sourceID must be valid");
+    	logError(__METHOD_NAME__,"sourceID must be valid");
         return (E_NON_EXISTENT);
     }
 
@@ -2877,7 +2879,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceSoundPropertyDB(const am_SoundProp
 			return (E_OK);
 		}
 	}
-	logError(__func__,"soundproperty type must be valid source:",sourceID,"type",soundProperty.type);
+	logError(__METHOD_NAME__,"soundproperty type must be valid source:",sourceID,"type",soundProperty.type);
 	return (E_NON_EXISTENT);
 }
 
@@ -2886,7 +2888,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkSoundPropertyDB(const am_SoundProper
 
     if (!existSink(sinkID))
     {
-    	logError(__func__,"sinkID must be valid");
+    	logError(__METHOD_NAME__,"sinkID must be valid");
         return (E_NON_EXISTENT);
     }
     am_Sink_Database_s & sink = mMappedData.mSinkMap[sinkID];
@@ -2901,7 +2903,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkSoundPropertyDB(const am_SoundProper
  			return (E_OK);
  		}
  	}
-	logError(__func__,"soundproperty type must be valid sinkID:",sinkID,"type",soundProperty.type);
+	logError(__METHOD_NAME__,"soundproperty type must be valid sinkID:",sinkID,"type",soundProperty.type);
  	return (E_NON_EXISTENT);
 }
 
@@ -2910,7 +2912,7 @@ am_Error_e CAmDatabaseHandlerMap::changeCrossFaderHotSink(const am_crossfaderID_
 
     if (!existCrossFader(crossfaderID))
     {
-    	logError(__func__,"crossfaderID must be valid");
+    	logError(__METHOD_NAME__,"crossfaderID must be valid");
         return (E_NON_EXISTENT);
     }
 
@@ -2966,7 +2968,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceDB(const am_sourceID_t sourceID, c
 
     if (!existSource(sourceID))
     {
-    	logError(__func__,"sourceID must be valid");
+    	logError(__METHOD_NAME__,"sourceID must be valid");
         return (E_NON_EXISTENT);
     }
 
@@ -3042,7 +3044,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkDB(const am_sinkID_t sinkID, const a
 
     if (!existSink(sinkID))
     {
-    	logError(__func__,"sinkID must be valid");
+    	logError(__METHOD_NAME__,"sinkID must be valid");
         return (E_NON_EXISTENT);
     }
 
@@ -3108,7 +3110,7 @@ am_Error_e CAmDatabaseHandlerMap::getListMainSinkNotificationConfigurations(cons
 
     if (!existSink(sinkID))
     {
-    	logWarning(__func__,"sinkID must be valid");
+    	logWarning(__METHOD_NAME__,"sinkID must be valid");
         return (E_DATABASE_ERROR);
     }
     listMainNotificationConfigurations.clear();
@@ -3123,7 +3125,7 @@ am_Error_e CAmDatabaseHandlerMap::getListMainSourceNotificationConfigurations(co
 
     if (!existSource(sourceID))
     {
-    	logWarning(__func__,"sourceID must be valid");
+    	logWarning(__METHOD_NAME__,"sourceID must be valid");
         return (E_DATABASE_ERROR);
     }
 
@@ -3156,7 +3158,7 @@ am_Error_e CAmDatabaseHandlerMap::changeMainSinkNotificationConfigurationDB(cons
 
     if (!existSink(sinkID))
     {
-    	logError(__func__,"sinkID must be valid");
+    	logError(__METHOD_NAME__,"sinkID must be valid");
         return (E_NON_EXISTENT);
     }
     if(!changeMainNotificationConfiguration(mMappedData.mSinkMap.at(sinkID).listMainNotificationConfigurations, mainNotificationConfiguration))
@@ -3174,7 +3176,7 @@ am_Error_e CAmDatabaseHandlerMap::changeMainSourceNotificationConfigurationDB(co
 
     if (!existSource(sourceID))
     {
-    	logError(__func__,"sourceID must be valid");
+    	logError(__METHOD_NAME__,"sourceID must be valid");
         return (E_NON_EXISTENT);
     }
 
@@ -3193,7 +3195,7 @@ am_Error_e CAmDatabaseHandlerMap::changeGatewayDB(const am_gatewayID_t gatewayID
 
    if (!existGateway(gatewayID))
    {
-	   logError(__func__,"gatewayID must be valid");
+	   logError(__METHOD_NAME__,"gatewayID must be valid");
        return (E_NON_EXISTENT);
    }
 
@@ -3224,7 +3226,7 @@ am_Error_e CAmDatabaseHandlerMap::changeConverterDB(const am_converterID_t conve
 
    if (!existConverter(converterID))
    {
-	   logError(__func__,"converterID must be valid");
+	   logError(__METHOD_NAME__,"converterID must be valid");
        return (E_NON_EXISTENT);
    }
 
@@ -3271,7 +3273,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkNotificationConfigurationDB(const am
 
     if (!existSink(sinkID))
     {
- 	   logError(__func__,"sinkID must be valid");
+ 	   logError(__METHOD_NAME__,"sinkID must be valid");
         return (E_NON_EXISTENT);
     }
     if(!changeNotificationConfiguration(mMappedData.mSinkMap.at(sinkID).listNotificationConfigurations, notificationConfiguration))
@@ -3288,7 +3290,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceNotificationConfigurationDB(const
 
     if (!existSource(sourceID))
     {
-  	   logError(__func__,"sourceID must be valid");
+  	   logError(__METHOD_NAME__,"sourceID must be valid");
         return (E_NON_EXISTENT);
     }
 
diff --git a/AudioManagerCore/src/CAmRoutingReceiver.cpp b/AudioManagerCore/src/CAmRoutingReceiver.cpp
index 103d35c..587cbf4 100644
--- a/AudioManagerCore/src/CAmRoutingReceiver.cpp
+++ b/AudioManagerCore/src/CAmRoutingReceiver.cpp
@@ -30,6 +30,8 @@
 #include "CAmDltWrapper.h"
 #include "CAmSocketHandler.h"
 
+#define __METHOD_NAME__ std::string (std::string("CAmRoutingReceiver::") + __func__)
+
 namespace am
 {
 
@@ -92,7 +94,7 @@ void CAmRoutingReceiver::handleCallback(const am_Handle_s handle, const am_Error
 
 void CAmRoutingReceiver::ackConnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_Error_e error)
 {
-	logInfo(__func__,"handle=",handle,"connectionID=",connectionID,"error=",error);
+	logInfo(__METHOD_NAME__,"handle=",handle,"connectionID=",connectionID,"error=",error);
     if (error == am_Error_e::E_OK)
     {
         mpRoutingSender->writeToDatabaseAndRemove(handle);
@@ -111,7 +113,7 @@ void CAmRoutingReceiver::ackConnect(const am_Handle_s handle, const am_connectio
 
 void CAmRoutingReceiver::ackDisconnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_Error_e error)
 {
-	logInfo(__func__,"handle=",handle,"connectionID=",connectionID,"error=",error);
+	logInfo(__METHOD_NAME__,"handle=",handle,"connectionID=",connectionID,"error=",error);
 	//only remove connection of handle was found
 	if(mpRoutingSender->removeHandle(handle) == 0)
 	{
@@ -122,7 +124,7 @@ void CAmRoutingReceiver::ackDisconnect(const am_Handle_s handle, const am_connec
 
 void CAmRoutingReceiver::ackSetSinkVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
 {
-	logInfo(__func__,"handle=",handle,"volume=",volume,"error=",error);
+	logInfo(__METHOD_NAME__,"handle=",handle,"volume=",volume,"error=",error);
 	if(error == E_OK)
     {
       	mpRoutingSender->checkVolume(handle,volume);
@@ -141,7 +143,7 @@ void CAmRoutingReceiver::ackSetSinkVolumeChange(const am_Handle_s handle, const
 
 void CAmRoutingReceiver::ackSetSourceVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
 {
-	logInfo(__func__,"handle=",handle,"volume=",volume,"error=",error);	
+	logInfo(__METHOD_NAME__,"handle=",handle,"volume=",volume,"error=",error);
 	if(error == E_OK)
     {
       	mpRoutingSender->checkVolume(handle,volume);
@@ -160,55 +162,55 @@ void CAmRoutingReceiver::ackSetSourceVolumeChange(const am_Handle_s handle, cons
 
 void CAmRoutingReceiver::ackSetSourceState(const am_Handle_s handle, const am_Error_e error)
 {
-	logInfo(__func__,"handle=",handle,"error=",error);		
+	logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
 	handleCallback(handle,error);
     mpControlSender->cbAckSetSourceState(handle, error);
 }
 
 void CAmRoutingReceiver::ackSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error)
 {
-	logInfo(__func__,"handle=",handle,"error=",error);	
+	logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
 	handleCallback(handle,error);
     mpControlSender->cbAckSetSinkSoundProperty(handle, error);
 }
 
 void am::CAmRoutingReceiver::ackSetSinkSoundProperties(const am_Handle_s handle, const am_Error_e error)
 {
-	logInfo(__func__,"handle=",handle,"error=",error);	
+	logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
 	handleCallback(handle,error);
     mpControlSender->cbAckSetSinkSoundProperties(handle, error);
 }
 
 void CAmRoutingReceiver::ackSetSourceSoundProperty(const am_Handle_s handle, const am_Error_e error)
 {
-	logInfo(__func__,"handle=",handle,"error=",error);	
+	logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
 	handleCallback(handle,error);
     mpControlSender->cbAckSetSourceSoundProperty(handle, error);
 }
 
 void am::CAmRoutingReceiver::ackSetSourceSoundProperties(const am_Handle_s handle, const am_Error_e error)
 {
-	logInfo(__func__,"handle=",handle,"error=",error);	
+	logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
 	handleCallback(handle,error);
     mpControlSender->cbAckSetSourceSoundProperties(handle, error);
 }
 
 void CAmRoutingReceiver::ackCrossFading(const am_Handle_s handle, const am_HotSink_e hotSink, const am_Error_e error)
 {
-	logInfo(__func__,"handle=",handle,"hotsink=",hotSink,"error=",error);	
+	logInfo(__METHOD_NAME__,"handle=",handle,"hotsink=",hotSink,"error=",error);
 	handleCallback(handle,error);
     mpControlSender->cbAckCrossFade(handle, hotSink, error);
 }
 
 void CAmRoutingReceiver::ackSourceVolumeTick(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume)
 {
-	logInfo(__func__,"handle=",handle,"sourceID=",sourceID,"volume=",volume);	
+	logInfo(__METHOD_NAME__,"handle=",handle,"sourceID=",sourceID,"volume=",volume);
     mpControlSender->hookSystemSourceVolumeTick(handle, sourceID, volume);
 }
 
 void CAmRoutingReceiver::ackSinkVolumeTick(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume)
 {
-	logInfo(__func__,"handle=",handle,"sinkID=",sinkID,"volume=",volume);	
+	logInfo(__METHOD_NAME__,"handle=",handle,"sinkID=",sinkID,"volume=",volume);
     mpControlSender->hookSystemSinkVolumeTick(handle, sinkID, volume);
 }
 
@@ -396,14 +398,14 @@ void am::CAmRoutingReceiver::waitOnStartup(bool startup)
 
 void CAmRoutingReceiver::ackSinkNotificationConfiguration(const am_Handle_s handle, const am_Error_e error)
 {
-	logInfo(__func__,"handle=",handle,"error=",error);		
+	logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
 	handleCallback(handle,error);
     mpControlSender->cbAckSetSinkNotificationConfiguration(handle,error);
 }
 
 void CAmRoutingReceiver::ackSourceNotificationConfiguration(const am_Handle_s handle, const am_Error_e error)
 {
-	logInfo(__func__,"handle=",handle,"error=",error);		
+	logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
 	handleCallback(handle,error);
     mpControlSender->cbAckSetSourceNotificationConfiguration(handle,error);
 }
@@ -430,20 +432,20 @@ am_Error_e CAmRoutingReceiver::updateSource(const am_sourceID_t sourceID, const
 
 void CAmRoutingReceiver::ackSetVolumes(const am_Handle_s handle, const std::vector<am_Volumes_s>& listvolumes, const am_Error_e error)
 {
-	logInfo(__func__,"handle=",handle,"error=",error);		
+	logInfo(__METHOD_NAME__,"handle=",handle,"error=",error);
 	handleCallback(handle,error);
     mpControlSender->cbAckSetVolume(handle,listvolumes,error);
 }
 
 void CAmRoutingReceiver::hookSinkNotificationDataChange(const am_sinkID_t sinkID, const am_NotificationPayload_s& payload)
 {
-    logInfo("CAmRoutingReceiver::hookSinkNotificationDataChange received, sinkID=",sinkID,"type=",payload.type,"notificationValue=",payload.value);
+    logInfo(__METHOD_NAME__,"sinkID=",sinkID,"type=",payload.type,"notificationValue=",payload.value);
     mpControlSender->hookSinkNotificationDataChanged(sinkID,payload);
 }
 
 void CAmRoutingReceiver::hookSourceNotificationDataChange(const am_sourceID_t sourceID, const am_NotificationPayload_s& payload)
 {
-    logInfo("CAmRoutingReceiver::hookSourceNotificationDataChange received, sinkID=",sourceID,"type=",payload.type,"notificationValue=",payload.value);
+    logInfo(__METHOD_NAME__,"sinkID=",sourceID,"type=",payload.type,"notificationValue=",payload.value);
     mpControlSender->hookSourceNotificationDataChanged(sourceID,payload);
 }
 
diff --git a/AudioManagerCore/src/CAmRoutingSender.cpp b/AudioManagerCore/src/CAmRoutingSender.cpp
index 06456f5..fc0953f 100644
--- a/AudioManagerCore/src/CAmRoutingSender.cpp
+++ b/AudioManagerCore/src/CAmRoutingSender.cpp
@@ -43,6 +43,8 @@ namespace am
 #define REQUIRED_INTERFACE_VERSION_MAJOR 1  //!< major interface version. All versions smaller than this will be rejected
 #define REQUIRED_INTERFACE_VERSION_MINOR 0 //!< minor interface version. All versions smaller than this will be rejected
 
+#define __METHOD_NAME__ std::string (std::string("CAmRoutingSender::") + __func__)
+
 CAmRoutingSender::CAmRoutingSender(const std::vector<std::string>& listOfPluginDirectories, IAmDatabaseHandler* databaseHandler) :
         mHandleCount(0), //
         mlistActiveHandles(), //
@@ -58,7 +60,7 @@ CAmRoutingSender::CAmRoutingSender(const std::vector<std::string>& listOfPluginD
 
     if (listOfPluginDirectories.empty())
     {
-        logError(__func__,"List of routingplugins is empty");
+        logError(__METHOD_NAME__,"List of routingplugins is empty");
     }
 
     std::vector<std::string> sharedLibraryNameList;
@@ -69,12 +71,12 @@ CAmRoutingSender::CAmRoutingSender(const std::vector<std::string>& listOfPluginD
     for (; dirIter < dirIterEnd; ++dirIter)
     {
         const char* directoryName = dirIter->c_str();
-        logInfo("Searching for HookPlugins in", directoryName);
+        logInfo(__METHOD_NAME__,"Searching for HookPlugins in", directoryName);
         DIR *directory = opendir(directoryName);
 
         if (!directory)
         {
-            logError("RoutingSender::RoutingSender Error opening directory: ", directoryName);
+            logError(__METHOD_NAME__,"Error opening directory: ", directoryName);
             continue;
         }
 
@@ -94,7 +96,7 @@ CAmRoutingSender::CAmRoutingSender(const std::vector<std::string>& listOfPluginD
 	            struct stat buf;
 
 	            if (stat(fullName.c_str(), &buf)) {
-	                logInfo(__PRETTY_FUNCTION__,"Failed to stat file: ", entryName, errno);
+	                logInfo(__METHOD_NAME__,"Failed to stat file: ", entryName, errno);
 	                continue;
 	            }
 
@@ -103,13 +105,13 @@ CAmRoutingSender::CAmRoutingSender(const std::vector<std::string>& listOfPluginD
 
             if (regularFile && sharedLibExtension)
             {
-                logInfo("RoutingSender::RoutingSender adding file: ", entryName);
+                logInfo(__METHOD_NAME__,"adding file: ", entryName);
                 std::string name(directoryName);
                 sharedLibraryNameList.push_back(name + "/" + entryName);
             }
             else
             {
-                logInfo("RoutingSender::RoutingSender PluginSearch ignoring file :", entryName);
+                logInfo(__METHOD_NAME__, "plugin search ignoring file :", entryName);
             }
         }
 
@@ -122,7 +124,7 @@ CAmRoutingSender::CAmRoutingSender(const std::vector<std::string>& listOfPluginD
 
     for (; iter != iterEnd; ++iter)
     {
-        logInfo("RoutingSender::RoutingSender try loading: ", *iter);
+        logInfo(__METHOD_NAME__,"try loading: ", *iter);
 
         IAmRoutingSend* (*createFunc)();
         void* tempLibHandle = NULL;
@@ -130,7 +132,7 @@ CAmRoutingSender::CAmRoutingSender(const std::vector<std::string>& listOfPluginD
 
         if (!createFunc)
         {
-            logError("RoutingSender::RoutingSender Entry point of RoutingPlugin not found");
+            logError(__METHOD_NAME__,"Entry point of RoutingPlugin not found");
             continue;
         }
 
@@ -138,7 +140,7 @@ CAmRoutingSender::CAmRoutingSender(const std::vector<std::string>& listOfPluginD
 
         if (!router)
         {
-            logError("RoutingSender::RoutingSender RoutingPlugin initialization failed. Entry Function not callable");
+            logError(__METHOD_NAME__,"initialization of plugin ",*iter,"failed. Entry Function not callable");
             dlclose(tempLibHandle);
             continue;
         }
@@ -159,7 +161,7 @@ CAmRoutingSender::CAmRoutingSender(const std::vector<std::string>& listOfPluginD
 
         if (majorVersion < cMajorVersion || ((majorVersion == cMajorVersion) && (minorVersion > cMinorVersion)))
         {
-            logError("Routing initialization failed. Version of Interface to old");
+            logError(__METHOD_NAME__,"Routing initialization failed. Version of Interface to old");
             dlclose(tempLibHandle);
             continue;
         }
@@ -180,7 +182,7 @@ CAmRoutingSender::~CAmRoutingSender()
     //every open handle is assumed to be an error...
     for (; it != mlistActiveHandles.end(); ++it)
     {
-        logError(__func__,"The action for the handle",it->first,"is still open");
+        logError(__METHOD_NAME__,"The action for the handle",it->first,"is still open");
     }
 }
 
@@ -207,10 +209,10 @@ am_Error_e CAmRoutingSender::asyncAbort(const am_Handle_s& handle)
     auto iter (mlistActiveHandles.find(handle));
     if (iter == mlistActiveHandles.end())
     {
-		logError(__func__,"Could not find handle",handle);
+		logError(__METHOD_NAME__,"Could not find handle",handle);
 		return (E_NON_EXISTENT);
     }
-    logInfo(__func__," handle", handle);
+    logInfo(__METHOD_NAME__," handle", handle);
 	return (iter->second->returnInterface()->asyncAbort(handle));
 }
 
@@ -219,7 +221,7 @@ am_Error_e CAmRoutingSender::asyncConnect(am_Handle_s& handle, am_connectionID_t
 	auto iter (mMapSinkInterface.find(sinkID));
 	if (iter == mMapSinkInterface.end())
 	{
-		logError(__func__,"Could not find sink",sinkID);
+		logError(__METHOD_NAME__,"Could not find sink",sinkID);
 		return (E_NON_EXISTENT);
 	}
 	
@@ -227,11 +229,11 @@ am_Error_e CAmRoutingSender::asyncConnect(am_Handle_s& handle, am_connectionID_t
 	{
 		if (handle.handleType==am_Handle_e::H_CONNECT)
 		{
-			logInfo(__func__,"Resending for handle",handle);
+			logInfo(__METHOD_NAME__,"Resending for handle",handle);
 		}
 		else
 		{
-			logError(__func__,"Handle exists but wrong type",handle);
+			logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
 			return(E_UNKNOWN);	
 		}
 	}
@@ -255,12 +257,12 @@ am_Error_e CAmRoutingSender::asyncConnect(am_Handle_s& handle, am_connectionID_t
 		handle = createHandle(handleData, am_Handle_e::H_CONNECT);
 	}
 
-    logInfo(__func__,"connectionID=",connectionID,"connectionFormat=", connectionFormat, "sourceID=", sourceID, "sinkID=", sinkID,"handle=",handle);
+    logInfo(__METHOD_NAME__,"connectionID=",connectionID,"connectionFormat=", connectionFormat, "sourceID=", sourceID, "sinkID=", sinkID,"handle=",handle);
 	am_Error_e syncError(iter->second->asyncConnect(handle, connectionID, sourceID, sinkID, connectionFormat));
 	if (syncError)
 	{
 		removeHandle(handle);
-		logError(__func__,"Error while calling connect connectionID:",connectionID,"sourceID:",sourceID,"sinkID:",sinkID,"connectionFormat:",connectionFormat,"handle",handle);
+		logError(__METHOD_NAME__,"Error while calling connect connectionID:",connectionID,"sourceID:",sourceID,"sinkID:",sinkID,"connectionFormat:",connectionFormat,"handle",handle);
 		mpDatabaseHandler->removeConnection(connectionID);
 	}
 	return(syncError); 
@@ -271,7 +273,7 @@ am_Error_e CAmRoutingSender::asyncDisconnect(am_Handle_s& handle, const am_conne
 	auto iter(mMapConnectionInterface.find(connectionID));
 	if (iter == mMapConnectionInterface.end())
 	{
-		logError(__func__,"Could not find connection",connectionID);
+		logError(__METHOD_NAME__,"Could not find connection",connectionID);
 		return (E_NON_EXISTENT);	
 	}
 	
@@ -279,11 +281,11 @@ am_Error_e CAmRoutingSender::asyncDisconnect(am_Handle_s& handle, const am_conne
 	{
 		if (handle.handleType==am_Handle_e::H_DISCONNECT)
 		{
-			logInfo(__func__,"Resending for handle",handle);
+			logInfo(__METHOD_NAME__,"Resending for handle",handle);
 		}
 		else
 		{
-			logError(__func__,"Handle exists but wrong type",handle);	
+			logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
 			return(E_UNKNOWN);	
 		}
     }
@@ -293,12 +295,12 @@ am_Error_e CAmRoutingSender::asyncDisconnect(am_Handle_s& handle, const am_conne
 		handle = createHandle(handleData, am_Handle_e::H_DISCONNECT);
 	}
 
-    logInfo(__func__,"connectionID=", connectionID, "handle=",handle);	
+    logInfo(__METHOD_NAME__,"connectionID=", connectionID, "handle=",handle);
 	am_Error_e syncError(iter->second->asyncDisconnect(handle, connectionID));
 	if (syncError)
 	{
 		removeHandle(handle);
-		logError(__func__,"Error while calling disconnect connectionID:",connectionID,"handle",handle);
+		logError(__METHOD_NAME__,"Error while calling disconnect connectionID:",connectionID,"handle",handle);
 	}
 	return(syncError);
 }
@@ -308,7 +310,7 @@ am_Error_e CAmRoutingSender::asyncSetSinkVolume(am_Handle_s& handle, const am_si
 	auto iter (mMapSinkInterface.find(sinkID));
 	if (iter == mMapSinkInterface.end())
 	{
-		logError(__func__,"Could not find sink",sinkID);
+		logError(__METHOD_NAME__,"Could not find sink",sinkID);
 		return (E_NON_EXISTENT);
 	}
 	
@@ -316,11 +318,11 @@ am_Error_e CAmRoutingSender::asyncSetSinkVolume(am_Handle_s& handle, const am_si
 	{
 		if (handle.handleType==am_Handle_e::H_SETSINKVOLUME)
 		{
-			logInfo(__func__,"Resending for handle",handle);
+			logInfo(__METHOD_NAME__,"Resending for handle",handle);
 		}
 		else
 		{
-			logError(__func__,"Handle exists but wrong type",handle);	
+			logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
 			return(E_UNKNOWN);	
 		}
     }
@@ -330,12 +332,12 @@ am_Error_e CAmRoutingSender::asyncSetSinkVolume(am_Handle_s& handle, const am_si
         handle = createHandle(handleData, H_SETSINKVOLUME);
     }
     
-    logInfo(__func__,"sinkID=", sinkID, "volume=", volume, "ramp=", ramp, "time=", time,"handle=",handle);    
+    logInfo(__METHOD_NAME__,"sinkID=", sinkID, "volume=", volume, "ramp=", ramp, "time=", time,"handle=",handle);
 	am_Error_e syncError(iter->second->asyncSetSinkVolume(handle, sinkID, volume, ramp, time));
 	if (syncError)
 	{
 		removeHandle(handle);
-		logError(__func__,"Error while calling asyncSetSinkVolume sinkID:",sinkID,"handle:",handle,"volume:",volume,"ramp:",ramp,"time:",time);
+		logError(__METHOD_NAME__,"Error while calling asyncSetSinkVolume sinkID:",sinkID,"handle:",handle,"volume:",volume,"ramp:",ramp,"time:",time);
 	}
 	return(syncError);
 }
@@ -345,7 +347,7 @@ am_Error_e CAmRoutingSender::asyncSetSourceVolume(am_Handle_s& handle, const am_
 	auto iter (mMapSourceInterface.find(sourceID));
 	if (iter == mMapSourceInterface.end())
 	{
-		logError(__func__,"Could not find sourceID",sourceID);
+		logError(__METHOD_NAME__,"Could not find sourceID",sourceID);
 		return (E_NON_EXISTENT);
 	}
 	
@@ -353,11 +355,11 @@ am_Error_e CAmRoutingSender::asyncSetSourceVolume(am_Handle_s& handle, const am_
 	{
 		if (handle.handleType==am_Handle_e::H_SETSOURCEVOLUME)
 		{
-			logInfo(__func__,"Resending for handle",handle);
+			logInfo(__METHOD_NAME__,"Resending for handle",handle);
 		}
 		else
 		{
-			logError(__func__,"Handle exists but wrong type",handle);	
+			logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
 			return(E_UNKNOWN);	
 		}
     }
@@ -367,12 +369,12 @@ am_Error_e CAmRoutingSender::asyncSetSourceVolume(am_Handle_s& handle, const am_
         handle = createHandle(handleData, H_SETSOURCEVOLUME);
     }
      
-    logInfo(__func__,"sourceID=", sourceID,"volume=", volume, "ramp=", ramp, "time=", time,"handle=",handle);     
+    logInfo(__METHOD_NAME__,"sourceID=", sourceID,"volume=", volume, "ramp=", ramp, "time=", time,"handle=",handle);
 	am_Error_e syncError(iter->second->asyncSetSourceVolume(handle, sourceID, volume, ramp, time));
 	if (syncError)
 	{
 		removeHandle(handle);
-		logError(__func__,"Error while calling asyncSetSourceVolume sourceID:",sourceID,"handle:",handle,"volume:",volume,"ramp:",ramp,"time:",time);
+		logError(__METHOD_NAME__,"Error while calling asyncSetSourceVolume sourceID:",sourceID,"handle:",handle,"volume:",volume,"ramp:",ramp,"time:",time);
 	}
 	return(syncError);
 }
@@ -382,7 +384,7 @@ am_Error_e CAmRoutingSender::asyncSetSourceState(am_Handle_s& handle, const am_s
 	auto iter (mMapSourceInterface.find(sourceID));
 	if (iter == mMapSourceInterface.end())
 	{
-		logError(__func__,"Could not find sourceID",sourceID);
+		logError(__METHOD_NAME__,"Could not find sourceID",sourceID);
 		return (E_NON_EXISTENT);
 	}
 	
@@ -390,11 +392,11 @@ am_Error_e CAmRoutingSender::asyncSetSourceState(am_Handle_s& handle, const am_s
 	{
 		if (handle.handleType==am_Handle_e::H_SETSOURCESTATE)
 		{
-			logInfo(__func__,"Resending for handle",handle);
+			logInfo(__METHOD_NAME__,"Resending for handle",handle);
 		}
 		else
 		{
-			logError(__func__,"Handle exists but wrong type",handle);	
+			logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
 			return(E_UNKNOWN);	
 		}
     }
@@ -403,12 +405,12 @@ am_Error_e CAmRoutingSender::asyncSetSourceState(am_Handle_s& handle, const am_s
 		auto handleData = std::make_shared<handleSourceState>(iter->second,sourceID,state,mpDatabaseHandler);
 		handle = createHandle(handleData, H_SETSOURCESTATE);
 	}
-    logInfo(__func__,"sourceID=", sourceID, "state=", state,"handle=",handle);	
+    logInfo(__METHOD_NAME__,"sourceID=", sourceID, "state=", state,"handle=",handle);
 	am_Error_e syncError(iter->second->asyncSetSourceState(handle, sourceID, state));
 	if (syncError)
 	{
 		removeHandle(handle);
-		logError(__func__,"Error while calling asyncSetSourceState sourceID:",sourceID,"handle:",handle,"state:",state);		
+		logError(__METHOD_NAME__,"Error while calling asyncSetSourceState sourceID:",sourceID,"handle:",handle,"state:",state);
 	}
 	return(syncError);
 }
@@ -418,7 +420,7 @@ am_Error_e CAmRoutingSender::asyncSetSinkSoundProperty(am_Handle_s& handle, cons
 	auto iter (mMapSinkInterface.find(sinkID));
 	if (iter == mMapSinkInterface.end())
 	{
-		logError(__func__,"Could not find sink",sinkID);
+		logError(__METHOD_NAME__,"Could not find sink",sinkID);
 		return (E_NON_EXISTENT);
 	}
 	
@@ -426,11 +428,11 @@ am_Error_e CAmRoutingSender::asyncSetSinkSoundProperty(am_Handle_s& handle, cons
 	{
 		if (handle.handleType==am_Handle_e::H_SETSINKSOUNDPROPERTY)
 		{
-			logInfo(__func__,"Resending for handle",handle);
+			logInfo(__METHOD_NAME__,"Resending for handle",handle);
 		}
 		else
 		{
-			logError(__func__,"Handle exists but wrong type",handle);	
+			logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
 			return(E_UNKNOWN);	
 		}
     }
@@ -440,12 +442,12 @@ am_Error_e CAmRoutingSender::asyncSetSinkSoundProperty(am_Handle_s& handle, cons
         handle = createHandle(handleData, H_SETSINKSOUNDPROPERTY);
      }
      
-    logInfo(__func__,"sinkID=", sinkID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value,"handle=",handle);     
+    logInfo(__METHOD_NAME__,"sinkID=", sinkID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value,"handle=",handle);
 	am_Error_e syncError(iter->second->asyncSetSinkSoundProperty(handle, sinkID, soundProperty));
 	if (syncError)
 	{
 		removeHandle(handle);
-		logError(__func__,"Error while calling asyncSetSinkSoundProperty sinkID:",sinkID,"handle:",handle,"soundProperty:",soundProperty.type,soundProperty.value);
+		logError(__METHOD_NAME__,"Error while calling asyncSetSinkSoundProperty sinkID:",sinkID,"handle:",handle,"soundProperty:",soundProperty.type,soundProperty.value);
 	}
 	return(syncError);
 }
@@ -455,7 +457,7 @@ am_Error_e CAmRoutingSender::asyncSetSourceSoundProperty(am_Handle_s& handle, co
 	auto iter (mMapSourceInterface.find(sourceID));
 	if (iter == mMapSourceInterface.end())
 	{
-		logError(__func__,"Could not find sourceID",sourceID);
+		logError(__METHOD_NAME__,"Could not find sourceID",sourceID);
 		return (E_NON_EXISTENT);
 	}
 	
@@ -463,11 +465,11 @@ am_Error_e CAmRoutingSender::asyncSetSourceSoundProperty(am_Handle_s& handle, co
 	{
 		if (handle.handleType==am_Handle_e::H_SETSOURCESOUNDPROPERTY)
 		{
-			logInfo(__func__,"Resending for handle",handle);
+			logInfo(__METHOD_NAME__,"Resending for handle",handle);
 		}
 		else
 		{
-			logError(__func__,"Handle exists but wrong type",handle);	
+			logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
 			return(E_UNKNOWN);	
 		}
     }
@@ -476,12 +478,12 @@ am_Error_e CAmRoutingSender::asyncSetSourceSoundProperty(am_Handle_s& handle, co
 		auto handleData = std::make_shared<handleSourceSoundProperty>(iter->second,sourceID,soundProperty,mpDatabaseHandler);
         handle = createHandle(handleData, H_SETSOURCESOUNDPROPERTY);
     }
-    logInfo(__func__,"sourceID=", sourceID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value,"handle=",handle);    
+    logInfo(__METHOD_NAME__,"sourceID=", sourceID, "soundProperty.Type=", soundProperty.type, "soundProperty.value=", soundProperty.value,"handle=",handle);
 	am_Error_e syncError(iter->second->asyncSetSourceSoundProperty(handle, sourceID, soundProperty));
 	if (syncError)
 	{
 		removeHandle(handle);
-		logError(__func__,"Error while calling asyncSetSourceSoundProperty sourceID:",sourceID,"handle:",handle,"soundProperty:",soundProperty.type,soundProperty.value);		
+		logError(__METHOD_NAME__,"Error while calling asyncSetSourceSoundProperty sourceID:",sourceID,"handle:",handle,"soundProperty:",soundProperty.type,soundProperty.value);
 	}
 	return(syncError);
 }
@@ -491,7 +493,7 @@ am_Error_e CAmRoutingSender::asyncSetSourceSoundProperties(am_Handle_s& handle,
 	auto iter (mMapSourceInterface.find(sourceID));
 	if (iter == mMapSourceInterface.end())
 	{
-		logError(__func__,"Could not find sourceID",sourceID);
+		logError(__METHOD_NAME__,"Could not find sourceID",sourceID);
 		return (E_NON_EXISTENT);
 	}
 	
@@ -499,11 +501,11 @@ am_Error_e CAmRoutingSender::asyncSetSourceSoundProperties(am_Handle_s& handle,
 	{
 		if (handle.handleType==am_Handle_e::H_SETSOURCESOUNDPROPERTIES)
 		{
-			logInfo(__func__,"Resending for handle",handle);
+			logInfo(__METHOD_NAME__,"Resending for handle",handle);
 		}
 		else
 		{
-			logError(__func__,"Handle exists but wrong type",handle);	
+			logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
 			return(E_UNKNOWN);	
 		}
     }
@@ -513,12 +515,12 @@ am_Error_e CAmRoutingSender::asyncSetSourceSoundProperties(am_Handle_s& handle,
         handle = createHandle(handleData, H_SETSOURCESOUNDPROPERTIES);
     }
      
-    logInfo(__func__,"sourceID=", sourceID);     
+    logInfo(__METHOD_NAME__,"sourceID=", sourceID);
 	am_Error_e syncError(iter->second->asyncSetSourceSoundProperties(handle, sourceID, listSoundProperties));
 	if (syncError)
 	{
 		removeHandle(handle);
-		logError(__func__,"Error while calling asyncSetSourceSoundProperties sourceID:",sourceID,"handle:",handle);		
+		logError(__METHOD_NAME__,"Error while calling asyncSetSourceSoundProperties sourceID:",sourceID,"handle:",handle);
 	}
 	return(syncError);
 }
@@ -528,7 +530,7 @@ am_Error_e CAmRoutingSender::asyncSetSinkSoundProperties(am_Handle_s& handle, co
 	auto iter (mMapSinkInterface.find(sinkID));
 	if (iter == mMapSinkInterface.end())
 	{
-		logError(__func__,"Could not find sink",sinkID);
+		logError(__METHOD_NAME__,"Could not find sink",sinkID);
 		return (E_NON_EXISTENT);
 	}
 	
@@ -536,11 +538,11 @@ am_Error_e CAmRoutingSender::asyncSetSinkSoundProperties(am_Handle_s& handle, co
 	{
 		if (handle.handleType==am_Handle_e::H_SETSINKSOUNDPROPERTIES)
 		{
-			logInfo(__func__,"Resending for handle",handle);
+			logInfo(__METHOD_NAME__,"Resending for handle",handle);
 		}
 		else
 		{
-			logError(__func__,"Handle exists but wrong type",handle);	
+			logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
 			return(E_UNKNOWN);	
 		}
     }
@@ -550,12 +552,12 @@ am_Error_e CAmRoutingSender::asyncSetSinkSoundProperties(am_Handle_s& handle, co
         handle = createHandle(handleData, H_SETSINKSOUNDPROPERTIES);
     }
     
-    logInfo(__func__,"sinkID=", sinkID,"handle=",handle);    
+    logInfo(__METHOD_NAME__,"sinkID=", sinkID,"handle=",handle);
 	am_Error_e syncError(iter->second->asyncSetSinkSoundProperties(handle, sinkID, listSoundProperties));
 	if (syncError)
 	{
 		removeHandle(handle);
-		logError(__func__,"Error while calling asyncSetSinkSoundProperties sinkID:",sinkID,"handle:",handle);			
+		logError(__METHOD_NAME__,"Error while calling asyncSetSinkSoundProperties sinkID:",sinkID,"handle:",handle);
 	}
 	return(syncError);
 }
@@ -565,7 +567,7 @@ am_Error_e CAmRoutingSender::asyncCrossFade(am_Handle_s& handle, const am_crossf
 	auto iter (mMapCrossfaderInterface.find(crossfaderID));
 	if (iter == mMapCrossfaderInterface.end())
 	{
-		logError(__func__,"Could not find crossfaderID",crossfaderID);
+		logError(__METHOD_NAME__,"Could not find crossfaderID",crossfaderID);
 		return (E_NON_EXISTENT);
 	}
 	
@@ -573,11 +575,11 @@ am_Error_e CAmRoutingSender::asyncCrossFade(am_Handle_s& handle, const am_crossf
 	{
 		if (handle.handleType==am_Handle_e::H_CROSSFADE)
 		{
-			logInfo(__func__,"Resending for handle",handle);
+			logInfo(__METHOD_NAME__,"Resending for handle",handle);
 		}
 		else
 		{
-			logError(__func__,"Handle exists but wrong type",handle);	
+			logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
 			return(E_UNKNOWN);	
 		}
     }
@@ -587,7 +589,7 @@ am_Error_e CAmRoutingSender::asyncCrossFade(am_Handle_s& handle, const am_crossf
         handle = createHandle(handleData, H_CROSSFADE);
 	}
 	
-	logInfo(__func__,"hotSource=", hotSink, "crossfaderID=", crossfaderID, "rampType=", rampType, "rampTime=", time,"handle=",handle);
+	logInfo(__METHOD_NAME__,"hotSource=", hotSink, "crossfaderID=", crossfaderID, "rampType=", rampType, "rampTime=", time,"handle=",handle);
 	am_Error_e syncError(iter->second->asyncCrossFade(handle, crossfaderID, hotSink, rampType, time));
 	if (syncError)
 	{
@@ -598,7 +600,7 @@ am_Error_e CAmRoutingSender::asyncCrossFade(am_Handle_s& handle, const am_crossf
 
 am_Error_e CAmRoutingSender::setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState)
 {
-	logInfo(__func__,"domainID=", domainID, "domainState=", domainState);
+	logInfo(__METHOD_NAME__,"domainID=", domainID, "domainState=", domainState);
     DomainInterfaceMap::iterator iter = mMapDomainInterface.begin();
     iter = mMapDomainInterface.find(domainID);
     if (iter != mMapDomainInterface.end())
@@ -760,7 +762,7 @@ am_Error_e CAmRoutingSender::removeHandle(const am_Handle_s& handle)
     {
         return (E_OK);
     }
-    logError(__func__,"Could not remove handle",handle.handle);
+    logError(__METHOD_NAME__,"Could not remove handle",handle.handle);
     return (E_NON_EXISTENT);
 }
 
@@ -793,7 +795,7 @@ am_Handle_s CAmRoutingSender::createHandle(std::shared_ptr<handleDataBase> handl
     {
         logInfo("CAmRoutingSender::createHandle warning: too many open handles, number of handles: ", mlistActiveHandles.size());
     }
-    logInfo(__func__,handle.handle, handle.handleType);
+    logInfo(__METHOD_NAME__,handle.handle, handle.handleType);
     return (handle);
 }
 
@@ -876,7 +878,7 @@ am_Error_e CAmRoutingSender::asyncSetVolumes(am_Handle_s& handle, const std::vec
 	auto handleData = std::make_shared<handleSetVolumes>(pRoutingInterface,listVolumes,mpDatabaseHandler);
     handle = createHandle(handleData, H_SETVOLUMES);
 
-    logInfo(__func__, "handle=", handle);
+    logInfo(__METHOD_NAME__, "handle=", handle);
     am_Error_e syncError(pRoutingInterface->asyncSetVolumes(handle, listVolumes));
     if (syncError)
 	{
@@ -891,7 +893,7 @@ am_Error_e CAmRoutingSender::asyncSetSinkNotificationConfiguration(am_Handle_s&
 	auto iter (mMapSinkInterface.find(sinkID));
 	if (iter == mMapSinkInterface.end())
 	{
-		logError(__func__,"Could not find sink",sinkID);
+		logError(__METHOD_NAME__,"Could not find sink",sinkID);
 		return (E_NON_EXISTENT);
 	}
 	
@@ -899,11 +901,11 @@ am_Error_e CAmRoutingSender::asyncSetSinkNotificationConfiguration(am_Handle_s&
 	{
 		if (handle.handleType==am_Handle_e::H_SETSINKNOTIFICATION)
 		{
-			logInfo(__func__,"Resending for handle",handle);
+			logInfo(__METHOD_NAME__,"Resending for handle",handle);
 		}
 		else
 		{
-			logError(__func__,"Handle exists but wrong type",handle);	
+			logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
 			return(E_UNKNOWN);	
 		}
     }
@@ -913,12 +915,12 @@ am_Error_e CAmRoutingSender::asyncSetSinkNotificationConfiguration(am_Handle_s&
         handle = createHandle(handleData, H_SETSINKNOTIFICATION);
     }
 
-    logInfo(__func__,"sinkID=",sinkID,"notificationConfiguration.type=",notificationConfiguration.type,"notificationConfiguration.status",notificationConfiguration.status,"notificationConfiguration.parameter",notificationConfiguration.parameter);      
+    logInfo(__METHOD_NAME__,"sinkID=",sinkID,"notificationConfiguration.type=",notificationConfiguration.type,"notificationConfiguration.status",notificationConfiguration.status,"notificationConfiguration.parameter",notificationConfiguration.parameter);
 	am_Error_e syncError(iter->second->asyncSetSinkNotificationConfiguration(handle, sinkID, notificationConfiguration));
 	if (syncError)
 	{
 		removeHandle(handle);
-		logError(__func__,"Error while calling asyncSetSinkNotificationConfiguration sinkID:",sinkID,"handle:",handle);			
+		logError(__METHOD_NAME__,"Error while calling asyncSetSinkNotificationConfiguration sinkID:",sinkID,"handle:",handle);
 	}
 	return(syncError);
 }
@@ -928,7 +930,7 @@ am_Error_e CAmRoutingSender::asyncSetSourceNotificationConfiguration(am_Handle_s
 	auto iter (mMapSourceInterface.find(sourceID));
 	if (iter == mMapSourceInterface.end())
 	{
-		logError(__func__,"Could not find sourceID",sourceID);
+		logError(__METHOD_NAME__,"Could not find sourceID",sourceID);
 		return (E_NON_EXISTENT);
 	}
 	
@@ -936,11 +938,11 @@ am_Error_e CAmRoutingSender::asyncSetSourceNotificationConfiguration(am_Handle_s
 	{
 		if (handle.handleType==am_Handle_e::H_SETSOURCENOTIFICATION)
 		{
-			logInfo(__func__,"Resending for handle",handle);
+			logInfo(__METHOD_NAME__,"Resending for handle",handle);
 		}
 		else
 		{
-			logError(__func__,"Handle exists but wrong type",handle);	
+			logError(__METHOD_NAME__,"Handle exists but wrong type",handle);
 			return(E_UNKNOWN);	
 		}
     }
@@ -950,12 +952,12 @@ am_Error_e CAmRoutingSender::asyncSetSourceNotificationConfiguration(am_Handle_s
         handle = createHandle(handleData, H_SETSOURCENOTIFICATION);
     }
 
-    logInfo(__func__,"sourceID=",sourceID,"notificationConfiguration.type=",notificationConfiguration.type,"notificationConfiguration.status",notificationConfiguration.status,"notificationConfiguration.parameter",notificationConfiguration.parameter);    
+    logInfo(__METHOD_NAME__,"sourceID=",sourceID,"notificationConfiguration.type=",notificationConfiguration.type,"notificationConfiguration.status",notificationConfiguration.status,"notificationConfiguration.parameter",notificationConfiguration.parameter);
 	am_Error_e syncError(iter->second->asyncSetSourceNotificationConfiguration(handle, sourceID, notificationConfiguration));
 	if (syncError)
 	{
 		removeHandle(handle);
-		logError(__func__,"Error while calling asyncSetSourceNotificationConfiguration sourceID:",sourceID,"handle:",handle);			
+		logError(__METHOD_NAME__,"Error while calling asyncSetSourceNotificationConfiguration sourceID:",sourceID,"handle:",handle);
 	}
 	return(syncError);
 }
@@ -1002,7 +1004,7 @@ am_Error_e CAmRoutingSender::writeToDatabaseAndRemove(const am_Handle_s handle)
     	mlistActiveHandles.erase(handle);
         return (error);
     }
-    logError(__func__,"could not find handle data for handle",handle);
+    logError(__METHOD_NAME__,"could not find handle data for handle",handle);
     return (am_Error_e::E_NON_EXISTENT);	
 }
 
@@ -1014,11 +1016,11 @@ void CAmRoutingSender::checkVolume(const am_Handle_s handle, const am_volume_t v
 		handleVolumeBase* basePtr = static_cast<handleVolumeBase*>(it->second.get());
     	if (basePtr->returnVolume()!=volume)
     	{	
-			logError(__func__,"volume returned for handle does not match: ",volume,"expected:",basePtr->returnVolume());	
+			logError(__METHOD_NAME__,"volume returned for handle does not match: ",volume,"expected:",basePtr->returnVolume());
 		}	
     	return;
     }
-    logError(__func__,"could not find handle data for handle",handle);	
+    logError(__METHOD_NAME__,"could not find handle data for handle",handle);
 }
 
 bool CAmRoutingSender::handleExists(const am_Handle_s handle)