* many database observers can be registred now by the database handler.

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

6 files changed, 147 insertions, 166 deletions

diff --git a/AudioManagerCore/include/CAmCommandSender.h b/AudioManagerCore/include/CAmCommandSender.h
index 82363de..caa72ad 100644
--- a/AudioManagerCore/include/CAmCommandSender.h
+++ b/AudioManagerCore/include/CAmCommandSender.h
@@ -29,21 +29,24 @@
 #endif
 
 #include "IAmCommand.h"
+#include "CAmDatabaseHandlerMap.h"
+#include "CAmSerializer.h"
 
 namespace am
 {
 
 class CAmCommandReceiver;
+class CAmCommandSender;
 
 
 /**
  * This class is used to send data to the CommandInterface.
  * All loaded plugins will be called when a callback is invoked.
  */
-class CAmCommandSender
+class CAmCommandSender: public CAmDatabaseHandlerMap::AmDatabaseObserverCallbacks
 {
 public:
-    CAmCommandSender(const std::vector<std::string>& listOfPluginDirectories);
+    CAmCommandSender(const std::vector<std::string>& listOfPluginDirectories, CAmSocketHandler *iSocketHandler);
     ~CAmCommandSender();
     am_Error_e startupInterfaces(CAmCommandReceiver* iCommandReceiver);
     void setCommandReady();
@@ -78,14 +81,18 @@ public:
     friend class IAmCommandBackdoor; //this is to get access to the loaded plugins and be able to exchange the interfaces
 #endif
 private:
+    
     void unloadLibraries(void); //!< unload the shared libraries
     std::vector<IAmCommandSend*> mListInterfaces; //!< list of all interfaces
     std::vector<void*> mListLibraryHandles; //!< list of all library handles. This information is used to unload the plugins correctly.
     std::vector<std::string> mListLibraryNames; //!< list of all library names. This information is used for getListPlugins.
-
+    
     CAmCommandReceiver *mCommandReceiver;
+    CAmSerializer mSerializer;
 };
 
+
+
 }
 
 #endif /* COMMANDSENDER_H_ */
diff --git a/AudioManagerCore/include/CAmDatabaseHandlerMap.h b/AudioManagerCore/include/CAmDatabaseHandlerMap.h
index 05443b1..3909b05 100644
--- a/AudioManagerCore/include/CAmDatabaseHandlerMap.h
+++ b/AudioManagerCore/include/CAmDatabaseHandlerMap.h
@@ -74,6 +74,51 @@ class CAmDatabaseHandlerMap : public IAmDatabaseHandler
 public:
 	CAmDatabaseHandlerMap();
     virtual ~CAmDatabaseHandlerMap();
