capicxx-dbus-runtime 3.1.12.13.1.12.1

12 files changed, 153 insertions, 627 deletions

diff --git a/.cproject b/.cproject
deleted file mode 100644
index df73099..0000000
--- a/.cproject
+++ /dev/null
@@ -1,152 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<?fileVersion 4.0.0?><cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage">
-	<storageModule moduleId="org.eclipse.cdt.core.settings">
-		<cconfiguration id="cdt.managedbuild.config.gnu.so.debug.1859452810">
-			<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="cdt.managedbuild.config.gnu.so.debug.1859452810" moduleId="org.eclipse.cdt.core.settings" name="Debug">
-				<externalSettings>
-					<externalSetting>
-						<entry flags="VALUE_WORKSPACE_PATH" kind="includePath" name="/CommonAPI-D-Bus"/>
-						<entry flags="VALUE_WORKSPACE_PATH" kind="libraryPath" name="/CommonAPI-D-Bus/Debug"/>
-						<entry flags="RESOLVED" kind="libraryFile" name="CommonAPI-D-Bus" srcPrefixMapping="" srcRootPath=""/>
-					</externalSetting>
-				</externalSettings>
-				<extensions>
-					<extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
-					<extension id="org.eclipse.cdt.core.CWDLocator" point="org.eclipse.cdt.core.ErrorParser"/>
-					<extension id="org.eclipse.cdt.core.GCCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
-					<extension id="org.eclipse.cdt.core.GASErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
-					<extension id="org.eclipse.cdt.core.GLDErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
-					<extension id="org.eclipse.cdt.core.ELF" point="org.eclipse.cdt.core.BinaryParser"/>
-				</extensions>
-			</storageModule>
-			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
-				<configuration artifactExtension="so" artifactName="${ProjName}" buildArtefactType="org.eclipse.cdt.build.core.buildArtefactType.sharedLib" buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug,org.eclipse.cdt.build.core.buildArtefactType=org.eclipse.cdt.build.core.buildArtefactType.sharedLib" cleanCommand="rm -rf" description="" id="cdt.managedbuild.config.gnu.so.debug.1859452810" name="Debug" parent="cdt.managedbuild.config.gnu.so.debug">
-					<folderInfo id="cdt.managedbuild.config.gnu.so.debug.1859452810." name="/" resourcePath="">
-						<toolChain id="cdt.managedbuild.toolchain.gnu.so.debug.6905674" name="Linux GCC" superClass="cdt.managedbuild.toolchain.gnu.so.debug">
-							<targetPlatform id="cdt.managedbuild.target.gnu.platform.so.debug.1947112604" name="Debug Platform" superClass="cdt.managedbuild.target.gnu.platform.so.debug"/>
-							<builder arguments="-C ${ProjDirPath}/build VERBOSE=1" buildPath="${workspace_loc:/ascgit017.CommonAPI-D-Bus}" command="make" id="cdt.managedbuild.target.gnu.builder.so.debug.216703021" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" superClass="cdt.managedbuild.target.gnu.builder.so.debug"/>
-							<tool id="cdt.managedbuild.tool.gnu.archiver.base.1612988189" name="GCC Archiver" superClass="cdt.managedbuild.tool.gnu.archiver.base"/>
-							<tool id="cdt.managedbuild.tool.gnu.cpp.compiler.so.debug.1642217911" name="GCC C++ Compiler" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.so.debug">
-								<option id="gnu.cpp.compiler.so.debug.option.optimization.level.1985215238" name="Optimization Level" superClass="gnu.cpp.compiler.so.debug.option.optimization.level" useByScannerDiscovery="false" value="gnu.cpp.compiler.optimization.level.none" valueType="enumerated"/>
-								<option id="gnu.cpp.compiler.so.debug.option.debugging.level.1179045778" name="Debug Level" superClass="gnu.cpp.compiler.so.debug.option.debugging.level" useByScannerDiscovery="false" value="gnu.cpp.compiler.debugging.level.max" valueType="enumerated"/>
-								<inputType id="cdt.managedbuild.tool.gnu.cpp.compiler.input.707478912" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.input"/>
-							</tool>
-							<tool id="cdt.managedbuild.tool.gnu.c.compiler.so.debug.1813739474" name="GCC C Compiler" superClass="cdt.managedbuild.tool.gnu.c.compiler.so.debug">
-								<option defaultValue="gnu.c.optimization.level.none" id="gnu.c.compiler.so.debug.option.optimization.level.296806273" name="Optimization Level" superClass="gnu.c.compiler.so.debug.option.optimization.level" useByScannerDiscovery="false" valueType="enumerated"/>
-								<option id="gnu.c.compiler.so.debug.option.debugging.level.2078130775" name="Debug Level" superClass="gnu.c.compiler.so.debug.option.debugging.level" useByScannerDiscovery="false" value="gnu.c.debugging.level.max" valueType="enumerated"/>
-								<inputType id="cdt.managedbuild.tool.gnu.c.compiler.input.339439894" superClass="cdt.managedbuild.tool.gnu.c.compiler.input"/>
-							</tool>
-							<tool id="cdt.managedbuild.tool.gnu.c.linker.so.debug.2108497925" name="GCC C Linker" superClass="cdt.managedbuild.tool.gnu.c.linker.so.debug">
-								<option defaultValue="true" id="gnu.c.link.so.debug.option.shared.351054059" name="Shared (-shared)" superClass="gnu.c.link.so.debug.option.shared" valueType="boolean"/>
-							</tool>
-							<tool id="cdt.managedbuild.tool.gnu.cpp.linker.so.debug.899448754" name="GCC C++ Linker" superClass="cdt.managedbuild.tool.gnu.cpp.linker.so.debug">
-								<option defaultValue="true" id="gnu.cpp.link.so.debug.option.shared.1332463754" name="Shared (-shared)" superClass="gnu.cpp.link.so.debug.option.shared" valueType="boolean"/>
-								<inputType id="cdt.managedbuild.tool.gnu.cpp.linker.input.609192959" superClass="cdt.managedbuild.tool.gnu.cpp.linker.input">
-									<additionalInput kind="additionalinputdependency" paths="$(USER_OBJS)"/>
-									<additionalInput kind="additionalinput" paths="$(LIBS)"/>
-								</inputType>
-							</tool>
-							<tool id="cdt.managedbuild.tool.gnu.assembler.so.debug.1733809661" name="GCC Assembler" superClass="cdt.managedbuild.tool.gnu.assembler.so.debug">
-								<inputType id="cdt.managedbuild.tool.gnu.assembler.input.2132354807" superClass="cdt.managedbuild.tool.gnu.assembler.input"/>
-							</tool>
-						</toolChain>
-					</folderInfo>
-				</configuration>
-			</storageModule>
-			<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
-		</cconfiguration>
-		<cconfiguration id="cdt.managedbuild.config.gnu.so.release.1276040933">
-			<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="cdt.managedbuild.config.gnu.so.release.1276040933" moduleId="org.eclipse.cdt.core.settings" name="Release">
-				<externalSettings>
-					<externalSetting>
-						<entry flags="VALUE_WORKSPACE_PATH" kind="includePath" name="/CommonAPI-D-Bus"/>
-						<entry flags="VALUE_WORKSPACE_PATH" kind="libraryPath" name="/CommonAPI-D-Bus/Release"/>
-						<entry flags="RESOLVED" kind="libraryFile" name="CommonAPI-D-Bus" srcPrefixMapping="" srcRootPath=""/>
-					</externalSetting>
-				</externalSettings>
-				<extensions>
-					<extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
-					<extension id="org.eclipse.cdt.core.CWDLocator" point="org.eclipse.cdt.core.ErrorParser"/>
-					<extension id="org.eclipse.cdt.core.GCCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
-					<extension id="org.eclipse.cdt.core.GASErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
-					<extension id="org.eclipse.cdt.core.GLDErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
-					<extension id="org.eclipse.cdt.core.ELF" point="org.eclipse.cdt.core.BinaryParser"/>
-				</extensions>
-			</storageModule>
-			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
-				<configuration artifactExtension="so" artifactName="${ProjName}" buildArtefactType="org.eclipse.cdt.build.core.buildArtefactType.sharedLib" buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release,org.eclipse.cdt.build.core.buildArtefactType=org.eclipse.cdt.build.core.buildArtefactType.sharedLib" cleanCommand="rm -rf" description="" id="cdt.managedbuild.config.gnu.so.release.1276040933" name="Release" parent="cdt.managedbuild.config.gnu.so.release">
-					<folderInfo id="cdt.managedbuild.config.gnu.so.release.1276040933." name="/" resourcePath="">
-						<toolChain id="cdt.managedbuild.toolchain.gnu.so.release.473555736" name="Linux GCC" superClass="cdt.managedbuild.toolchain.gnu.so.release">
-							<targetPlatform id="cdt.managedbuild.target.gnu.platform.so.release.913197338" name="Debug Platform" superClass="cdt.managedbuild.target.gnu.platform.so.release"/>
-							<builder buildPath="${workspace_loc:/ascgit017.CommonAPI-D-Bus}/Release" id="cdt.managedbuild.target.gnu.builder.so.release.1120719007" keepEnvironmentInBuildfile="false" managedBuildOn="true" name="Gnu Make Builder" superClass="cdt.managedbuild.target.gnu.builder.so.release"/>
-							<tool id="cdt.managedbuild.tool.gnu.archiver.base.13478497" name="GCC Archiver" superClass="cdt.managedbuild.tool.gnu.archiver.base"/>
-							<tool id="cdt.managedbuild.tool.gnu.cpp.compiler.so.release.184956043" name="GCC C++ Compiler" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.so.release">
-								<option id="gnu.cpp.compiler.so.release.option.optimization.level.226311448" name="Optimization Level" superClass="gnu.cpp.compiler.so.release.option.optimization.level" value="gnu.cpp.compiler.optimization.level.most" valueType="enumerated"/>
-								<option id="gnu.cpp.compiler.so.release.option.debugging.level.2024947288" name="Debug Level" superClass="gnu.cpp.compiler.so.release.option.debugging.level" value="gnu.cpp.compiler.debugging.level.none" valueType="enumerated"/>
-								<inputType id="cdt.managedbuild.tool.gnu.cpp.compiler.input.1309040493" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.input"/>
-							</tool>
-							<tool id="cdt.managedbuild.tool.gnu.c.compiler.so.release.1370355040" name="GCC C Compiler" superClass="cdt.managedbuild.tool.gnu.c.compiler.so.release">
-								<option defaultValue="gnu.c.optimization.level.most" id="gnu.c.compiler.so.release.option.optimization.level.1785693532" name="Optimization Level" superClass="gnu.c.compiler.so.release.option.optimization.level" valueType="enumerated"/>
-								<option id="gnu.c.compiler.so.release.option.debugging.level.826432118" name="Debug Level" superClass="gnu.c.compiler.so.release.option.debugging.level" value="gnu.c.debugging.level.none" valueType="enumerated"/>
-								<inputType id="cdt.managedbuild.tool.gnu.c.compiler.input.309528651" superClass="cdt.managedbuild.tool.gnu.c.compiler.input"/>
-							</tool>
-							<tool id="cdt.managedbuild.tool.gnu.c.linker.so.release.250098446" name="GCC C Linker" superClass="cdt.managedbuild.tool.gnu.c.linker.so.release">
-								<option defaultValue="true" id="gnu.c.link.so.release.option.shared.438760097" name="Shared (-shared)" superClass="gnu.c.link.so.release.option.shared" valueType="boolean"/>
-							</tool>
-							<tool id="cdt.managedbuild.tool.gnu.cpp.linker.so.release.351648733" name="GCC C++ Linker" superClass="cdt.managedbuild.tool.gnu.cpp.linker.so.release">
-								<option defaultValue="true" id="gnu.cpp.link.so.release.option.shared.557352195" name="Shared (-shared)" superClass="gnu.cpp.link.so.release.option.shared" valueType="boolean"/>
-								<inputType id="cdt.managedbuild.tool.gnu.cpp.linker.input.720953433" superClass="cdt.managedbuild.tool.gnu.cpp.linker.input">
-									<additionalInput kind="additionalinputdependency" paths="$(USER_OBJS)"/>
-									<additionalInput kind="additionalinput" paths="$(LIBS)"/>
-								</inputType>
-							</tool>
-							<tool id="cdt.managedbuild.tool.gnu.assembler.so.release.156898238" name="GCC Assembler" superClass="cdt.managedbuild.tool.gnu.assembler.so.release">
-								<inputType id="cdt.managedbuild.tool.gnu.assembler.input.634438968" superClass="cdt.managedbuild.tool.gnu.assembler.input"/>
-							</tool>
-						</toolChain>
-					</folderInfo>
-				</configuration>
-			</storageModule>
-			<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
-		</cconfiguration>
-	</storageModule>
-	<storageModule moduleId="cdtBuildSystem" version="4.0.0">
-		<project id="ascgit017.CommonAPI-D-Bus.cdt.managedbuild.target.gnu.so.602020624" name="Shared Library" projectType="cdt.managedbuild.target.gnu.so"/>
-	</storageModule>
-	<storageModule moduleId="scannerConfiguration">
-		<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
-		<scannerConfigBuildInfo instanceId="cdt.managedbuild.config.gnu.so.release.1276040933;cdt.managedbuild.config.gnu.so.release.1276040933.;cdt.managedbuild.tool.gnu.cpp.compiler.so.release.184956043;cdt.managedbuild.tool.gnu.cpp.compiler.input.1309040493">
-			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
-		</scannerConfigBuildInfo>
-		<scannerConfigBuildInfo instanceId="cdt.managedbuild.config.gnu.so.release.1276040933;cdt.managedbuild.config.gnu.so.release.1276040933.;cdt.managedbuild.tool.gnu.c.compiler.so.release.1370355040;cdt.managedbuild.tool.gnu.c.compiler.input.309528651">
-			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
-		</scannerConfigBuildInfo>
-		<scannerConfigBuildInfo instanceId="cdt.managedbuild.config.gnu.so.debug.1859452810;cdt.managedbuild.config.gnu.so.debug.1859452810.;cdt.managedbuild.tool.gnu.cpp.compiler.so.debug.1642217911;cdt.managedbuild.tool.gnu.cpp.compiler.input.707478912">
-			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
-		</scannerConfigBuildInfo>
-		<scannerConfigBuildInfo instanceId="cdt.managedbuild.config.gnu.so.debug.1859452810;cdt.managedbuild.config.gnu.so.debug.1859452810.;cdt.managedbuild.tool.gnu.c.compiler.so.debug.1813739474;cdt.managedbuild.tool.gnu.c.compiler.input.339439894">
-			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
-		</scannerConfigBuildInfo>
-	</storageModule>
-	<storageModule moduleId="org.eclipse.cdt.core.LanguageSettingsProviders"/>
-	<storageModule moduleId="refreshScope" versionNumber="2">
-		<configuration configurationName="Release">
-			<resource resourceType="PROJECT" workspacePath="/ascgit017.CommonAPI-D-Bus"/>
-		</configuration>
-		<configuration configurationName="Debug">
-			<resource resourceType="PROJECT" workspacePath="/ascgit017.CommonAPI-D-Bus"/>
-		</configuration>
-	</storageModule>
-	<storageModule moduleId="org.eclipse.cdt.make.core.buildtargets">
-		<buildTargets>
-			<target name="Run cmake" path="" targetID="org.eclipse.cdt.build.MakeTargetBuilder">
-				<buildCommand>cmake</buildCommand>
-				<buildArguments>-E chdir build/ cmake -G "Unix Makefiles" -D CMAKE_BUILD_TYPE=debug -D USE_INSTALLED_COMMONAPI=OFF ../</buildArguments>
-				<buildTarget/>
-				<stopOnError>true</stopOnError>
-				<useDefaultCommand>false</useDefaultCommand>
-				<runAllBuilders>true</runAllBuilders>
-			</target>
-		</buildTargets>
-	</storageModule>
-</cproject>
diff --git a/.gitattributes b/.gitattributes
deleted file mode 100644
index deacb5b..0000000
--- a/.gitattributes
+++ /dev/null
@@ -1,44 +0,0 @@
-# set default behaviour, in case users don't have core.autocrlf set.
-* text=auto
-
-# Explicitly declare text files we want to always be normalized and converted 
-# to native line endings on checkout.
-*.am text
-*.ac text
-*.m4 text
-*.in text
-
-*.c text
-*.cpp text
-*.h text
-*.hpp text
-
-*.fidl text
-*.java text
-*.xtend text
-
-*.html text
-*.xml text
-
-*.properties text
-
-*.patch text
-
-AUTHORS text
-LICENSE* text
-README text
-
-# Eclipse
-.autotools text
-.cproject text
-.project text
-org.eclipse.core.resources.prefs text
-*.MF text
-
-# Declare files that will always have CRLF line endings on checkout.
-*.sln binary
-*.vcxproj binary
-
-# Denote all files that are truly binary and should not be modified.
-*.png binary
-*.jpg binary
diff --git a/.gitignore b/.gitignore
deleted file mode 100644
index 4720f25..0000000
--- a/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-/build/*
-.settings/*
diff --git a/.project b/.project
deleted file mode 100644
index 3a8657b..0000000
--- a/.project
+++ /dev/null
@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>CommonAPI-D-Bus</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
-			<triggers>clean,full,incremental,</triggers>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
-			<triggers>full,incremental,</triggers>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.cdt.core.cnature</nature>
-		<nature>org.eclipse.cdt.core.ccnature</nature>
-		<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
-		<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
-		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
-	</natures>
-</projectDescription>
diff --git a/CHANGES b/CHANGES
index d945e65..3dde05f 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,5 +1,10 @@
 Changes
 =======
+v3.1.12.1
+- Fixed race condition for managed services. When a managed services was removed, an appropriate
+availability status changed event was received (service became unavailable) and afterwards a 'getAvailablStatusAsync' call for the removed service instance was done, the response could be that
+the service instance is still available.
+
 v3.1.12
 - Support DBus type DBUS_TYPE_UNIX_FD as deployment for ints
 - DBus deployment: IsObjectPath for all string locations
diff --git a/include/CommonAPI/DBus/DBusConnection.hpp b/include/CommonAPI/DBus/DBusConnection.hpp
index b5c75dd..87264f1 100644
--- a/include/CommonAPI/DBus/DBusConnection.hpp
+++ b/include/CommonAPI/DBus/DBusConnection.hpp
@@ -321,8 +321,6 @@ public:
 
     void deleteAsyncHandlers();
 
-    uint32_t getNumberOfSignalMemberHandlers(DBusSignalHandlerPath handlerPath);
-
     ::DBusConnection* connection_;
     mutable std::recursive_mutex connectionGuard_;
 
@@ -340,16 +338,12 @@ public:
     DBusSignalMatchRulesMap dbusSignalMatchRulesMap_;
 
     DBusSignalHandlerTable dbusSignalHandlers_;
-    DBusSignalHandlerTable dbusSignalHandlersToAdd_;
-    DBusSignalHandlerTable dbusSignalHandlersToRemove_;
 
     std::mutex dbusOMSignalHandlersGuard_;
 
     DBusOMSignalMatchRulesMap dbusOMSignalMatchRulesMap_;
 
     DBusOMSignalHandlerTable dbusOMSignalHandlers_;
-    DBusOMSignalHandlerTable dbusOMSignalHandlersToAdd_;
-    DBusOMSignalHandlerTable dbusOMSignalHandlersToRemove_;
 
     COMMONAPI_EXPORT bool addObjectManagerSignalMatchRule(const std::string& dbusBusName);
     COMMONAPI_EXPORT bool removeObjectManagerSignalMatchRule(const std::string& dbusBusName);
diff --git a/include/CommonAPI/DBus/DBusProxy.hpp b/include/CommonAPI/DBus/DBusProxy.hpp
index f40c4d8..403ce21 100644
--- a/include/CommonAPI/DBus/DBusProxy.hpp
+++ b/include/CommonAPI/DBus/DBusProxy.hpp
@@ -65,7 +65,7 @@ public:
               const std::string& interfaceMemberName,
               const std::string& interfaceMemberSignature,
               std::weak_ptr<DBusProxyConnection::DBusSignalHandler> dbusSignalHandler,
-			  uint32_t tag);
+              uint32_t tag);
 
     COMMONAPI_EXPORT void insertSelectiveSubscription(
             const std::string& interfaceMemberName,
diff --git a/include/CommonAPI/DBus/DBusProxyHelper.hpp b/include/CommonAPI/DBus/DBusProxyHelper.hpp
index 7113d9d..2337fab 100644
--- a/include/CommonAPI/DBus/DBusProxyHelper.hpp
+++ b/include/CommonAPI/DBus/DBusProxyHelper.hpp
@@ -217,7 +217,7 @@ struct DBusProxyHelper<In_<DBusInputStream, DBusOutputStream, InArgs_...>,
             COMMONAPI_VERBOSE("MethodAsync(dbus): Proxy available -> sendMessageWithReplyAsync");
                 return callStatusFuture;
             } else {
-            	return std::future<CallStatus>();
+                return std::future<CallStatus>();
             }
         } else {
             std::shared_ptr< std::unique_ptr< DBusProxyConnection::DBusMessageReplyAsyncHandler > > sharedDbusMessageReplyAsyncHandler(
diff --git a/include/CommonAPI/DBus/DBusServiceRegistry.hpp b/include/CommonAPI/DBus/DBusServiceRegistry.hpp
index 61a4ac5..2edcd8f 100644
--- a/include/CommonAPI/DBus/DBusServiceRegistry.hpp
+++ b/include/CommonAPI/DBus/DBusServiceRegistry.hpp
@@ -132,7 +132,10 @@ class DBusServiceRegistry: public std::enable_shared_from_this<DBusServiceRegist
               mutexOnResolve() {
         }
 
-        ~DBusServiceListenersRecord() {};
+        ~DBusServiceListenersRecord() { 
+            if(uniqueBusNameState == DBusRecordState::RESOLVING && futureOnResolve.valid())
+                promiseOnResolve->set_value(DBusRecordState::NOT_AVAILABLE);
+        };
 
         DBusRecordState uniqueBusNameState;
         std::string uniqueBusName;
@@ -155,7 +158,10 @@ class DBusServiceRegistry: public std::enable_shared_from_this<DBusServiceRegist
               pendingObjectManagerCalls(0) {
         }
 
-        ~DBusObjectPathCache() {}
+        ~DBusObjectPathCache() {
+            if(state == DBusRecordState::RESOLVING && futureOnResolve.valid())
+                promiseOnResolve->set_value(DBusRecordState::NOT_AVAILABLE);
+        }
 
         size_t referenceCount;
         DBusRecordState state;
diff --git a/include/CommonAPI/DBus/DBusStubAdapterHelper.hpp b/include/CommonAPI/DBus/DBusStubAdapterHelper.hpp
index 643109f..0d4e7a7 100644
--- a/include/CommonAPI/DBus/DBusStubAdapterHelper.hpp
+++ b/include/CommonAPI/DBus/DBusStubAdapterHelper.hpp
@@ -350,7 +350,7 @@ protected:
 
          dbusOutputStream.beginWriteMap();
          appendGetAllReply(dbusMessage, dbusOutputStream);
- 		     dbusOutputStream.endWriteMap();
+         dbusOutputStream.endWriteMap();
          dbusOutputStream.flush();
 
          return getDBusConnection()->sendDBusMessage(dbusMessageReply);
diff --git a/src/CommonAPI/DBus/DBusConnection.cpp b/src/CommonAPI/DBus/DBusConnection.cpp
index 003aea9..d9da52e 100644
--- a/src/CommonAPI/DBus/DBusConnection.cpp
+++ b/src/CommonAPI/DBus/DBusConnection.cpp
@@ -1237,56 +1237,23 @@ DBusProxyConnection::DBusSignalHandlerToken DBusConnection::addSignalMemberHandl
 
     std::lock_guard<std::mutex> dbusSignalHandlersLock(signalHandlersGuard_);
 
-    if(auto itsHandler = dbusSignalHandler.lock()) {
-
-        uint32_t lastNumOfSignalMemberHandlers = getNumberOfSignalMemberHandlers(dbusSignalHandlerPath);
-
-        //check if signal handler is already added
-        auto signalHandlerPathIt = dbusSignalHandlers_.find(dbusSignalHandlerPath);
-        if(signalHandlerPathIt == dbusSignalHandlers_.end() || 
-            signalHandlerPathIt->second.find(itsHandler.get()) == signalHandlerPathIt->second.end()) {
+    auto signalHandlerPathIt = dbusSignalHandlers_.find(dbusSignalHandlerPath);
+    const bool isFirstSignalMemberHandler = (signalHandlerPathIt == dbusSignalHandlers_.end());
 
-            // the signal handler is not added yet for the 'dbusSignalHandlerPath' --> needs to be added
-            auto signalHandlerPathToAddIt = dbusSignalHandlersToAdd_.find(dbusSignalHandlerPath);
-            if(signalHandlerPathToAddIt == dbusSignalHandlersToAdd_.end()) {
-
-                // is first signal member handler for this 'dbusSignalHandlerPath' --> add
-                std::map<const DBusSignalHandler*, std::weak_ptr<DBusSignalHandler>> handlerList;
-                handlerList[itsHandler.get()] = dbusSignalHandler;
-
-                dbusSignalHandlersToAdd_.insert( {
-                    dbusSignalHandlerPath,
-                    std::move(handlerList)
-                } );
-            } else {
-                // add further signal handler
-                signalHandlerPathToAddIt->second[itsHandler.get()] = dbusSignalHandler;
-            }
+    auto itsHandler = dbusSignalHandler.lock();
 
-        } else {
-            // signal handler is already added
-            // check if handler is going to be removed
-            auto signalHandlerPathToRemoveIt = dbusSignalHandlersToRemove_.find(dbusSignalHandlerPath);
-            if(signalHandlerPathToRemoveIt != dbusSignalHandlersToRemove_.end()) {
-
-                auto handlerToRemoveEntry = signalHandlerPathToRemoveIt->second.find(itsHandler.get());
-                if(handlerToRemoveEntry != signalHandlerPathToRemoveIt->second.end()) {
-
-                    // signal handler is going to be removed --> erase
-                    signalHandlerPathToRemoveIt->second.erase(handlerToRemoveEntry);
-                    if(signalHandlerPathToRemoveIt->second.empty()) {
-                        dbusSignalHandlersToRemove_.erase(signalHandlerPathToRemoveIt);
-                    }
-                }
-            }
-        }
+    if (itsHandler && isFirstSignalMemberHandler) {
+        addLibdbusSignalMatchRule(objectPath, interfaceName, interfaceMemberName, justAddFilter);
 
-        uint32_t numOfSignalMemberHandlers = getNumberOfSignalMemberHandlers(dbusSignalHandlerPath);
+        std::map<const DBusSignalHandler*, std::weak_ptr<DBusSignalHandler>> handlerList;
+        handlerList[itsHandler.get()] = dbusSignalHandler;
 
-        if(lastNumOfSignalMemberHandlers == 0 && numOfSignalMemberHandlers == 1) {
-            // a new signal handler for the 'dbusSignalHandlerPath' was added --> add match rule
-            addLibdbusSignalMatchRule(objectPath, interfaceName, interfaceMemberName, justAddFilter);
-        }
+        dbusSignalHandlers_.insert( {
+            dbusSignalHandlerPath,
+            std::move(handlerList)
+        } );
+    } else if (itsHandler && !isFirstSignalMemberHandler) {
+        signalHandlerPathIt->second[itsHandler.get()] = dbusSignalHandler;
     }
 
     return dbusSignalHandlerPath;
@@ -1294,72 +1261,28 @@ DBusProxyConnection::DBusSignalHandlerToken DBusConnection::addSignalMemberHandl
 
 bool DBusConnection::removeSignalMemberHandler(const DBusSignalHandlerToken &dbusSignalHandlerToken,
                                                const DBusSignalHandler* dbusSignalHandler) {
+    bool lastHandlerRemoved = false;
 
-    std::lock_guard<std::mutex> itsLock(signalHandlersGuard_);
-
-    uint32_t lastNumOfSignalMemberHandlers = getNumberOfSignalMemberHandlers(dbusSignalHandlerToken);
-
-    //check if signal handler is already added
+    std::lock_guard<std::mutex> dbusSignalHandlersLock(signalHandlersGuard_);
+    
     auto signalHandlerPathIt = dbusSignalHandlers_.find(dbusSignalHandlerToken);
-    if(signalHandlerPathIt != dbusSignalHandlers_.end() &&
-            signalHandlerPathIt->second.find(dbusSignalHandler) !=
-                    signalHandlerPathIt->second.end()) {
-
-        // signal handler is already added
-        // check if handler is going to be removed
-        auto signalHandlerPathToRemoveIt = dbusSignalHandlersToRemove_.find(dbusSignalHandlerToken);
-        if(signalHandlerPathToRemoveIt != dbusSignalHandlersToRemove_.end()) {
-
-            auto it = signalHandlerPathToRemoveIt->second.find(dbusSignalHandler);
+    if (signalHandlerPathIt != dbusSignalHandlers_.end()) {
 
-            if(it == signalHandlerPathToRemoveIt->second.end()) {
-
-                // handler is not going to be removed yet --> remove
-                signalHandlerPathToRemoveIt->second[dbusSignalHandler] =
-                        std::weak_ptr<DBusSignalHandler>();
-            } 
-
-        } else {
-            // handler is not going to be removed yet. No dbus signal handler token found --> insert with handler to remove
-            std::map<const DBusSignalHandler*, std::weak_ptr<DBusSignalHandler>> handlerList;
-            handlerList[dbusSignalHandler] =
-                    std::weak_ptr<DBusSignalHandler>();
-
-            dbusSignalHandlersToRemove_.insert( {
-                dbusSignalHandlerToken,
-                std::move(handlerList)
-            } );
-        }
-
-    } else {
-        // signal handler not added yet
-        // check if handler is going to be added
-        auto signalHandlerPathToAddIt = dbusSignalHandlersToAdd_.find(dbusSignalHandlerToken);
-        if(signalHandlerPathToAddIt != dbusSignalHandlersToAdd_.end()) {
-
-            auto handlersToAddEntry = signalHandlerPathToAddIt->second.find(dbusSignalHandler);
-            if(handlersToAddEntry != signalHandlerPathToAddIt->second.end()) {
-
-                // handler is planned to be added --> erase
-                signalHandlerPathToAddIt->second.erase(handlersToAddEntry);
-                if(signalHandlerPathToAddIt->second.empty()) {
-                    dbusSignalHandlersToAdd_.erase(signalHandlerPathToAddIt);
-                }
-            }
+        auto selectedHandler = signalHandlerPathIt->second.find(const_cast<DBusSignalHandler*>(dbusSignalHandler));
+        if (selectedHandler != signalHandlerPathIt->second.end()) {
+            signalHandlerPathIt->second.erase(selectedHandler);
+            lastHandlerRemoved = (signalHandlerPathIt->second.empty());
         }
     }
 
-    uint32_t numOfSignalMemberHandlers = getNumberOfSignalMemberHandlers(dbusSignalHandlerToken);
-
-    if(lastNumOfSignalMemberHandlers == 1 && numOfSignalMemberHandlers == 0) {
-        // the last signal handler for the 'dbusSignalHandlerToken' was removed --> remove match rule
+    if (lastHandlerRemoved) {
+        dbusSignalHandlers_.erase(signalHandlerPathIt);
         removeLibdbusSignalMatchRule(std::get<0>(dbusSignalHandlerToken),
-                                 std::get<1>(dbusSignalHandlerToken),
-                                 std::get<2>(dbusSignalHandlerToken));
-        return true;
+                std::get<1>(dbusSignalHandlerToken),
+                std::get<2>(dbusSignalHandlerToken));
     }
 
-    return false;
+    return lastHandlerRemoved;
 }
 
 bool DBusConnection::addObjectManagerSignalMemberHandler(const std::string& dbusBusName,
@@ -1369,46 +1292,37 @@ bool DBusConnection::addObjectManagerSignalMemberHandler(const std::string& dbus
     }
 
     if(auto itsHandler = dbusSignalHandler.lock()) {
-        std::lock_guard<std::mutex> dbusSignalLock(dbusOMSignalHandlersGuard_);
-
-        auto signalHandlerPathIt = dbusOMSignalHandlers_.find(dbusBusName);
-        if(signalHandlerPathIt == dbusOMSignalHandlers_.end()) {
+        std::lock_guard<std::mutex> dbusOMSignalHandlersLock(dbusOMSignalHandlersGuard_);
 
-            // the signal handler is not added yet --> add
-            auto signalHandlerPathToAddIt = dbusOMSignalHandlersToAdd_.find(dbusBusName);
-            if(signalHandlerPathToAddIt == dbusOMSignalHandlersToAdd_.end()) {
+        auto dbusSignalMatchRuleIterator = dbusOMSignalMatchRulesMap_.find(dbusBusName);
+        const bool isDBusSignalMatchRuleFound = (dbusSignalMatchRuleIterator != dbusOMSignalMatchRulesMap_.end());
 
-                // is first signal member handler --> add to list and add match rule
-                std::pair<const DBusSignalHandler*, std::weak_ptr<DBusSignalHandler>> handler =
-                        std::make_pair(itsHandler.get(), dbusSignalHandler);
+        if (!isDBusSignalMatchRuleFound) {
+            if (isConnected() && !addObjectManagerSignalMatchRule(dbusBusName)) {
+                return false;
+            }
 
-                dbusOMSignalHandlersToAdd_.insert( {
-                    dbusBusName,
-                    std::move(handler)
-                } );
+            auto insertResult = dbusOMSignalMatchRulesMap_.insert({ dbusBusName, 0 });
+            const bool isInsertSuccessful = insertResult.second;
 
-                if (!addObjectManagerSignalMatchRule(dbusBusName)) {
-                    return false;
-                }
-            } else {
-                // signal handler is already going to be added
-                COMMONAPI_WARNING(std::string(__FUNCTION__), " a signal handler is already added for ", dbusBusName);
-                return true;
-            }
-        } else {
-            // signal handler is added
-            // check if handler is going to be removed
-            auto signalHandlerPathToRemoveIt= dbusOMSignalHandlersToRemove_.find(dbusBusName);
-            if(signalHandlerPathToRemoveIt != dbusOMSignalHandlersToRemove_.end()) {
-
-                // signal handler is going to be removed --> erase
-                dbusOMSignalHandlersToRemove_.erase(signalHandlerPathToRemoveIt);
-                if(isConnected() && !addObjectManagerSignalMatchRule(dbusBusName)) {
-                    return false;
+            if (!isInsertSuccessful) {
+                if (isConnected()) {
+                    const bool isRemoveSignalMatchRuleSuccessful = removeObjectManagerSignalMatchRule(dbusBusName);
+                    if (!isRemoveSignalMatchRuleSuccessful) {
+                        COMMONAPI_ERROR(std::string(__FUNCTION__), " removeObjectManagerSignalMatchRule", dbusBusName, " failed");
+                    }
                 }
+                return false;
             }
+
+            dbusSignalMatchRuleIterator = insertResult.first;
         }
+
+        size_t &dbusSignalMatchRuleReferenceCount = dbusSignalMatchRuleIterator->second;
+        dbusSignalMatchRuleReferenceCount++;
+        dbusOMSignalHandlers_.insert( { dbusBusName, std::make_pair(itsHandler.get(), dbusSignalHandler) } );
     }
+
     return true;
 }
 
@@ -1419,106 +1333,23 @@ bool DBusConnection::removeObjectManagerSignalMemberHandler(const std::string& d
         return false;
     }
 
-    std::lock_guard<std::mutex> itsLock(signalHandlersGuard_);
-
-    auto signalHandlerPathIt = dbusOMSignalHandlers_.find(dbusBusName);
-    if(signalHandlerPathIt != dbusOMSignalHandlers_.end()) {
-
-        // signal handler is added
-        // check if handler is already going to be removed
-        auto signalHandlerPathToRemoveIt = dbusOMSignalHandlersToRemove_.find(dbusBusName);
-        if(signalHandlerPathToRemoveIt != dbusOMSignalHandlersToRemove_.end()) {
-
-            if(signalHandlerPathToRemoveIt->second.first == dbusSignalHandler) {
-                COMMONAPI_WARNING(std::string(__FUNCTION__), " the signal handler is already removed for ", dbusBusName);
-                return true;
-            } else {
-                COMMONAPI_ERROR(std::string(__FUNCTION__), " the signal handler is not found for ", dbusBusName);
-                return false;
-            }
-        } else {
-            // no dbus signal handler found for 'dbusBusName' --> insert with handler
-            std::pair<const DBusSignalHandler*, std::weak_ptr<DBusSignalHandler>> handler =
-                    std::make_pair(dbusSignalHandler, std::weak_ptr<DBusSignalHandler>());
-
-            dbusOMSignalHandlersToRemove_.insert( {
-                dbusBusName,
-                std::move(handler)
-            } );
-
-            if (isConnected() && !removeObjectManagerSignalMatchRule(dbusBusName)) {
-                return false;
-            }
-        }
-    } else {
-        // signal handler not added
-        // check if handler is going to be added
-        auto signalHandlerPathToAddIt = dbusOMSignalHandlersToAdd_.find(dbusBusName);
-        if(signalHandlerPathToAddIt != dbusOMSignalHandlersToAdd_.end()) {
-
-            if(signalHandlerPathToAddIt->second.first == dbusSignalHandler) {
-                // handler is planned to be added --> erase
-                dbusOMSignalHandlersToAdd_.erase(signalHandlerPathToAddIt);
-                if (isConnected() && !removeObjectManagerSignalMatchRule(dbusBusName)) {
-                    return false;
-                }
-            } else {
-                COMMONAPI_ERROR(std::string(__FUNCTION__), " the signal handler is not found for ", dbusBusName);
-                return false;
-            }
-        }
-    }
-    return true;
-}
-
-bool DBusConnection::addObjectManagerSignalMatchRule(const std::string& dbusBusName) {
-
-    std::ostringstream dbusMatchRuleStringStream;
-    dbusMatchRuleStringStream << "type='signal'"
-                                << ",sender='" << dbusBusName << "'"
-                                << ",interface='org.freedesktop.DBus.ObjectManager'";
+    std::lock_guard<std::mutex> dbusOMSignalHandlersLock(dbusOMSignalHandlersGuard_);
 
     auto dbusSignalMatchRuleIterator = dbusOMSignalMatchRulesMap_.find(dbusBusName);
     const bool isDBusSignalMatchRuleFound = (dbusSignalMatchRuleIterator != dbusOMSignalMatchRulesMap_.end());
 
     if (!isDBusSignalMatchRuleFound) {
-
-        if(isConnected() && !addLibdbusSignalMatchRule(dbusMatchRuleStringStream.str())) {
-            return false;
-        }
-
-        auto insertResult = dbusOMSignalMatchRulesMap_.insert({ dbusBusName, 0 });
-        const bool isInsertSuccessful = insertResult.second;
-
-        if (!isInsertSuccessful) {
-            if (isConnected()) {
-                if (!removeObjectManagerSignalMatchRule(dbusBusName)) {
-                    COMMONAPI_ERROR(std::string(__FUNCTION__), " removeObjectManagerSignalMatchRule", dbusBusName, " failed");
-                }
-            }
-            return false;
-        }
-
-        dbusSignalMatchRuleIterator = insertResult.first;
+        return true;
     }
 
-    size_t &dbusSignalMatchRuleReferenceCount = dbusSignalMatchRuleIterator->second;
-    dbusSignalMatchRuleReferenceCount++;
-
-    return true;
-}
-
-bool DBusConnection::removeObjectManagerSignalMatchRule(const std::string& dbusBusName) {
-    std::ostringstream dbusMatchRuleStringStream;
-    dbusMatchRuleStringStream << "type='signal'"
-                                << ",sender='" << dbusBusName << "'"
-                                << ",interface='org.freedesktop.DBus.ObjectManager'";
-
-    auto dbusSignalMatchRuleIterator = dbusOMSignalMatchRulesMap_.find(dbusBusName);
-    const bool isDBusSignalMatchRuleFound = (dbusSignalMatchRuleIterator != dbusOMSignalMatchRulesMap_.end());
-
-    if (!isDBusSignalMatchRuleFound) {
-        return true;
+    auto dbusOMSignalHandlerRange = dbusOMSignalHandlers_.equal_range(dbusBusName);
+    auto dbusOMSignalHandlerIterator = std::find_if(
+        dbusOMSignalHandlerRange.first,
+        dbusOMSignalHandlerRange.second,
+        [&](decltype(*dbusOMSignalHandlerRange.first)& it) { return it.second.first == dbusSignalHandler; });
+    const bool isDBusSignalHandlerFound = (dbusOMSignalHandlerIterator != dbusOMSignalHandlerRange.second);
+    if (!isDBusSignalHandlerFound) {
+        return false;
     }
 
     size_t& dbusSignalMatchRuleReferenceCount = dbusSignalMatchRuleIterator->second;
@@ -1531,14 +1362,34 @@ bool DBusConnection::removeObjectManagerSignalMatchRule(const std::string& dbusB
 
     const bool isLastDBusSignalMatchRuleReference = (dbusSignalMatchRuleReferenceCount == 0);
     if (isLastDBusSignalMatchRuleReference) {
-        if (isConnected() && !removeLibdbusSignalMatchRule(dbusBusName)) {
+        if (isConnected() && !removeObjectManagerSignalMatchRule(dbusBusName)) {
             return false;
         }
+
         dbusOMSignalMatchRulesMap_.erase(dbusSignalMatchRuleIterator);
     }
+
+    dbusOMSignalHandlers_.erase(dbusOMSignalHandlerIterator);
+
     return true;
 }
 
+bool DBusConnection::addObjectManagerSignalMatchRule(const std::string& dbusBusName) {
+    std::ostringstream dbusMatchRuleStringStream;
+    dbusMatchRuleStringStream << "type='signal'"
+                                << ",sender='" << dbusBusName << "'"
+                                << ",interface='org.freedesktop.DBus.ObjectManager'";
+    return addLibdbusSignalMatchRule(dbusMatchRuleStringStream.str());
+}
+
+bool DBusConnection::removeObjectManagerSignalMatchRule(const std::string& dbusBusName) {
+    std::ostringstream dbusMatchRuleStringStream;
+    dbusMatchRuleStringStream << "type='signal'"
+                                << ",sender='" << dbusBusName << "'"
+                                << ",interface='org.freedesktop.DBus.ObjectManager'";
+    return removeLibdbusSignalMatchRule(dbusMatchRuleStringStream.str());
+}
+
 /**
  * Called only if connected
  *
@@ -1743,23 +1594,23 @@ void DBusConnection::removeLibdbusSignalMatchRule(const std::string& objectPath,
     if (!matchRuleFound) {
         COMMONAPI_ERROR(std::string(__FUNCTION__), " no match rule found for path: ", objectPath,
                             "interface: ", interfaceName, " member: ", interfaceMemberName);
-    } else {
-        uint32_t& matchRuleReferenceCount = matchRuleIterator->second.first;
-        if (matchRuleReferenceCount > 1) {
-            matchRuleReferenceCount--;
-            return;
-        }
+    }
 
-        if (isConnected()) {
-            const std::string& matchRuleString = matchRuleIterator->second.second;
-            const bool libdbusSuccess = removeLibdbusSignalMatchRule(matchRuleString);
-            if (!libdbusSuccess) {
-                COMMONAPI_ERROR(std::string(__FUNCTION__), " removeLibdbusSignalMatchRule failed ", matchRuleString);
-            }
-        }
+    uint32_t& matchRuleReferenceCount = matchRuleIterator->second.first;
+    if (matchRuleReferenceCount > 1) {
+        matchRuleReferenceCount--;
+        return;
+    }
 
-        dbusSignalMatchRulesMap_.erase(matchRuleIterator);
+    if (isConnected()) {
+        const std::string& matchRuleString = matchRuleIterator->second.second;
+        const bool libdbusSuccess = removeLibdbusSignalMatchRule(matchRuleString);
+        if (!libdbusSuccess) {
+            COMMONAPI_ERROR(std::string(__FUNCTION__), " removeLibdbusSignalMatchRule failed ", matchRuleString);
+        }
     }
+
+    dbusSignalMatchRulesMap_.erase(matchRuleIterator);
 }
 
 void DBusConnection::initLibdbusObjectPathHandlerAfterConnect() {
@@ -1814,8 +1665,8 @@ void DBusConnection::initLibdbusSignalFilterAfterConnect() {
     }
 
     // object manager match rules (see DBusServiceRegistry)
-    for (const auto& dbusObjectManagerSignalMatchRuleIterator : dbusOMSignalMatchRulesMap_) {
-        const std::string& dbusBusName = dbusObjectManagerSignalMatchRuleIterator.first;
+    for (const auto& dbusOMSignalMatchRuleIterator : dbusOMSignalMatchRulesMap_) {
+        const std::string& dbusBusName = dbusOMSignalMatchRuleIterator.first;
         const bool libdbusSuccess = addObjectManagerSignalMatchRule(dbusBusName);
         if (!libdbusSuccess) {
             COMMONAPI_ERROR(std::string(__FUNCTION__), " addObjectManagerSignalMatchRule(", dbusBusName , ") failed ");
@@ -1841,73 +1692,28 @@ void DBusConnection::initLibdbusSignalFilterAfterConnect() {
 void DBusConnection::notifyDBusSignalHandlers(DBusSignalHandlerPath handlerPath,
                                               const DBusMessage& dbusMessage,
                                               ::DBusHandlerResult& dbusHandlerResult) {
-    {
-        std::lock_guard<std::mutex> dbusSignalHandlersLock(signalHandlersGuard_);
-
-        // remove signal handlers
-        auto signalHandlerPathToRemoveIt = dbusSignalHandlersToRemove_.find(handlerPath);
-        if(signalHandlerPathToRemoveIt != dbusSignalHandlersToRemove_.end()) {
-
-            for(auto handlerToRemoveIt = signalHandlerPathToRemoveIt->second.begin();
-                    handlerToRemoveIt != signalHandlerPathToRemoveIt->second.end();
-                    ++handlerToRemoveIt) {
-
-                auto signalHandlerPathIt = dbusSignalHandlers_.find(handlerPath);
-                if(signalHandlerPathIt != dbusSignalHandlers_.end()) {
-                    auto signalHandlerIt = signalHandlerPathIt->second.find(handlerToRemoveIt->first);
-                    if(signalHandlerIt != signalHandlerPathIt->second.end()) {
-                        signalHandlerPathIt->second.erase(signalHandlerIt);
-                    }
-                }
-            }
-            auto signalHandlerPathIt = dbusSignalHandlers_.find(handlerPath);
-            if(signalHandlerPathIt != dbusSignalHandlers_.end() &&
-                    signalHandlerPathIt->second.empty()) {
-                dbusSignalHandlers_.erase(handlerPath);
-            }
-            dbusSignalHandlersToRemove_.erase(signalHandlerPathToRemoveIt);
-        }
-
-        // add signal handlers
-        auto signalHandlerPathToAddIt = dbusSignalHandlersToAdd_.find(handlerPath);
-        if(signalHandlerPathToAddIt != dbusSignalHandlersToAdd_.end()) {
 
-            for(auto handlerToAddIt = signalHandlerPathToAddIt->second.begin();
-                    handlerToAddIt != signalHandlerPathToAddIt->second.end();
-                    ++handlerToAddIt) {
-
-                auto signalHandlerPathIt = dbusSignalHandlers_.find(handlerPath);
-                if(signalHandlerPathIt == dbusSignalHandlers_.end()) {
+    // ensure, the registry survives
+    std::shared_ptr<DBusServiceRegistry> itsRegistry_ = DBusServiceRegistry::get(shared_from_this());
 
-                    std::map<const DBusSignalHandler*, std::weak_ptr<DBusSignalHandler>> handlerList;
-                    handlerList[handlerToAddIt->first] = handlerToAddIt->second;
+    std::map<const DBusSignalHandler*,
+        std::weak_ptr<DBusProxyConnection::DBusSignalHandler>> itsHandlers;
+    {
+        std::lock_guard<std::mutex> dbusSignalHandlersLock(signalHandlersGuard_);
 
-                    dbusSignalHandlers_.insert( {
-                        handlerPath,
-                        std::move(handlerList)
-                    } );
-                } else {
-                    signalHandlerPathIt->second[handlerToAddIt->first] = handlerToAddIt->second;
-                }
-            }
-            dbusSignalHandlersToAdd_.erase(signalHandlerPathToAddIt);
+        auto signalHandlerPathIt = dbusSignalHandlers_.find(handlerPath);
+        if(signalHandlerPathIt != dbusSignalHandlers_.end()) {
+            itsHandlers = signalHandlerPathIt->second;
         }
     }
 
-    // ensure, the registry survives
-    std::shared_ptr<DBusServiceRegistry> itsRegistry_ = DBusServiceRegistry::get(shared_from_this(), false);
-
-    // notify
-    auto signalHandlerPathIt = dbusSignalHandlers_.find(handlerPath);
-    if(signalHandlerPathIt != dbusSignalHandlers_.end()) {
-        for(auto handlerIt = signalHandlerPathIt->second.begin();
-                handlerIt != signalHandlerPathIt->second.end();
-                ++handlerIt) {
-            std::weak_ptr<DBusProxyConnection::DBusSignalHandler> dbusSignalHandler = handlerIt->second;
-            if(auto itsHandler = dbusSignalHandler.lock()) {
-                itsHandler->onSignalDBusMessage(dbusMessage);
-            }
-        }
+
+    auto itsHandlerIt = itsHandlers.begin();
+    while (itsHandlerIt != itsHandlers.end()) {
+        std::weak_ptr<DBusProxyConnection::DBusSignalHandler> dbusSignalHandler = itsHandlerIt->second;
+        if(auto itsHandler = dbusSignalHandler.lock())
+            itsHandler->onSignalDBusMessage(dbusMessage);
+        itsHandlerIt++;
     }
     dbusHandlerResult = DBUS_HANDLER_RESULT_HANDLED;
 }
@@ -1915,63 +1721,23 @@ void DBusConnection::notifyDBusSignalHandlers(DBusSignalHandlerPath handlerPath,
 void DBusConnection::notifyDBusOMSignalHandlers(const char* dbusSenderName,
                                                 const DBusMessage& dbusMessage,
                                                 ::DBusHandlerResult& dbusHandlerResult) {
+    std::vector<std::weak_ptr<DBusProxyConnection::DBusSignalHandler>> dbusOMSignalHandlers;
     {
         std::lock_guard<std::mutex> dbusOMSignalHandlersLock(dbusOMSignalHandlersGuard_);
+        auto equalRange = dbusOMSignalHandlers_.equal_range(dbusSenderName);
 
-        // remove signal handlers
-        auto signalHandlerPathToRemoveIt = dbusOMSignalHandlersToRemove_.find(dbusSenderName);
-        if(signalHandlerPathToRemoveIt != dbusOMSignalHandlersToRemove_.end()) {
-
-            auto signalHandlerPathIt = dbusOMSignalHandlers_.find(dbusSenderName);
-            if(signalHandlerPathIt != dbusOMSignalHandlers_.end()) {
-
-                if(signalHandlerPathToRemoveIt->second.first ==
-                        signalHandlerPathIt->second.first) {
-                    dbusOMSignalHandlers_.erase(signalHandlerPathIt);
-                    dbusOMSignalHandlersToRemove_.erase(signalHandlerPathToRemoveIt);
-                } else {
-                    COMMONAPI_ERROR(std::string(__FUNCTION__), " signal handler can not be removed ", dbusSenderName);
-                    return;
-                }
-            }
+        if (equalRange.first != equalRange.second) {
+            dbusHandlerResult = DBUS_HANDLER_RESULT_HANDLED;
         }
-
-        // add signal handlers
-        auto signalHandlerPathToAddIt = dbusOMSignalHandlersToAdd_.find(dbusSenderName);
-        if(signalHandlerPathToAddIt != dbusOMSignalHandlersToAdd_.end()) {
-
-            auto signalHandlerPathIt = dbusOMSignalHandlers_.find(dbusSenderName);
-            if(signalHandlerPathIt == dbusOMSignalHandlers_.end()) {
-
-                dbusOMSignalHandlers_.insert( {
-                    dbusSenderName,
-                    std::move(signalHandlerPathToAddIt->second)
-                } );
-
-            } else {
-                if(signalHandlerPathToAddIt->second.first ==
-                        signalHandlerPathIt->second.first) {
-                    COMMONAPI_ERROR(std::string(__FUNCTION__), " signal handler already added for ", dbusSenderName);
-                    return;
-                } else {
-                    COMMONAPI_ERROR(std::string(__FUNCTION__), " signal handler is trying to be added but "
-                            "a signal handler is already added for", dbusSenderName);
-                    return;
-                }
-            }
-            dbusOMSignalHandlersToAdd_.erase(signalHandlerPathToAddIt);
+        while (equalRange.first != equalRange.second) {
+            dbusOMSignalHandlers.push_back(equalRange.first->second.second);
+            equalRange.first++;
         }
     }
 
-    dbusHandlerResult = DBUS_HANDLER_RESULT_HANDLED;
-
-    // notify
-    auto signalHandlerPathIt = dbusOMSignalHandlers_.find(dbusSenderName);
-    if(signalHandlerPathIt != dbusOMSignalHandlers_.end()) {
-        std::weak_ptr<DBusProxyConnection::DBusSignalHandler> dbusSignalHandler = signalHandlerPathIt->second.second;
-        if(auto itsHandler = dbusSignalHandler.lock()) {
+    for(auto it = dbusOMSignalHandlers.begin(); it != dbusOMSignalHandlers.end(); ++it) {
+        if(auto itsHandler = it->lock())
             itsHandler->onSignalDBusMessage(dbusMessage);
-        }
     }
 }
 
@@ -2007,8 +1773,6 @@ void DBusConnection::notifyDBusOMSignalHandlers(const char* dbusSenderName,
             interfaceMemberName,
             interfaceMemberSignature);
 
-    notifyDBusSignalHandlers(handlerPath, dbusMessage, dbusHandlerResult);
-
     if (dbusMessage.hasInterfaceName("org.freedesktop.DBus.ObjectManager")) {
 
         const char* dbusSenderName = dbusMessage.getSender();
@@ -2020,6 +1784,8 @@ void DBusConnection::notifyDBusOMSignalHandlers(const char* dbusSenderName,
         notifyDBusOMSignalHandlers(dbusSenderName, dbusMessage, dbusHandlerResult);
     }
 
+    notifyDBusSignalHandlers(handlerPath, dbusMessage, dbusHandlerResult);
+
     return dbusHandlerResult;
 }
 
@@ -2119,20 +1885,6 @@ void DBusConnection::deleteAsyncHandlers() {
     }
 }
 
-uint32_t DBusConnection::getNumberOfSignalMemberHandlers(DBusSignalHandlerPath handlerPath) {
-    uint32_t handlers, handlersToAdd, handlersToRemove;
-
-    auto signalHandlerPathIt = dbusSignalHandlers_.find(handlerPath);
-    auto signalHandlerPathToAddIt = dbusSignalHandlersToAdd_.find(handlerPath);
-    auto signalHandlerPathToRemoveIt = dbusSignalHandlersToRemove_.find(handlerPath);
-
-    (signalHandlerPathIt != dbusSignalHandlers_.end()) ? handlers = (uint32_t)signalHandlerPathIt->second.size() : handlers = 0;
-    (signalHandlerPathToAddIt != dbusSignalHandlersToAdd_.end()) ? handlersToAdd = (uint32_t)signalHandlerPathToAddIt->second.size() : handlersToAdd = 0;
-    (signalHandlerPathToRemoveIt != dbusSignalHandlersToRemove_.end()) ? handlersToRemove = (uint32_t)signalHandlerPathToRemoveIt->second.size() : handlersToRemove = 0;
-
-    return handlers - handlersToRemove + handlersToAdd;
-}
-
 void DBusConnection::addSignalStateHandler(
             std::shared_ptr<DBusProxyConnection::DBusSignalHandler> _handler,
             const uint32_t _subscription) {
diff --git a/src/CommonAPI/DBus/DBusFactory.cpp b/src/CommonAPI/DBus/DBusFactory.cpp
index 0d10c61..2490e98 100644
--- a/src/CommonAPI/DBus/DBusFactory.cpp
+++ b/src/CommonAPI/DBus/DBusFactory.cpp
@@ -45,27 +45,27 @@ Factory::~Factory() {
 void
 Factory::init() {
 #ifndef _WIN32
-	std::lock_guard<std::mutex> itsLock(initializerMutex_);
+    std::lock_guard<std::mutex> itsLock(initializerMutex_);
 #endif
-	if (!isInitialized_) {
-		for (auto i : initializers_) i();
-		initializers_.clear(); // Not needed anymore
-		isInitialized_ = true;
-	}
+    if (!isInitialized_) {
+        for (auto i : initializers_) i();
+        initializers_.clear(); // Not needed anymore
+        isInitialized_ = true;
+    }
 }
 
 void
 Factory::registerInterface(InterfaceInitFunction _function) {
 #ifndef _WIN32
-	std::lock_guard<std::mutex> itsLock(initializerMutex_);
+    std::lock_guard<std::mutex> itsLock(initializerMutex_);
 #endif
-	if (isInitialized_) {
-		// We are already running --> initialize the interface library!
-		_function();
-	} else {
-		// We are not initialized --> save the initializer
-		initializers_.push_back(_function);
-	}
+    if (isInitialized_) {
+        // We are already running --> initialize the interface library!
+        _function();
+    } else {
+        // We are not initialized --> save the initializer
+        initializers_.push_back(_function);
+    }
 }
 
 void