+
+    /**
+      * Database observer.
+      */
+    struct AmDatabaseObserverCallbacks: public IAmDatabaseObserver
+    {
+    protected:
+    	std::function<void()> dboNumberOfSinkClassesChanged;
+    	std::function<void()> dboNumberOfSourceClassesChanged;
+    	std::function<void(const am_Sink_s&)> dboNewSink;
+    	std::function<void(const am_Source_s&)> dboNewSource;
+    	std::function<void(const am_Domain_s& )> dboNewDomain;
+    	std::function<void (const am_Gateway_s& )> dboNewGateway;
+    	std::function<void (const am_Converter_s& )> dboNewConverter;
+    	std::function<void (const am_Crossfader_s& )> dboNewCrossfader;
+    	std::function<void (const am_MainConnectionType_s& )> dboNewMainConnection;
+    	std::function<void (const am_mainConnectionID_t )> dboRemovedMainConnection;
+    	std::function<void (const am_sinkID_t , const bool )> dboRemovedSink;
+    	std::function<void (const am_sourceID_t , const bool )> dboRemovedSource;
+    	std::function<void (const am_domainID_t )> dboRemoveDomain;
+    	std::function<void (const am_gatewayID_t )> dboRemoveGateway;
+    	std::function<void (const am_converterID_t )> dboRemoveConverter;
+    	std::function<void (const am_crossfaderID_t )> dboRemoveCrossfader;
+    	std::function<void (const am_mainConnectionID_t , const am_ConnectionState_e )> dboMainConnectionStateChanged;
+    	std::function<void (const am_sinkID_t , const am_MainSoundProperty_s& )> dboMainSinkSoundPropertyChanged;
+    	std::function<void (const am_sourceID_t , const am_MainSoundProperty_s& )> dboMainSourceSoundPropertyChanged;
+    	std::function<void (const am_sinkID_t , const am_Availability_s& )> dboSinkAvailabilityChanged;
+    	std::function<void (const am_sourceID_t , const am_Availability_s& )> dboSourceAvailabilityChanged;
+    	std::function<void (const am_sinkID_t , const am_mainVolume_t )> dboVolumeChanged;
+    	std::function<void (const am_sinkID_t , const am_MuteState_e )> dboSinkMuteStateChanged;
+    	std::function<void (const am_SystemProperty_s& )>dboSystemPropertyChanged;
+    	std::function<void (const am_mainConnectionID_t , const am_timeSync_t )>dboTimingInformationChanged;
+    	std::function<void (const am_sinkID_t , const am_sinkClass_t , const std::vector<am_MainSoundProperty_s>& , const bool )>dboSinkUpdated;
+    	std::function<void (const am_sourceID_t , const am_sourceClass_t , const std::vector<am_MainSoundProperty_s>& , const bool )>dboSourceUpdated;
+    	std::function<void (const am_sinkID_t , const am_NotificationConfiguration_s )> dboSinkMainNotificationConfigurationChanged;
+    	std::function<void (const am_sourceID_t , const am_NotificationConfiguration_s )> dboSourceMainNotificationConfigurationChanged;
+    public:
+    	friend class CAmDatabaseHandlerMap;
+    	AmDatabaseObserverCallbacks():IAmDatabaseObserver(), mpDatabaseHandler(nullptr) {}
+        virtual ~AmDatabaseObserverCallbacks(){ if(mpDatabaseHandler) mpDatabaseHandler->unregisterObserver(this);}
+    protected:
+	CAmDatabaseHandlerMap *mpDatabaseHandler;
+
+    };
+
     am_Error_e enterDomainDB(const am_Domain_s& domainData, am_domainID_t& domainID);
     am_Error_e enterMainConnectionDB(const am_MainConnection_s& mainConnectionData, am_mainConnectionID_t& connectionID);
     am_Error_e enterSinkDB(const am_Sink_s& sinkData, am_sinkID_t& sinkID);
@@ -196,7 +241,6 @@ public:
     bool existConverter(const am_converterID_t converterID) const;
     bool existSinkClass(const am_sinkClass_t sinkClassID) const;
     bool existSourceClass(const am_sourceClass_t sourceClassID) const;
-    void registerObserver(CAmDatabaseObserver *iObserver);
     bool sourceVisible(const am_sourceID_t sourceID) const;
     bool sinkVisible(const am_sinkID_t sinkID) const;
     bool isComponentConnected(const am_Gateway_s & gateway) const;
@@ -206,6 +250,11 @@ public:
     am_Error_e enumerateSinks(std::function<void(const am_Sink_s & element)> cb) const;
     am_Error_e enumerateGateways(std::function<void(const am_Gateway_s & element)> cb) const;
     am_Error_e enumerateConverters(std::function<void(const am_Converter_s & element)> cb) const;
+
+    bool registerObserver(IAmDatabaseObserver * iObserver);
+   	bool unregisterObserver(IAmDatabaseObserver * iObserver);
+    unsigned countObservers();
+
     /**
      * The following structures extend the base structures with the field 'reserved'.
      */
@@ -276,55 +325,55 @@ public:
 		AM_SUBCLASS_COPY_OP_END()\
 		AM_SUBCLASS_OP(Subclass, Class)\
 
-
+private:
     AM_TYPEDEF_SUBCLASS_RESERVED_FLAG_BEGIN(am_Domain_Database_s,am_Domain_s)
-    AM_SUBCLASS_END(CAmDomain)
+    AM_SUBCLASS_END(AmDomain)
 
     AM_TYPEDEF_SUBCLASS_SOUND_PROPERTIES_BEGIN(am_Sink_Database_s,am_Sink_s)
     	void getSinkType(am_SinkType_s & sinkType) const;\
-    AM_SUBCLASS_END(CAmSink)
+    AM_SUBCLASS_END(AmSink)
 
     AM_TYPEDEF_SUBCLASS_SOUND_PROPERTIES_BEGIN(am_Source_Database_s,am_Source_s)
     	void getSourceType(am_SourceType_s & sourceType) const;\
-    AM_SUBCLASS_END(CAmSource)
+    AM_SUBCLASS_END(AmSource)
 
     AM_TYPEDEF_SUBCLASS_RESERVED_FLAG_BEGIN(am_Connection_Database_s,am_Connection_s)
-    AM_SUBCLASS_END(CAmConnection)
+    AM_SUBCLASS_END(AmConnection)
 
     /**
       * The following structures extend the base structures with print capabilities.
     */
     AM_TYPEDEF_SUBCLASS_BEGIN(am_MainConnection_Database_s, am_MainConnection_s)
     	void getMainConnectionType(am_MainConnectionType_s & connectionType) const;\
-    AM_SUBCLASS_END(CAmMainConnection)
+    AM_SUBCLASS_END(AmMainConnection)
 
 	AM_TYPEDEF_SUBCLASS_BEGIN(am_SourceClass_Database_s, am_SourceClass_s)
-	AM_SUBCLASS_END(CAmSourceClass)
+	AM_SUBCLASS_END(AmSourceClass)
 
 	AM_TYPEDEF_SUBCLASS_BEGIN(am_SinkClass_Database_s, am_SinkClass_s)
-	AM_SUBCLASS_END(CAmSinkClass)
+	AM_SUBCLASS_END(AmSinkClass)
 
 	AM_TYPEDEF_SUBCLASS_BEGIN(am_Gateway_Database_s, am_Gateway_s)
-	AM_SUBCLASS_END(CAmGateway)
+	AM_SUBCLASS_END(AmGateway)
 
 	AM_TYPEDEF_SUBCLASS_BEGIN(am_Converter_Database_s, am_Converter_s)
-	AM_SUBCLASS_END(CAmConverter)
+	AM_SUBCLASS_END(AmConverter)
 
 	AM_TYPEDEF_SUBCLASS_BEGIN(am_Crossfader_Database_s, am_Crossfader_s)
-	AM_SUBCLASS_END(CAmCrossfader)
-
-    private:
-    typedef std::unordered_map<am_domainID_t, CAmDomain>  		  			 	 CAmMapDomain;
-    typedef std::unordered_map<am_sourceClass_t, CAmSourceClass> 				 CAmMapSourceClass;
-    typedef std::unordered_map<am_sinkClass_t, CAmSinkClass> 		  	  	     CAmMapSinkClass;
-    typedef std::unordered_map<am_sinkID_t, CAmSink> 			   				 CAmMapSink;
-    typedef std::unordered_map<am_sourceID_t, CAmSource> 		 			 	 CAmMapSource;
-    typedef std::unordered_map<am_gatewayID_t, CAmGateway> 			 	 		 CAmMapGateway;
-    typedef std::unordered_map<am_converterID_t, CAmConverter> 			 	 	 CAmMapConverter;
-    typedef std::unordered_map<am_crossfaderID_t, CAmCrossfader> 		    	 CAmMapCrossfader;
-    typedef std::unordered_map<am_connectionID_t, CAmConnection>				 CAmMapConnection;
-    typedef std::unordered_map<am_mainConnectionID_t, CAmMainConnection> 	 	 CAmMapMainConnection;
-    typedef std::vector<am_SystemProperty_s> 	   				  			     CAmVectorSystemProperties;
+	AM_SUBCLASS_END(AmCrossfader)
+
+
+    typedef std::unordered_map<am_domainID_t, AmDomain>  		  			 	 AmMapDomain;
+    typedef std::unordered_map<am_sourceClass_t, AmSourceClass> 				 AmMapSourceClass;
+    typedef std::unordered_map<am_sinkClass_t, AmSinkClass> 		  	  	     AmMapSinkClass;
+    typedef std::unordered_map<am_sinkID_t, AmSink> 			   				 AmMapSink;
+    typedef std::unordered_map<am_sourceID_t, AmSource> 		 			 	 AmMapSource;
+    typedef std::unordered_map<am_gatewayID_t, AmGateway> 			 	 		 AmMapGateway;
+    typedef std::unordered_map<am_converterID_t, AmConverter> 			 	 	 AmMapConverter;
+    typedef std::unordered_map<am_crossfaderID_t, AmCrossfader> 		    	 AmMapCrossfader;
+    typedef std::unordered_map<am_connectionID_t, AmConnection>				 	 AmMapConnection;
+    typedef std::unordered_map<am_mainConnectionID_t, AmMainConnection> 	 	 AmMapMainConnection;
+    typedef std::vector<am_SystemProperty_s> 	   				  			     AmVectorSystemProperties;
     /**
      * The following structure groups the map objects needed for the implementation.
      * Every map object is coupled with an identifier, which hold the current value.
@@ -332,46 +381,46 @@ public:
      * The IDs can be increased through the method increaseID(...), which follows the AudioManager logic.
      * For more information about the static and dynamic IDs, please see the documentation.
      */
-    typedef struct CAmMappedData
+    struct AmMappedData
     {
         /**
          * The structure encapsulates the id boundary and the current id value.
          * It defines a range within the id can vary.
          */
-    	struct am_Identifier_s
+    	struct AmIdentifier
     	{
     		int16_t mMin;			//!< min possible value
     		int16_t mMax;			//!< max possible value
     		int16_t mCurrentValue;	//!< current value
 
-    		am_Identifier_s():mMin(DYNAMIC_ID_BOUNDARY), mMax(SHRT_MAX), mCurrentValue(mMin){};
-    		am_Identifier_s(const int16_t & min, const int16_t &  max):mMin(min), mMax(max), mCurrentValue(mMin){assert(min<max);};
+    		AmIdentifier():mMin(DYNAMIC_ID_BOUNDARY), mMax(SHRT_MAX), mCurrentValue(mMin){};
+    		AmIdentifier(const int16_t & min, const int16_t &  max):mMin(min), mMax(max), mCurrentValue(mMin){assert(min<max);};
     	};
 
-    	am_Identifier_s mCurrentDomainID;			//!< domain ID
-    	am_Identifier_s mCurrentSourceClassesID;	//!< source classes ID
-    	am_Identifier_s mCurrentSinkClassesID;		//!< sink classes ID
-    	am_Identifier_s mCurrentSinkID;				//!< sink ID
-    	am_Identifier_s mCurrentSourceID;			//!< source ID
-    	am_Identifier_s mCurrentGatewayID;			//!< gateway ID
-    	am_Identifier_s mCurrentConverterID;		//!< converter ID
-    	am_Identifier_s mCurrentCrossfaderID;		//!< crossfader ID
-    	am_Identifier_s mCurrentConnectionID;		//!< connection ID
-    	am_Identifier_s mCurrentMainConnectionID;	//!< mainconnection ID
-
-    	CAmVectorSystemProperties mSystemProperties; //!< vector with system properties
-    	CAmMapDomain mDomainMap;					 //!< map for domain structures
-    	CAmMapSourceClass mSourceClassesMap;		 //!< map for source classes structures
-    	CAmMapSinkClass mSinkClassesMap;			 //!< map for sink classes structures
-    	CAmMapSink mSinkMap;						 //!< map for sink structures
-    	CAmMapSource mSourceMap;					 //!< map for source structures
-    	CAmMapGateway mGatewayMap;					 //!< map for gateway structures
-    	CAmMapConverter mConverterMap;				 //!< map for converter structures
-    	CAmMapCrossfader mCrossfaderMap;			 //!< map for crossfader structures
-    	CAmMapConnection mConnectionMap;			 //!< map for connection structures
-    	CAmMapMainConnection mMainConnectionMap;	 //!< map for main connection structures
-
-    	CAmMappedData(): //For Domain, MainConnections, Connections we don't have static IDs.
+    	AmIdentifier mCurrentDomainID;			//!< domain ID
+    	AmIdentifier mCurrentSourceClassesID;	//!< source classes ID
+    	AmIdentifier mCurrentSinkClassesID;		//!< sink classes ID
+    	AmIdentifier mCurrentSinkID;				//!< sink ID
+    	AmIdentifier mCurrentSourceID;			//!< source ID
+    	AmIdentifier mCurrentGatewayID;			//!< gateway ID
+    	AmIdentifier mCurrentConverterID;		//!< converter ID
+    	AmIdentifier mCurrentCrossfaderID;		//!< crossfader ID
+    	AmIdentifier mCurrentConnectionID;		//!< connection ID
+    	AmIdentifier mCurrentMainConnectionID;	//!< mainconnection ID
+
+    	AmVectorSystemProperties mSystemProperties; //!< vector with system properties
+    	AmMapDomain mDomainMap;					 //!< map for domain structures
+    	AmMapSourceClass mSourceClassesMap;		 //!< map for source classes structures
+    	AmMapSinkClass mSinkClassesMap;			 //!< map for sink classes structures
+    	AmMapSink mSinkMap;						 //!< map for sink structures
+    	AmMapSource mSourceMap;					 //!< map for source structures
+    	AmMapGateway mGatewayMap;					 //!< map for gateway structures
+    	AmMapConverter mConverterMap;				 //!< map for converter structures
+    	AmMapCrossfader mCrossfaderMap;			 //!< map for crossfader structures
+    	AmMapConnection mConnectionMap;			 //!< map for connection structures
+    	AmMapMainConnection mMainConnectionMap;	 //!< map for main connection structures
+
+    	AmMappedData(): //For Domain, MainConnections, Connections we don't have static IDs.
     		mCurrentDomainID(DYNAMIC_ID_BOUNDARY, SHRT_MAX),
     		mCurrentSourceClassesID(DYNAMIC_ID_BOUNDARY, SHRT_MAX),
     		mCurrentSinkClassesID(DYNAMIC_ID_BOUNDARY, SHRT_MAX),
@@ -399,7 +448,7 @@ public:
     	 * @param preferedStaticIDBoundary A limit for a given dynamic ID. Default is DYNAMIC_ID_BOUNDARY.
     	 * @return TRUE on successfully changed ID.
     	 */
-    	bool increaseID(int16_t & resultID, am_Identifier_s & sourceID, int16_t const desiredStaticID);
+    	bool increaseID(int16_t & resultID, AmIdentifier & sourceID, int16_t const desiredStaticID);
       	/**
 		 * \brief Increases the main connection ID.
 		 *
@@ -426,12 +475,13 @@ public:
         {
         	typename std::unordered_map<TPrintMapKey, TPrintMapObject>::const_iterator iter = t.begin();
         	for(; iter!=t.end(); iter++)
-        		CAmMappedData::print(iter->second, output);
+        		AmMappedData::print(iter->second, output);
         }
     private:
-        template <typename TMapKey,class TMapObject> bool getNextConnectionID(int16_t & resultID, am_Identifier_s & sourceID,
+        template <typename TMapKey,class TMapObject> bool getNextConnectionID(int16_t & resultID, AmIdentifier & sourceID,
         																			  const std::unordered_map<TMapKey, TMapObject> & map);
-    } CAmMappedData;
+    };
+
     /*
      * Helper methods.
      */
@@ -469,9 +519,9 @@ public:
 			} );
 	}
 
-    CAmDatabaseObserver *mpDatabaseObserver; //!< pointer to the Observer
     ListConnectionFormat mListConnectionFormat; //!< list of connection formats
-    CAmMappedData mMappedData; //!< Internal structure encapsulating all the maps used in this class
+    AmMappedData mMappedData; //!< Internal structure encapsulating all the maps used in this class
+    std::vector<AmDatabaseObserverCallbacks*> mDatabaseObservers;
 
 #ifdef UNIT_TEST
     public:
diff --git a/AudioManagerCore/include/CAmDatabaseObserver.h b/AudioManagerCore/include/CAmDatabaseObserver.h
deleted file mode 100644
index 7d18be4..0000000
--- a/AudioManagerCore/include/CAmDatabaseObserver.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/**
- * SPDX license identifier: MPL-2.0
- *
- * Copyright (C) 2012, BMW AG
- *
- * This file is part of GENIVI Project AudioManager.
- *
- * Contributions are licensed to the GENIVI Alliance under one or more
- * Contribution License Agreements.
- *
- * \copyright
- * This Source Code Form is subject to the terms of the
- * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
- * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- *
- * \author Christian Linke, christian.linke@bmw.de BMW 2011,2012
- *
- * \file CAmDatabaseObserver.h
- * For further information see http://www.genivi.org/.
- *
- */
-
-#ifndef DATABASEOBSERVER_H_
-#define DATABASEOBSERVER_H_
-
-#include "audiomanagertypes.h"
-#include <queue>
-#include "CAmSerializer.h"
-
-namespace am
-{
-
-class CAmTelnetServer;
-class CAmCommandSender;
-class CAmRoutingSender;
-class CAmSocketHandler;
-
-/**
- * This class observes the Database and notifies other classes about important events, mainly the CommandSender.
- */
-class CAmDatabaseObserver
-{
-public:
-    CAmDatabaseObserver(CAmCommandSender *iCommandSender, CAmRoutingSender *iRoutingSender, CAmSocketHandler *iSocketHandler);
-    CAmDatabaseObserver(CAmCommandSender *iCommandSender, CAmRoutingSender *iRoutingSender, CAmSocketHandler *iSocketHandler, CAmTelnetServer *iTelnetServer);
-    ~CAmDatabaseObserver();
-    void numberOfSinkClassesChanged();
-    void numberOfSourceClassesChanged();
-    void newSink(const am_Sink_s& sink);
-    void newSource(const am_Source_s& source);
-    void newDomain(const am_Domain_s& domain);
-    void newGateway(const am_Gateway_s& gateway);
-    void newConverter(const am_Converter_s& coverter);
-    void newCrossfader(const am_Crossfader_s& crossfader);
-    void newMainConnection(const am_MainConnectionType_s& mainConnection);
-    void removedMainConnection(const am_mainConnectionID_t mainConnection);
-    void removedSink(const am_sinkID_t sinkID, const bool visible);
-    void removedSource(const am_sourceID_t sourceID, const bool visible);
-    void removeDomain(const am_domainID_t domainID);
-    void removeGateway(const am_gatewayID_t gatewayID);
-    void removeConverter(const am_converterID_t converterID);
-    void removeCrossfader(const am_crossfaderID_t crossfaderID);
-    void mainConnectionStateChanged(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState);
-    void mainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty);
-    void mainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s& SoundProperty);
-    void sinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s& availability);
-    void sourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s& availability);
-    void volumeChanged(const am_sinkID_t sinkID, const am_mainVolume_t volume);
-    void sinkMuteStateChanged(const am_sinkID_t sinkID, const am_MuteState_e muteState);
-    void systemPropertyChanged(const am_SystemProperty_s& SystemProperty);
-    void timingInformationChanged(const am_mainConnectionID_t mainConnection, const am_timeSync_t time);
-    void sinkUpdated(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties, const bool visible);
-    void sourceUpdated(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties, const bool visible);
-    void sinkMainNotificationConfigurationChanged(const am_sinkID_t sinkID, const am_NotificationConfiguration_s mainNotificationConfiguration);
-    void sourceMainNotificationConfigurationChanged(const am_sourceID_t sourceID, const am_NotificationConfiguration_s mainNotificationConfiguration);
-
-private:
-    CAmCommandSender *mCommandSender; //!< pointer to the comandSender
-    CAmRoutingSender* mRoutingSender; //!< pointer to the routingSender
-    CAmTelnetServer* mTelnetServer; //!< pointer to the telnetserver
-    CAmSerializer mSerializer; //!< serializer to handle the CommandInterface via the mainloop
-};
-
-}
-
-#endif /* DATABASEOBSERVER_H_ */
diff --git a/AudioManagerCore/include/CAmRouter.h b/AudioManagerCore/include/CAmRouter.h
index 1242824..7543abc 100644
--- a/AudioManagerCore/include/CAmRouter.h
+++ b/AudioManagerCore/include/CAmRouter.h
@@ -31,7 +31,7 @@
 #include <functional>
 #include "audiomanagertypes.h"
 #include "CAmGraph.h"
-#include "IAmDatabaseHandler.h"
+#include "CAmDatabaseHandlerMap.h"
 
 
 namespace am
@@ -151,7 +151,7 @@ class CAmControlSender;
 /**
  * Implements an autorouting algorithm for connecting sinks and sources via different audio domains.
  */
-class CAmRouter
+class CAmRouter: public CAmDatabaseHandlerMap::AmDatabaseObserverCallbacks
 {
 	IAmDatabaseHandler* mpDatabaseHandler; 									 //!< pointer to database handler
 	CAmControlSender* mpControlSender; 										 //!< pointer the controlsender - is used to retrieve information for the optimal route
@@ -281,7 +281,7 @@ public:
 
 	/**
 	 * Find the shortest path between given source and sink. This method should be called only after 'load' has been called.
-	 * This method do not pay attention on the parameter mMaxAllowedCycles and go through all possible paths.
+	 * This method do not pay attention on the parameter mMaxAllowedCycles and goes through all possible paths.
 	 *
 	 * @param source start point.
 	 * @param sink end point.
diff --git a/AudioManagerCore/include/CAmRoutingSender.h b/AudioManagerCore/include/CAmRoutingSender.h
index 8804d90..8d8a063 100644
--- a/AudioManagerCore/include/CAmRoutingSender.h
+++ b/AudioManagerCore/include/CAmRoutingSender.h
@@ -32,16 +32,17 @@
 #include "../test/IAmRoutingBackdoor.h"
 #endif
 
+#include "CAmDatabaseHandlerMap.h"
+
 namespace am
 {
 
 class CAmRoutingReceiver;
-class IAmDatabaseHandler;
 
 /**
  * Implements the RoutingSendInterface. Loads all plugins and dispatches calls to the plugins
  */
-class CAmRoutingSender
+class CAmRoutingSender: public CAmDatabaseHandlerMap::AmDatabaseObserverCallbacks
 {
 public:
     CAmRoutingSender(const std::vector<std::string>& listOfPluginDirectories, IAmDatabaseHandler* databaseHandler);
diff --git a/AudioManagerCore/include/IAmDatabaseHandler.h b/AudioManagerCore/include/IAmDatabaseHandler.h
index aa275db..f4fe8a1 100644
--- a/AudioManagerCore/include/IAmDatabaseHandler.h
+++ b/AudioManagerCore/include/IAmDatabaseHandler.h
@@ -30,18 +30,14 @@
 #include <string>
 #include <iostream>
 #include <functional>
+#include <memory>
+#include <assert.h>
+#include <algorithm>
 #include "audiomanagerconfig.h"
 
 namespace am
 {
 
-class CAmDatabaseObserver;
-class CAmRoutingTree;
-class CAmRoutingTreeItem;
-
-
-//enum { DYNAMIC_ID_BOUNDARY = 100 }; //!< the value below is reserved for staticIDs, the value above will be assigned to dynamically registered items
-
 //todo: check the enum values before entering & changing in the database.
 //todo: change asserts for dynamic boundary checks into failure answers.#
 //todo: check autoincrement boundary and set to 16bit limits
@@ -59,8 +55,12 @@ typedef std::map<am_gatewayID_t, std::vector<bool> > ListConnectionFormat; //!<
 class IAmDatabaseHandler
 {
 public:
-	IAmDatabaseHandler () {};
-	virtual ~IAmDatabaseHandler () {};
+    IAmDatabaseHandler (){}
+    virtual ~IAmDatabaseHandler (){}
+
+    /**
+      * The following interface methods must be implemented by the subclass.
+      */
     virtual am_Error_e enterDomainDB(const am_Domain_s& domainData, am_domainID_t& domainID) = 0;
     virtual am_Error_e enterMainConnectionDB(const am_MainConnection_s& mainConnectionData, am_mainConnectionID_t& connectionID) = 0;
     virtual am_Error_e enterSinkDB(const am_Sink_s& sinkData, am_sinkID_t& sinkID) = 0;
@@ -117,7 +117,7 @@ public:
     virtual am_Error_e getSourceVolume(const am_sourceID_t sourceID, am_volume_t& volume) const = 0;
     virtual am_Error_e getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomSoundPropertyType_t propertyType, int16_t& value) const = 0;
     virtual am_Error_e getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomSoundPropertyType_t propertyType, int16_t& value) const = 0;
-	virtual am_Error_e getListSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_SoundProperty_s>& listSoundproperties) const =0;
+    virtual am_Error_e getListSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_SoundProperty_s>& listSoundproperties) const =0;
     virtual am_Error_e getListSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_SoundProperty_s>& listSoundproperties) const =0;
     virtual am_Error_e getMainSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomMainSoundPropertyType_t propertyType, int16_t& value) const = 0;
     virtual am_Error_e getMainSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomMainSoundPropertyType_t propertyType, int16_t& value) const = 0;
@@ -166,7 +166,6 @@ public:
     virtual am_Error_e changeConverterDB(const am_converterID_t converterID, const std::vector<am_CustomConnectionFormat_t>& listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t>& listSinkConnectionFormats, const std::vector<bool>& convertionMatrix) = 0;
     virtual am_Error_e changeSinkNotificationConfigurationDB(const am_sinkID_t sinkID,const am_NotificationConfiguration_s notificationConfiguration) = 0;
     virtual am_Error_e changeSourceNotificationConfigurationDB(const am_sourceID_t sourceID,const am_NotificationConfiguration_s notificationConfiguration) = 0;
-
     virtual bool existMainConnection(const am_mainConnectionID_t mainConnectionID) const = 0;
     virtual bool existCrossFader(const am_crossfaderID_t crossfaderID) const = 0;
     virtual bool existConnection(const am_Connection_s & connection) const = 0;
@@ -181,7 +180,6 @@ public:
     virtual bool existGateway(const am_gatewayID_t gatewayID) const = 0;
     virtual bool existSinkClass(const am_sinkClass_t sinkClassID) const = 0;
     virtual bool existSourceClass(const am_sourceClass_t sourceClassID) const = 0;
-    virtual void registerObserver(CAmDatabaseObserver *iObserver) = 0;
     virtual bool sourceVisible(const am_sourceID_t sourceID) const = 0;
     virtual bool sinkVisible(const am_sinkID_t sinkID) const = 0;
     virtual bool isComponentConnected(const am_Gateway_s & gateway) const = 0;
@@ -192,7 +190,19 @@ public:
     virtual am_Error_e enumerateSinks(std::function<void(const am_Sink_s & element)> cb) const = 0 ;
     virtual am_Error_e enumerateGateways(std::function<void(const am_Gateway_s & element)> cb) const = 0 ;
     virtual am_Error_e enumerateConverters(std::function<void(const am_Converter_s & element)> cb) const = 0 ;
+    /**
+      * Database observer protocol
+      */
+    class IAmDatabaseObserver
+    {
+    public:
+      IAmDatabaseObserver() {}
+      virtual ~IAmDatabaseObserver(){}
+    };
 
+    virtual bool registerObserver(IAmDatabaseObserver * iObserver) = 0;
+    virtual bool unregisterObserver(IAmDatabaseObserver * iObserver) = 0;
+    virtual unsigned countObservers()  = 0;
 };