Added support for selective broadcasts

-Add subclass for event to support additional API for selective
-StubAdapter handles all management, only callbacks exposed

Change-Id: I2af3c6bcc8b6d0cfd7362eeed7d518a57cf804c6

29 files changed, 1380 insertions, 544 deletions

diff --git a/Makefile.am b/Makefile.am
index 1a037b0..3c33519 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -89,6 +89,7 @@ CommonAPI_DBus_include_HEADERS = \
         src/CommonAPI/DBus/DBusFactory.h \
         src/CommonAPI/DBus/DBusProxyHelper.h \
         src/CommonAPI/DBus/DBusRuntime.h \
+        src/CommonAPI/DBus/DBusSelectiveEvent.h \
         src/CommonAPI/DBus/DBusSerializableArguments.h \
         src/CommonAPI/DBus/DBusServicePublisher.h \
         src/CommonAPI/DBus/DBusServiceRegistry.h \
@@ -171,7 +172,8 @@ check_PROGRAMS = \
         DBusCommunicationTest \
         DBusMultipleConnectionTest \
         DBusServicePublisherTest \
-        DBusClientIdTest
+        DBusClientIdTest \
+        DBusSelectiveBroadcastTest
 
 
 TESTS = ${check_PROGRAMS}
@@ -314,12 +316,20 @@ DBusDynamicLoadingNoValidityTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS}
 DBusDynamicLoadingNoValidityTest_CXXFLAGS = ${GTEST_CXXFLAGS}
 DBusDynamicLoadingNoValidityTest_LDADD = ${LDADD_FOR_GTEST_WITHOUT_LIBCOMMON_API_DBUS}
 
-
-DBusClientIdTest_SOURCES = src/test/DBusClientIdTest.cpp
+DBusClientIdTest_SOURCES =  \
+        src/test/DBusClientIdTest.cpp
 DBusClientIdTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS}
 DBusClientIdTest_CXXFLAGS = ${GTEST_CXXFLAGS}
 DBusClientIdTest_LDADD = ${LDADD_FOR_GTEST}
 
+
+DBusSelectiveBroadcastTest_SOURCES =  \
+        ${TestInterfaceDBusSources} \
+        src/test/DBusSelectiveBroadcastTest.cpp
+DBusSelectiveBroadcastTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS}
+DBusSelectiveBroadcastTest_CXXFLAGS = ${GTEST_CXXFLAGS}
+DBusSelectiveBroadcastTest_LDADD = ${LDADD_FOR_GTEST}
+
 endif
 
 
diff --git a/src/CommonAPI/DBus/DBusClientId.cpp b/src/CommonAPI/DBus/DBusClientId.cpp
index cf0f9a3..39219bf 100644
--- a/src/CommonAPI/DBus/DBusClientId.cpp
+++ b/src/CommonAPI/DBus/DBusClientId.cpp
@@ -6,8 +6,21 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "DBusClientId.h"
+#include "DBusMessage.h"
 #include <typeinfo>
 
+namespace std {
+
+template<>
+struct hash<CommonAPI::DBus::DBusClientId> {
+public:
+    size_t operator()(CommonAPI::DBus::DBusClientId* dbusClientIdToHash) const {
+        return (hash<string>()(dbusClientIdToHash->dbusId_));
+    }
+};
+
+} /* namespace std */
+
 namespace CommonAPI {
 namespace DBus {
 
@@ -18,7 +31,7 @@ DBusClientId::DBusClientId(std::string dbusId) :
 bool DBusClientId::operator==(CommonAPI::ClientId& clientIdToCompare) {
     try {
         DBusClientId clientIdToCompareDBus = DBusClientId(dynamic_cast<DBusClientId&>(clientIdToCompare));
-        return (&clientIdToCompareDBus == this);
+        return (clientIdToCompareDBus == *this);
     }
     catch (const std::bad_cast& e) {
         return false;
@@ -29,5 +42,20 @@ bool DBusClientId::operator==(DBusClientId& clientIdToCompare) {
     return (clientIdToCompare.dbusId_ == dbusId_);
 }
 
+size_t DBusClientId::hashCode()
+{
+    return std::hash<DBusClientId>()(this);
+}
+
+DBusMessage DBusClientId::createMessage(const std::string objectPath, const std::string interfaceName, const std::string signalName) const
+{
+    DBusMessage returnMessage = DBusMessage::createSignal(objectPath, interfaceName, signalName);
+    returnMessage.setDestination(dbusId_.c_str());
+
+    return(returnMessage);
+}
+
 } /* namespace DBus */
 } /* namespace CommonAPI */
+
+
diff --git a/src/CommonAPI/DBus/DBusClientId.h b/src/CommonAPI/DBus/DBusClientId.h
index 7818969..4b76699 100644
--- a/src/CommonAPI/DBus/DBusClientId.h
+++ b/src/CommonAPI/DBus/DBusClientId.h
@@ -18,6 +18,8 @@
 namespace CommonAPI {
 namespace DBus {
 
+class DBusMessage;
+
 /**
  * \brief Implementation of CommonAPI::ClientId for DBus
  *
@@ -25,11 +27,16 @@ namespace DBus {
  * It internally uses a string to identify clients. This string is the unique sender id used by dbus.
  */
 class DBusClientId: public CommonAPI::ClientId {
+    friend class std::hash<DBusClientId>;
+
 public:
     DBusClientId(std::string dbusId);
 
     bool operator==(CommonAPI::ClientId& clientIdToCompare);
     bool operator==(DBusClientId& clientIdToCompare);
+    size_t hashCode();
+
+    DBusMessage createMessage(const std::string objectPath, const std::string interfaceName, const std::string signalName) const;
 protected:
     std::string dbusId_;
 };
diff --git a/src/CommonAPI/DBus/DBusConnection.cpp b/src/CommonAPI/DBus/DBusConnection.cpp
index c41f8ab..9ac9cee 100644
--- a/src/CommonAPI/DBus/DBusConnection.cpp
+++ b/src/CommonAPI/DBus/DBusConnection.cpp
@@ -12,6 +12,7 @@
 
 #include "DBusConnection.h"
 #include "DBusInputStream.h"
+#include "DBusProxy.h"
 
 #include <algorithm>
 #include <sstream>
@@ -583,48 +584,103 @@ bool DBusConnection::isDispatchReady() {
     return (dbus_connection_get_dispatch_status(libdbusConnection_) == DBUS_DISPATCH_DATA_REMAINS);
 }
 
+DBusProxyConnection::DBusSignalHandlerToken DBusConnection::subscribeForSelectiveBroadcast(
+                    bool& subscriptionAccepted,
+                    const std::string& objectPath,
+                    const std::string& interfaceName,
+                    const std::string& interfaceMemberName,
+                    const std::string& interfaceMemberSignature,
+                    DBusSignalHandler* dbusSignalHandler,
+                    DBusProxy* callingProxy) {
+
+    const char* methodName = ("subscribeFor" + interfaceMemberName + "Selective").c_str();
+
+    subscriptionAccepted = false;
+    CommonAPI::CallStatus callStatus;
+    DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
+                    CommonAPI::DBus::DBusSerializableArguments<bool>>::callMethodWithReply(
+                    *callingProxy, methodName, "", callStatus, subscriptionAccepted);
+
+    DBusProxyConnection::DBusSignalHandlerToken subscriptionToken;
+
+    if (callStatus == CommonAPI::CallStatus::SUCCESS && subscriptionAccepted) {
+        subscriptionToken = addSignalMemberHandler(
+                        objectPath,
+                        interfaceName,
+                        interfaceMemberName,
+                        interfaceMemberSignature,
+                        dbusSignalHandler,
+                        true);
+
+        subscriptionAccepted = true;
+    }
+
+    return (subscriptionToken);
+}
+
+void DBusConnection::unsubsribeFromSelectiveBroadcast(const std::string& eventName,
+                                                      DBusProxyConnection::DBusSignalHandlerToken subscription,
+                                                      DBusProxy* callingProxy) {
+    bool lastListenerOnConnectionRemoved = removeSignalMemberHandler(subscription);
+
+    if (lastListenerOnConnectionRemoved) {
+        // send unsubscribe message to stub
+        const char* methodName = ("unsubscribeFrom" + eventName + "Selective").c_str();
+        CommonAPI::CallStatus callStatus;
+        DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
+                        CommonAPI::DBus::DBusSerializableArguments<>>::callMethodWithReply(
+                        *callingProxy, methodName, "", callStatus);
+    }
+}
 
 DBusProxyConnection::DBusSignalHandlerToken DBusConnection::addSignalMemberHandler(const std::string& objectPath,
                                                                                    const std::string& interfaceName,
                                                                                    const std::string& interfaceMemberName,
                                                                                    const std::string& interfaceMemberSignature,
-                                                                                   DBusSignalHandler* dbusSignalHandler) {
+                                                                                   DBusSignalHandler* dbusSignalHandler,
+                                                                                   const bool justAddFilter) {
     DBusSignalHandlerPath dbusSignalHandlerPath(
                     objectPath,
                     interfaceName,
                     interfaceMemberName,
                     interfaceMemberSignature);
-    std::lock_guard<std::mutex> dbusSignalLock(signalGuard_);
-    const bool isFirstSignalMemberHandler = dbusSignalHandlerTable_.find(dbusSignalHandlerPath) == dbusSignalHandlerTable_.end();
+    std::lock_guard < std::mutex > dbusSignalLock(signalGuard_);
+    const bool isFirstSignalMemberHandler = dbusSignalHandlerTable_.find(dbusSignalHandlerPath)
+                    == dbusSignalHandlerTable_.end();
     dbusSignalHandlerTable_.insert(DBusSignalHandlerTable::value_type(dbusSignalHandlerPath, dbusSignalHandler));
 
     if (isFirstSignalMemberHandler) {
-        addLibdbusSignalMatchRule(objectPath, interfaceName, interfaceMemberName);
+        addLibdbusSignalMatchRule(objectPath, interfaceName, interfaceMemberName, justAddFilter);
     }
 
     return dbusSignalHandlerPath;
 }
 
-void DBusConnection::removeSignalMemberHandler(const DBusSignalHandlerToken& dbusSignalHandlerToken) {
+bool DBusConnection::removeSignalMemberHandler(const DBusSignalHandlerToken& dbusSignalHandlerToken) {
+    bool lastHandlerRemoved = false;
+
     std::lock_guard<std::mutex> dbusSignalLock(signalGuard_);
     auto equalRangeIteratorPair = dbusSignalHandlerTable_.equal_range(dbusSignalHandlerToken);
     if (equalRangeIteratorPair.first != equalRangeIteratorPair.second) {
-		// advance to the next element
-		equalRangeIteratorPair.first++;
+        // advance to the next element
+        equalRangeIteratorPair.first++;
 
-		// check if the first element was the only element
-		const bool isLastSignalMemberHandler = equalRangeIteratorPair.first == equalRangeIteratorPair.second;
+        // check if the first element was the only element
+        const bool isLastSignalMemberHandler = equalRangeIteratorPair.first == equalRangeIteratorPair.second;
 
-		if (isLastSignalMemberHandler) {
-			const std::string& objectPath = std::get<0>(dbusSignalHandlerToken);
-			const std::string& interfaceName = std::get<1>(dbusSignalHandlerToken);
-			const std::string& interfaceMemberName = std::get<2>(dbusSignalHandlerToken);
+        if (isLastSignalMemberHandler) {
+            const std::string& objectPath = std::get<0>(dbusSignalHandlerToken);
+            const std::string& interfaceName = std::get<1>(dbusSignalHandlerToken);
+            const std::string& interfaceMemberName = std::get<2>(dbusSignalHandlerToken);
 
-			removeLibdbusSignalMatchRule(objectPath, interfaceName, interfaceMemberName);
-		}
+            removeLibdbusSignalMatchRule(objectPath, interfaceName, interfaceMemberName);
+            lastHandlerRemoved = true;
+        }
 
-		dbusSignalHandlerTable_.erase(dbusSignalHandlerToken);
+        dbusSignalHandlerTable_.erase(equalRangeIteratorPair.first, equalRangeIteratorPair.first);
     }
+
+    return lastHandlerRemoved;
 }
 
 void DBusConnection::registerObjectPath(const std::string& objectPath) {
@@ -681,7 +737,8 @@ void DBusConnection::unregisterObjectPath(const std::string& objectPath) {
 
 void DBusConnection::addLibdbusSignalMatchRule(const std::string& objectPath,
                                                const std::string& interfaceName,
-                                               const std::string& interfaceMemberName) {
+                                               const std::string& interfaceMemberName,
+                                               const bool justAddFilter) {
     DBusSignalMatchRuleTuple dbusSignalMatchRuleTuple(objectPath, interfaceName, interfaceMemberName);
     auto matchRuleIterator = dbusSignalMatchRulesMap_.find(dbusSignalMatchRuleTuple);
     const bool matchRuleFound = matchRuleIterator != dbusSignalMatchRulesMap_.end();
@@ -706,7 +763,7 @@ void DBusConnection::addLibdbusSignalMatchRule(const std::string& objectPath,
     std::string matchRuleString = matchRuleStringStream.str();
     auto success = dbusSignalMatchRulesMap_.insert(
                     DBusSignalMatchRulesMap::value_type(dbusSignalMatchRuleTuple,
-                                                        DBusSignalMatchRuleMapping(1, matchRuleString)));
+                                    DBusSignalMatchRuleMapping(1, matchRuleString)));
     assert(success.second);
 
     // if not connected the filter and the rules will be added as soon as the connection is established
@@ -715,16 +772,19 @@ void DBusConnection::addLibdbusSignalMatchRule(const std::string& objectPath,
         // add the libdbus message signal filter
         if (isFirstMatchRule) {
             const dbus_bool_t libdbusSuccess = dbus_connection_add_filter(libdbusConnection_,
-                                                                          &onLibdbusSignalFilterThunk,
-                                                                          this,
-                                                                          NULL);
+                            &onLibdbusSignalFilterThunk,
+                            this,
+                            NULL);
             assert(libdbusSuccess);
         }
 
-        // finally add the match rule
-        DBusError dbusError;
-        dbus_bus_add_match(libdbusConnection_, matchRuleString.c_str(), &dbusError.libdbusError_);
-        assert(!dbusError);
+        if (!justAddFilter)
+        {
+            // finally add the match rule
+            DBusError dbusError;
+            dbus_bus_add_match(libdbusConnection_, matchRuleString.c_str(), &dbusError.libdbusError_);
+            assert(!dbusError);
+        }
 
         resumeDispatching();
     }
@@ -835,6 +895,7 @@ void DBusConnection::initLibdbusSignalFilterAfterConnect() {
 
 ::DBusHandlerResult DBusConnection::onLibdbusSignalFilter(::DBusMessage* libdbusMessage) {
     assert(libdbusMessage);
+
     auto selfReference = this->shared_from_this();
 
     // handle only signal messages
diff --git a/src/CommonAPI/DBus/DBusConnection.h b/src/CommonAPI/DBus/DBusConnection.h
index a64693c..61c7418 100644
--- a/src/CommonAPI/DBus/DBusConnection.h
+++ b/src/CommonAPI/DBus/DBusConnection.h
@@ -90,16 +90,28 @@ class DBusConnection: public DBusProxyConnection, public std::enable_shared_from
             int timeoutMilliseconds = kDefaultSendTimeoutMs) const;
 
     DBusSignalHandlerToken addSignalMemberHandler(const std::string& objectPath,
-            const std::string& interfaceName,
-            const std::string& interfaceMemberName,
-            const std::string& interfaceMemberSignature,
-            DBusSignalHandler* dbusSignalHandler);
+                                                  const std::string& interfaceName,
+                                                  const std::string& interfaceMemberName,
+                                                  const std::string& interfaceMemberSignature,
+                                                  DBusSignalHandler* dbusSignalHandler,
+                                                  const bool justAddFilter = false);
+
+    DBusProxyConnection::DBusSignalHandlerToken subscribeForSelectiveBroadcast(bool& subscriptionAccepted,
+                                                                               const std::string& objectPath,
+                                                                               const std::string& interfaceName,
+                                                                               const std::string& interfaceMemberName,
+                                                                               const std::string& interfaceMemberSignature,
+                                                                               DBusSignalHandler* dbusSignalHandler,
+                                                                               DBusProxy* callingProxy);
+
+    void unsubsribeFromSelectiveBroadcast(const std::string& eventName,
+                                          DBusProxyConnection::DBusSignalHandlerToken subscription,
+                                          DBusProxy* callingProxy);
 
     void registerObjectPath(const std::string& objectPath);
     void unregisterObjectPath(const std::string& objectPath);
 
-    void removeSignalMemberHandler(const DBusSignalHandlerToken& dbusSignalHandlerToken);
-
+    bool removeSignalMemberHandler(const DBusSignalHandlerToken& dbusSignalHandlerToken);
     bool readWriteDispatch(int timeoutMilliseconds = -1);
 
     virtual const std::shared_ptr<DBusServiceRegistry> getDBusServiceRegistry();
@@ -113,6 +125,9 @@ class DBusConnection: public DBusProxyConnection, public std::enable_shared_from
     bool isDispatchReady();
     bool singleDispatch();
 
+    typedef std::tuple<std::string, std::string, std::string> DBusSignalMatchRuleTuple;
+    typedef std::pair<uint32_t, std::string> DBusSignalMatchRuleMapping;
+    typedef std::unordered_map<DBusSignalMatchRuleTuple, DBusSignalMatchRuleMapping> DBusSignalMatchRulesMap;
  private:
     void dispatch();
     void suspendDispatching() const;
@@ -130,7 +145,8 @@ class DBusConnection: public DBusProxyConnection, public std::enable_shared_from
 
     void addLibdbusSignalMatchRule(const std::string& objectPath,
             const std::string& interfaceName,
-            const std::string& interfaceMemberName);
+            const std::string& interfaceMemberName,
+            const bool justAddFilter = false);
 
     void removeLibdbusSignalMatchRule(const std::string& objectPath,
             const std::string& interfaceName,
@@ -179,9 +195,7 @@ class DBusConnection: public DBusProxyConnection, public std::enable_shared_from
 
     DBusConnectionStatusEvent dbusConnectionStatusEvent_;
 
-    typedef std::tuple<std::string, std::string, std::string> DBusSignalMatchRuleTuple;
-    typedef std::pair<uint32_t, std::string> DBusSignalMatchRuleMapping;
-    typedef std::unordered_map<DBusSignalMatchRuleTuple, DBusSignalMatchRuleMapping> DBusSignalMatchRulesMap;
+
     DBusSignalMatchRulesMap dbusSignalMatchRulesMap_;
 
     DBusSignalHandlerTable dbusSignalHandlerTable_;
diff --git a/src/CommonAPI/DBus/DBusEvent.h b/src/CommonAPI/DBus/DBusEvent.h
index 4bd235d..587ccfc 100644
--- a/src/CommonAPI/DBus/DBusEvent.h
+++ b/src/CommonAPI/DBus/DBusEvent.h
@@ -28,22 +28,23 @@ class DBusProxyBase;
 template <typename _EventType, typename _DBusProxy = DBusProxyBase>
 class DBusEvent: public _EventType, public DBusProxyConnection::DBusSignalHandler {
  public:
-	typedef typename _EventType::ArgumentsTuple ArgumentsTuple;
-	typedef typename _EventType::CancellableListener CancellableListener;
+    typedef typename _EventType::ArgumentsTuple ArgumentsTuple;
+    typedef typename _EventType::CancellableListener CancellableListener;
 
-	DBusEvent(_DBusProxy& dbusProxy, const char* eventName, const char* eventSignature):
-			dbusProxy_(dbusProxy),
-			eventName_(eventName),
-			eventSignature_(eventSignature) {
+
+    DBusEvent(_DBusProxy& dbusProxy, const char* eventName, const char* eventSignature):
+            dbusProxy_(dbusProxy),
+            eventName_(eventName),
+            eventSignature_(eventSignature) {
         interfaceName_ = dbusProxy.getInterfaceName().c_str();
         objectPath_ = dbusProxy_.getDBusObjectPath().c_str();
         assert(eventName_);
         assert(eventSignature_);
         assert(objectPath_);
         assert(interfaceName_);
-	}
+    }
 
-	DBusEvent(_DBusProxy& dbusProxy, const char* eventName, const char* eventSignature, const char* objPath, const char* interfaceName) :
+    DBusEvent(_DBusProxy& dbusProxy, const char* eventName, const char* eventSignature, const char* objPath, const char* interfaceName) :
                     dbusProxy_(dbusProxy),
                     eventName_(eventName),
                     eventSignature_(eventSignature),
@@ -55,29 +56,28 @@ class DBusEvent: public _EventType, public DBusProxyConnection::DBusSignalHandle
         assert(interfaceName);
     }
 
-	virtual ~DBusEvent() {
-		if (this->hasListeners())
-			dbusProxy_.removeSignalMemberHandler(subscription_);
-	}
-
-	virtual SubscriptionStatus onSignalDBusMessage(const DBusMessage& dbusMessage) {
-		return unpackArgumentsAndHandleSignalDBusMessage(dbusMessage, ArgumentsTuple());
-	}
+    virtual ~DBusEvent() {
+        if (this->hasListeners())
+            dbusProxy_.removeSignalMemberHandler(subscription_);
+    }
 
+    virtual SubscriptionStatus onSignalDBusMessage(const DBusMessage& dbusMessage) {
+        return unpackArgumentsAndHandleSignalDBusMessage(dbusMessage, ArgumentsTuple());
+    }
  protected:
-	virtual void onFirstListenerAdded(const CancellableListener&) {
-	 	subscription_ = dbusProxy_.addSignalMemberHandler(objectPath_, interfaceName_,
-	 	                eventName_, eventSignature_, this);
- 	}
+    virtual void onFirstListenerAdded(const CancellableListener&) {
+         subscription_ = dbusProxy_.addSignalMemberHandler(objectPath_, interfaceName_,
+                         eventName_, eventSignature_, this);
+     }
 
-	virtual void onLastListenerRemoved(const CancellableListener&) {
-	 	dbusProxy_.removeSignalMemberHandler(subscription_);
-	}
+    virtual void onLastListenerRemoved(const CancellableListener&) {
+        dbusProxy_.removeSignalMemberHandler(subscription_);
+    }
 
-	template <typename ... _Arguments>
-	inline SubscriptionStatus unpackArgumentsAndHandleSignalDBusMessage(const DBusMessage& dbusMessage, std::tuple<_Arguments...> argTuple) {
-		return handleSignalDBusMessage(dbusMessage, std::move(argTuple), typename make_sequence<sizeof...(_Arguments)>::type());
-	}
+    template <typename ... _Arguments>
+    inline SubscriptionStatus unpackArgumentsAndHandleSignalDBusMessage(const DBusMessage& dbusMessage, std::tuple<_Arguments...> argTuple) {
+        return handleSignalDBusMessage(dbusMessage, std::move(argTuple), typename make_sequence<sizeof...(_Arguments)>::type());
+    }
 
     template<typename ... _Arguments, int ... _ArgIndices>
     inline SubscriptionStatus handleSignalDBusMessage(const DBusMessage& dbusMessage,
@@ -91,12 +91,12 @@ class DBusEvent: public _EventType, public DBusProxyConnection::DBusSignalHandle
         return success ? this->notifyListeners(std::get<_ArgIndices>(argTuple)...) : SubscriptionStatus::RETAIN;
     }
 
- 	_DBusProxy& dbusProxy_;
-	const char* eventName_;
-	const char* eventSignature_;
-	const char* interfaceName_;
-	const char* objectPath_;
-	DBusProxyConnection::DBusSignalHandlerToken subscription_;
+    _DBusProxy& dbusProxy_;
+    const char* eventName_;
+    const char* eventSignature_;
+    const char* interfaceName_;
+    const char* objectPath_;
+    DBusProxyConnection::DBusSignalHandlerToken subscription_;
 };
 
 } // namespace DBus
diff --git a/src/CommonAPI/DBus/DBusMessage.cpp b/src/CommonAPI/DBus/DBusMessage.cpp
index 110584d..0180f58 100644
--- a/src/CommonAPI/DBus/DBusMessage.cpp
+++ b/src/CommonAPI/DBus/DBusMessage.cpp
@@ -13,75 +13,75 @@ namespace CommonAPI {
 namespace DBus {
 
 DBusMessage::DBusMessage():
-		libdbusMessage_(NULL) {
+        libdbusMessage_(NULL) {
 }
 
 DBusMessage::DBusMessage(::DBusMessage* libdbusMessage) {
-	libdbusMessage_ = libdbusMessage != NULL ? dbus_message_ref(libdbusMessage) : NULL;
+    libdbusMessage_ = libdbusMessage != NULL ? dbus_message_ref(libdbusMessage) : NULL;
 }
 
 DBusMessage::DBusMessage(::DBusMessage* libdbusMessage, bool increaseReferenceCount) {
-	assert(libdbusMessage);
+    assert(libdbusMessage);
 
-	libdbusMessage_ = increaseReferenceCount ? dbus_message_ref(libdbusMessage) : libdbusMessage;
+    libdbusMessage_ = increaseReferenceCount ? dbus_message_ref(libdbusMessage) : libdbusMessage;
 }
 
 DBusMessage::DBusMessage(const DBusMessage& src) {
-	libdbusMessage_ = src.libdbusMessage_ != NULL ? dbus_message_ref(src.libdbusMessage_) : NULL;
+    libdbusMessage_ = src.libdbusMessage_ != NULL ? dbus_message_ref(src.libdbusMessage_) : NULL;
 }
 
 DBusMessage::DBusMessage(DBusMessage&& rsrc) {
-	libdbusMessage_ = rsrc.libdbusMessage_;
-	rsrc.libdbusMessage_ = NULL;
+    libdbusMessage_ = rsrc.libdbusMessage_;
+    rsrc.libdbusMessage_ = NULL;
 }
 
 DBusMessage::~DBusMessage() {
-	if (libdbusMessage_)
-		dbus_message_unref(libdbusMessage_);
+    if (libdbusMessage_)
+        dbus_message_unref(libdbusMessage_);
 }
 
 DBusMessage& DBusMessage::operator=(const DBusMessage& src) {
-	if (this != &src) {
-		if (libdbusMessage_)
-			dbus_message_unref(libdbusMessage_);
+    if (this != &src) {
+        if (libdbusMessage_)
+            dbus_message_unref(libdbusMessage_);
 
-		libdbusMessage_ = src.libdbusMessage_ != NULL ? dbus_message_ref(src.libdbusMessage_) : NULL;
-	}
+        libdbusMessage_ = src.libdbusMessage_ != NULL ? dbus_message_ref(src.libdbusMessage_) : NULL;
+    }
 
-	return *this;
+    return *this;
 }
 
 DBusMessage& DBusMessage::operator=(DBusMessage&& rsrc) {
-	if (this != &rsrc) {
-		if (libdbusMessage_)
-			dbus_message_unref(libdbusMessage_);
+    if (this != &rsrc) {
+        if (libdbusMessage_)
+            dbus_message_unref(libdbusMessage_);
 
-		libdbusMessage_ = rsrc.libdbusMessage_;
-		rsrc.libdbusMessage_ = NULL;
-	}
+        libdbusMessage_ = rsrc.libdbusMessage_;
+        rsrc.libdbusMessage_ = NULL;
+    }
 
-	return *this;
+    return *this;
 }
 
 DBusMessage::operator bool() const {
-	const bool isNotNullDBusMessage = (libdbusMessage_ != NULL);
-	return isNotNullDBusMessage;
+    const bool isNotNullDBusMessage = (libdbusMessage_ != NULL);
+    return isNotNullDBusMessage;
 }
 
 DBusMessage DBusMessage::createOrgFreedesktopOrgMethodCall(const char* methodName, const char* signature) {
-	return DBusMessage::createMethodCall("org.freedesktop.DBus",
-										 "/",
-										 "org.freedesktop.DBus",
-										 methodName,
-										 signature);
+    return DBusMessage::createMethodCall("org.freedesktop.DBus",
+                                         "/",
+                                         "org.freedesktop.DBus",
+                                         methodName,
+                                         signature);
 }
 
 DBusMessage DBusMessage::createOrgFreedesktopOrgMethodCall(const std::string& methodName,
-														   const std::string& signature) {
-	assert(!methodName.empty());
+                                                           const std::string& signature) {
+    assert(!methodName.empty());
 
-	return createOrgFreedesktopOrgMethodCall(methodName.c_str(),
-											 signature.empty() ? NULL : signature.c_str());
+    return createOrgFreedesktopOrgMethodCall(methodName.c_str(),
+                                             signature.empty() ? NULL : signature.c_str());
 }
 
 DBusMessage DBusMessage::createMethodCall(const char* busName,
@@ -89,54 +89,54 @@ DBusMessage DBusMessage::createMethodCall(const char* busName,
                                           const char* interfaceName,
                                           const char* methodName,
                                           const char* signature) {
-	assert(busName);
-	assert(objectPath);
-	assert(interfaceName);
-	assert(methodName);
+    assert(busName);
+    assert(objectPath);
+    assert(interfaceName);
+    assert(methodName);
 
-	::DBusMessage* libdbusMessageCall = dbus_message_new_method_call(busName,
-																	 objectPath,
-																	 interfaceName,
-																	 methodName);
-	assert(libdbusMessageCall);
+    ::DBusMessage* libdbusMessageCall = dbus_message_new_method_call(busName,
+                                                                     objectPath,
+                                                                     interfaceName,
+                                                                     methodName);
+    assert(libdbusMessageCall);
 
-	if (signature)
-		dbus_message_set_signature(libdbusMessageCall, signature);
+    if (signature)
+        dbus_message_set_signature(libdbusMessageCall, signature);
 
-	const bool increaseLibdbusMessageReferenceCount = false;
-	return DBusMessage(libdbusMessageCall, increaseLibdbusMessageReferenceCount);
+    const bool increaseLibdbusMessageReferenceCount = false;
+    return DBusMessage(libdbusMessageCall, increaseLibdbusMessageReferenceCount);
 }
 
 DBusMessage DBusMessage::createMethodCall(const std::string& busName,
-										  const std::string& objectPath,
-										  const std::string& interfaceName,
-										  const std::string& methodName,
-										  const std::string& signature) {
-	assert(!busName.empty());
-	assert(!objectPath.empty());
-	assert(!interfaceName.empty());
-	assert(!methodName.empty());
-
-	return createMethodCall(busName.c_str(),
-							objectPath.c_str(),
-							interfaceName.c_str(),
-							methodName.c_str(),
-							signature.empty() ? NULL : signature.c_str());
+                                          const std::string& objectPath,
+                                          const std::string& interfaceName,
+                                          const std::string& methodName,
+                                          const std::string& signature) {
+    assert(!busName.empty());
+    assert(!objectPath.empty());
+    assert(!interfaceName.empty());
+    assert(!methodName.empty());
+
+    return createMethodCall(busName.c_str(),
+                            objectPath.c_str(),
+                            interfaceName.c_str(),
+                            methodName.c_str(),
+                            signature.empty() ? NULL : signature.c_str());
 }
 
 DBusMessage DBusMessage::createMethodReturn(const char* signature) const {
-	::DBusMessage* libdbusMessageReturn = dbus_message_new_method_return(libdbusMessage_);
-	assert(libdbusMessageReturn);
+    ::DBusMessage* libdbusMessageReturn = dbus_message_new_method_return(libdbusMessage_);
+    assert(libdbusMessageReturn);
 
-	if (signature)
-		dbus_message_set_signature(libdbusMessageReturn, signature);
+    if (signature)
+        dbus_message_set_signature(libdbusMessageReturn, signature);
 
-	const bool increaseLibdbusMessageReferenceCount = false;
-	return DBusMessage(libdbusMessageReturn, increaseLibdbusMessageReferenceCount);
+    const bool increaseLibdbusMessageReferenceCount = false;
+    return DBusMessage(libdbusMessageReturn, increaseLibdbusMessageReferenceCount);
 }
 
 DBusMessage DBusMessage::createMethodReturn(const std::string& signature) const {
-	return createMethodReturn(signature.empty() ? NULL : signature.c_str());
+    return createMethodReturn(signature.empty() ? NULL : signature.c_str());
 }
 
 DBusMessage DBusMessage::createMethodError(const std::string& name, const std::string& reason) const {
@@ -151,60 +151,64 @@ DBusMessage DBusMessage::createSignal(const char* objectPath,
                                       const char* interfaceName,
                                       const char* signalName,
                                       const char* signature) {
-	assert(objectPath);
-	assert(interfaceName);
-	assert(signalName);
+    assert(objectPath);
+    assert(interfaceName);
+    assert(signalName);
 
-	::DBusMessage* libdbusMessageSignal = dbus_message_new_signal(objectPath,
-																  interfaceName,
-																  signalName);
-	assert(libdbusMessageSignal);
+    ::DBusMessage* libdbusMessageSignal = dbus_message_new_signal(objectPath,
+                                                                  interfaceName,
+                                                                  signalName);
+    assert(libdbusMessageSignal);
 
-	if (signature)
-		dbus_message_set_signature(libdbusMessageSignal, signature);
+    if (signature)
+        dbus_message_set_signature(libdbusMessageSignal, signature);
 
-	const bool increaseLibdbusMessageReferenceCount = false;
-	return DBusMessage(libdbusMessageSignal, increaseLibdbusMessageReferenceCount);
+    const bool increaseLibdbusMessageReferenceCount = false;
+    return DBusMessage(libdbusMessageSignal, increaseLibdbusMessageReferenceCount);
 }
 
 DBusMessage DBusMessage::createSignal(const std::string& objectPath,
-									  const std::string& interfaceName,
-									  const std::string& signalName,
-									  const std::string& signature) {
-	assert(!objectPath.empty());
-	assert(!interfaceName.empty());
-	assert(!signalName.empty());
+                                      const std::string& interfaceName,
+                                      const std::string& signalName,
+                                      const std::string& signature) {
+    assert(!objectPath.empty());
+    assert(!interfaceName.empty());
+    assert(!signalName.empty());
 
-	return createSignal(objectPath.c_str(),
-						interfaceName.c_str(),
-						signalName.c_str(),
-						signature.empty() ? NULL : signature.c_str());
+    return createSignal(objectPath.c_str(),
+                        interfaceName.c_str(),
+                        signalName.c_str(),
+                        signature.empty() ? NULL : signature.c_str());
 }
 
 const char* DBusMessage::getObjectPath() const {
-	return dbus_message_get_path(libdbusMessage_);
+    return dbus_message_get_path(libdbusMessage_);
 }
 
 const char* DBusMessage::getSenderName() const {
-	return dbus_message_get_sender(libdbusMessage_);
+    return dbus_message_get_sender(libdbusMessage_);
 }
 
 const char* DBusMessage::getInterfaceName() const {
-	return dbus_message_get_interface(libdbusMessage_);
+    return dbus_message_get_interface(libdbusMessage_);
 }
 
 const char* DBusMessage::getMemberName() const {
-	return dbus_message_get_member(libdbusMessage_);
+    return dbus_message_get_member(libdbusMessage_);
 }
 
 const char* DBusMessage::getSignatureString() const {
-	return dbus_message_get_signature(libdbusMessage_);
+    return dbus_message_get_signature(libdbusMessage_);
 }
 
 const char* DBusMessage::getErrorName() const {
-	assert(isErrorType());
+    assert(isErrorType());
+
+    return dbus_message_get_error_name(libdbusMessage_);
+}
 
-	return dbus_message_get_error_name(libdbusMessage_);
+const char* DBusMessage::getDestination() const {
+    return dbus_message_get_destination(libdbusMessage_);
 }
 
 bool DBusMessage::hasObjectPath(const char* objectPath) const {
@@ -235,33 +239,38 @@ bool DBusMessage::hasMemberName(const char* memberName) const {
 }
 
 bool DBusMessage::hasSignature(const char* signature) const {
-	const char* dbusMessageSignature = getSignatureString();
+    const char* dbusMessageSignature = getSignatureString();
 
-	assert(signature);
-	assert(dbusMessageSignature);
+    assert(signature);
+    assert(dbusMessageSignature);
 
-	return !strcmp(dbusMessageSignature, signature);
+    return !strcmp(dbusMessageSignature, signature);
 }
 
 const DBusMessage::Type DBusMessage::getType() const {
-	const int libdbusType = dbus_message_get_type(libdbusMessage_);
-	return static_cast<Type>(libdbusType);
+    const int libdbusType = dbus_message_get_type(libdbusMessage_);
+    return static_cast<Type>(libdbusType);
 }
 
 char* DBusMessage::getBodyData() const {
-	return dbus_message_get_body(libdbusMessage_);
+    return dbus_message_get_body(libdbusMessage_);
 }
 
 int DBusMessage::getBodyLength() const {
-	return dbus_message_get_body_length(libdbusMessage_);
+    return dbus_message_get_body_length(libdbusMessage_);
 }
 
 int DBusMessage::getBodySize() const {
-	return dbus_message_get_body_allocated(libdbusMessage_);
+    return dbus_message_get_body_allocated(libdbusMessage_);
 }
 
 bool DBusMessage::setBodyLength(const int bodyLength) {
-	return dbus_message_set_body_length(libdbusMessage_, bodyLength);
+    return dbus_message_set_body_length(libdbusMessage_, bodyLength);
+}
+
+bool DBusMessage::setDestination(const char* destination)
+{
+    return dbus_message_set_destination(libdbusMessage_, destination);
 }
 
 } // namespace DBus
diff --git a/src/CommonAPI/DBus/DBusMessage.h b/src/CommonAPI/DBus/DBusMessage.h
index 839ff64..3b30ad0 100644
--- a/src/CommonAPI/DBus/DBusMessage.h
+++ b/src/CommonAPI/DBus/DBusMessage.h
@@ -23,90 +23,92 @@ class DBusConnection;
 
 class DBusMessage {
  public:
-	DBusMessage();
-	DBusMessage(::DBusMessage* libdbusMessage);
-	DBusMessage(::DBusMessage* libdbusMessage, bool increaseReferenceCount);
-	DBusMessage(const DBusMessage& src);
-	DBusMessage(DBusMessage&& src);
+    DBusMessage();
+    DBusMessage(::DBusMessage* libdbusMessage);
+    DBusMessage(::DBusMessage* libdbusMessage, bool increaseReferenceCount);
+    DBusMessage(const DBusMessage& src);
+    DBusMessage(DBusMessage&& src);
 
-	~DBusMessage();
+    ~DBusMessage();
 
-	DBusMessage& operator=(const DBusMessage& src);
-	DBusMessage& operator=(DBusMessage&& rsrc);
-	operator bool() const;
+    DBusMessage& operator=(const DBusMessage& src);
+    DBusMessage& operator=(DBusMessage&& rsrc);
+    operator bool() const;
 
-	static DBusMessage createOrgFreedesktopOrgMethodCall(const char* methodName,
-			                                             const char* signature = NULL);
+    static DBusMessage createOrgFreedesktopOrgMethodCall(const char* methodName,
+                                                         const char* signature = NULL);
 
-	static DBusMessage createOrgFreedesktopOrgMethodCall(const std::string& methodName,
-														 const std::string& signature = "");
+    static DBusMessage createOrgFreedesktopOrgMethodCall(const std::string& methodName,
+                                                         const std::string& signature = "");
 
-	static DBusMessage createMethodCall(const char* busName,
+    static DBusMessage createMethodCall(const char* busName,
                                         const char* objectPath,
                                         const char* interfaceName,
                                         const char* methodName,
                                         const char* signature = NULL);
 
-	static DBusMessage createMethodCall(const std::string& busName,
-										const std::string& objectPath,
-										const std::string& interfaceName,
-										const std::string& methodName,
-										const std::string& signature = "");
+    static DBusMessage createMethodCall(const std::string& busName,
+                                        const std::string& objectPath,
+                                        const std::string& interfaceName,
+                                        const std::string& methodName,
+                                        const std::string& signature = "");
 
-	DBusMessage createMethodReturn(const char* signature = NULL) const;
+    DBusMessage createMethodReturn(const char* signature = NULL) const;
 
-	DBusMessage createMethodReturn(const std::string& signature) const;
+    DBusMessage createMethodReturn(const std::string& signature) const;
 
     DBusMessage createMethodError(const std::string& name, const std::string& reason = "") const;
 
-	static DBusMessage createSignal(const char* objectPath,
-			                        const char* interfaceName,
-			                        const char* signalName,
-			                        const char* signature = NULL);
+    static DBusMessage createSignal(const char* objectPath,
+                                    const char* interfaceName,
+                                    const char* signalName,
+                                    const char* signature = NULL);
 
-	static DBusMessage createSignal(const std::string& objectPath,
-									const std::string& interfaceName,
-									const std::string& signalName,
-									const std::string& signature = "");
+    static DBusMessage createSignal(const std::string& objectPath,
+                                    const std::string& interfaceName,
+                                    const std::string& signalName,
+                                    const std::string& signature = "");
 
-	const char* getSenderName() const;
-	const char* getObjectPath() const;
-	const char* getInterfaceName() const;
-	const char* getMemberName() const;
-	const char* getSignatureString() const;
-	const char* getErrorName() const;
+    const char* getSenderName() const;
+    const char* getObjectPath() const;
+    const char* getInterfaceName() const;
+    const char* getMemberName() const;
+    const char* getSignatureString() const;
+    const char* getErrorName() const;
+    const char* getDestination() const;
 
-	inline bool hasObjectPath(const std::string& objectPath) const;
+    inline bool hasObjectPath(const std::string& objectPath) const;
 
-	bool hasObjectPath(const char* objectPath) const;
+    bool hasObjectPath(const char* objectPath) const;
     bool hasInterfaceName(const char* interfaceName) const;
-	bool hasMemberName(const char* memberName) const;
-	bool hasSignature(const char* signature) const;
-
-	enum class Type: int {
-		Invalid = DBUS_MESSAGE_TYPE_INVALID,
-		MethodCall = DBUS_MESSAGE_TYPE_METHOD_CALL,
-		MethodReturn = DBUS_MESSAGE_TYPE_METHOD_RETURN,
-		Error = DBUS_MESSAGE_TYPE_ERROR,
-		Signal = DBUS_MESSAGE_TYPE_SIGNAL
-	};
-	const Type getType() const;
-	inline bool isInvalidType() const;
-	inline bool isMethodCallType() const;
-	inline bool isMethodReturnType() const;
-	inline bool isErrorType() const;
-	inline bool isSignalType() const;
-
-	char* getBodyData() const;
-	int getBodyLength() const;
-	int getBodySize() const;
-
-	bool setBodyLength(const int bodyLength);
+    bool hasMemberName(const char* memberName) const;
+    bool hasSignature(const char* signature) const;
+
+    enum class Type: int {
+        Invalid = DBUS_MESSAGE_TYPE_INVALID,
+        MethodCall = DBUS_MESSAGE_TYPE_METHOD_CALL,
+        MethodReturn = DBUS_MESSAGE_TYPE_METHOD_RETURN,
+        Error = DBUS_MESSAGE_TYPE_ERROR,
+        Signal = DBUS_MESSAGE_TYPE_SIGNAL
+    };
+    const Type getType() const;
+    inline bool isInvalidType() const;
+    inline bool isMethodCallType() const;
+    inline bool isMethodReturnType() const;
+    inline bool isErrorType() const;
+    inline bool isSignalType() const;
+
+    char* getBodyData() const;
+    int getBodyLength() const;
+    int getBodySize() const;
+
+    bool setBodyLength(const int bodyLength);
+    bool setDestination(const char* destination);
 
  private:
-	::DBusMessage* libdbusMessage_;
+    ::DBusMessage* libdbusMessage_;
 
-	friend class DBusConnection;
+    friend class DBusConnection;
 };
 
 bool DBusMessage::hasObjectPath(const std::string& objectPath) const {
@@ -114,23 +116,23 @@ bool DBusMessage::hasObjectPath(const std::string& objectPath) const {
 }
 
 bool DBusMessage::isInvalidType() const {
-	return (getType() == Type::Invalid);
+    return (getType() == Type::Invalid);
 }
 
 bool DBusMessage::isMethodCallType() const {
-	return (getType() == Type::MethodCall);
+    return (getType() == Type::MethodCall);
 }
 
 bool DBusMessage::isMethodReturnType() const {
-	return (getType() == Type::MethodReturn);
+    return (getType() == Type::MethodReturn);
 }
 
 bool DBusMessage::isErrorType() const {
-	return (getType() == Type::Error);
+    return (getType() == Type::Error);
 }
 
 bool DBusMessage::isSignalType() const {
-	return (getType() == Type::Signal);
+    return (getType() == Type::Signal);
 }
 
 } // namespace DBus
diff --git a/src/CommonAPI/DBus/DBusProxy.cpp b/src/CommonAPI/DBus/DBusProxy.cpp
index afe4f65..fe7679a 100644
--- a/src/CommonAPI/DBus/DBusProxy.cpp
+++ b/src/CommonAPI/DBus/DBusProxy.cpp
@@ -117,5 +117,28 @@ std::string DBusProxy::getAddress() const {
     return commonApiDomain_ + ":" + commonApiServiceId_ + ":" + commonApiParticipantId_;
 }
 
+DBusProxyConnection::DBusSignalHandlerToken DBusProxy::subscribeForSelectiveBroadcastOnConnection(
+                                                      bool& subscriptionAccepted,
+                                                      const std::string& objectPath,
+                                                      const std::string& interfaceName,
+                                                      const std::string& interfaceMemberName,
+                                                      const std::string& interfaceMemberSignature,
+                                                      DBusProxyConnection::DBusSignalHandler* dbusSignalHandler) {
+
+    return getDBusConnection()->subscribeForSelectiveBroadcast(
+                    subscriptionAccepted,
+                    objectPath,
+                    interfaceName,
+                    interfaceMemberName,
+                    interfaceMemberSignature,
+                    dbusSignalHandler,
+                    this);
+}
+
+void DBusProxy::unsubsribeFromSelectiveBroadcast(const std::string& eventName,
+                                                 DBusProxyConnection::DBusSignalHandlerToken subscription) {
+    getDBusConnection()->unsubsribeFromSelectiveBroadcast(eventName, subscription, this);
+}
+
 } // namespace DBus
 } // namespace CommonAPI
diff --git a/src/CommonAPI/DBus/DBusProxy.h b/src/CommonAPI/DBus/DBusProxy.h
index 253f0bb..128e1c1 100644
--- a/src/CommonAPI/DBus/DBusProxy.h
+++ b/src/CommonAPI/DBus/DBusProxy.h
@@ -61,7 +61,15 @@ class DBusProxy: public DBusProxyBase {
     virtual const std::string& getDBusBusName() const;
     virtual const std::string& getDBusObjectPath() const;
     virtual const std::string& getInterfaceName() const;
-
+    DBusProxyConnection::DBusSignalHandlerToken subscribeForSelectiveBroadcastOnConnection(
+              bool& subscriptionAccepted,
+              const std::string& objectPath,
+              const std::string& interfaceName,
+              const std::string& interfaceMemberName,
+              const std::string& interfaceMemberSignature,
+              DBusProxyConnection::DBusSignalHandler* dbusSignalHandler);
+    void unsubsribeFromSelectiveBroadcast(const std::string& eventName,
+                                          DBusProxyConnection::DBusSignalHandlerToken subscription);
  private:
     DBusProxy(const DBusProxy&) = delete;
 
diff --git a/src/CommonAPI/DBus/DBusProxyBase.h b/src/CommonAPI/DBus/DBusProxyBase.h
index c995a1c..ea79a2a 100644
--- a/src/CommonAPI/DBus/DBusProxyBase.h
+++ b/src/CommonAPI/DBus/DBusProxyBase.h
@@ -42,19 +42,20 @@ class DBusProxyBase: public virtual CommonAPI::Proxy {
                                  const char* methodSignature = NULL) const;
 
     inline DBusProxyConnection::DBusSignalHandlerToken addSignalMemberHandler(
-    		const std::string& signalName,
-    		const std::string& signalSignature,
-    		DBusProxyConnection::DBusSignalHandler* dbusSignalHandler);
+            const std::string& signalName,
+            const std::string& signalSignature,
+            DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
+            const bool justAddFilter = false);
 
     inline DBusProxyConnection::DBusSignalHandlerToken addSignalMemberHandler(
                 const std::string& objectPath,
                 const std::string& interfaceName,
                 const std::string& signalName,
                 const std::string& signalSignature,
-                DBusProxyConnection::DBusSignalHandler* dbusSignalHandler);
-
-    inline void removeSignalMemberHandler(const DBusProxyConnection::DBusSignalHandlerToken& dbusSignalHandlerToken);
+                DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
+                const bool justAddFilter = false);
 
+    inline bool removeSignalMemberHandler(const DBusProxyConnection::DBusSignalHandlerToken& dbusSignalHandlerToken);
  protected:
     const std::string commonApiDomain_;
 
@@ -71,13 +72,15 @@ const std::shared_ptr<DBusProxyConnection>& DBusProxyBase::getDBusConnection() c
 DBusProxyConnection::DBusSignalHandlerToken DBusProxyBase::addSignalMemberHandler(
         const std::string& signalName,
         const std::string& signalSignature,
-        DBusProxyConnection::DBusSignalHandler* dbusSignalHandler) {
+        DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
+        const bool justAddFilter) {
     return addSignalMemberHandler(
             getDBusObjectPath(),
             getInterfaceName(),
             signalName,
             signalSignature,
-            dbusSignalHandler);
+            dbusSignalHandler,
+            justAddFilter);
 }
 
 DBusProxyConnection::DBusSignalHandlerToken DBusProxyBase::addSignalMemberHandler(
@@ -85,19 +88,22 @@ DBusProxyConnection::DBusSignalHandlerToken DBusProxyBase::addSignalMemberHandle
                 const std::string& interfaceName,
                 const std::string& signalName,
                 const std::string& signalSignature,
-                DBusProxyConnection::DBusSignalHandler* dbusSignalHandler) {
+                DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
+                const bool justAddFilter) {
     return dbusConnection_->addSignalMemberHandler(
                 objectPath,
                 interfaceName,
                 signalName,
                 signalSignature,
-                dbusSignalHandler);
+                dbusSignalHandler,
+                justAddFilter);
 }
 
-void DBusProxyBase::removeSignalMemberHandler(const DBusProxyConnection::DBusSignalHandlerToken& dbusSignalHandlerToken) {
+bool DBusProxyBase::removeSignalMemberHandler(const DBusProxyConnection::DBusSignalHandlerToken& dbusSignalHandlerToken) {
     return dbusConnection_->removeSignalMemberHandler(dbusSignalHandlerToken);
 }
 
+
 } // namespace DBus
 } // namespace CommonAPI
 
diff --git a/src/CommonAPI/DBus/DBusProxyConnection.h b/src/CommonAPI/DBus/DBusProxyConnection.h
index bd117a0..bce9e37 100644
--- a/src/CommonAPI/DBus/DBusProxyConnection.h
+++ b/src/CommonAPI/DBus/DBusProxyConnection.h
@@ -40,6 +40,7 @@ typedef std::function<void(const DBusMessage&)> DBusMessageHandler;
 class DBusDaemonProxy;
 class DBusServiceRegistry;
 class DBusObjectManager;
+class DBusProxy;
 
 
 class DBusProxyConnection {
@@ -90,9 +91,21 @@ class DBusProxyConnection {
             const std::string& interfaceName,
             const std::string& interfaceMemberName,
             const std::string& interfaceMemberSignature,
-            DBusSignalHandler* dbusSignalHandler) = 0;
-
-    virtual void removeSignalMemberHandler(const DBusSignalHandlerToken& dbusSignalHandlerToken) = 0;
+            DBusSignalHandler* dbusSignalHandler,
+            const bool justAddFilter = false) = 0;
+
+    virtual DBusSignalHandlerToken subscribeForSelectiveBroadcast(bool& subscriptionAccepted,
+                                                                  const std::string& objectPath,
+                                                                  const std::string& interfaceName,
+                                                                  const std::string& interfaceMemberName,
+                                                                  const std::string& interfaceMemberSignature,
+                                                                  DBusSignalHandler* dbusSignalHandler,
+                                                                  DBusProxy* callingProxy) = 0;
+
+    virtual void unsubsribeFromSelectiveBroadcast(const std::string& eventName,
+                                                  DBusProxyConnection::DBusSignalHandlerToken subscription,
+                                                  DBusProxy* callingProxy) = 0;
+    virtual bool removeSignalMemberHandler(const DBusSignalHandlerToken& dbusSignalHandlerToken) = 0;
 
     virtual const std::shared_ptr<DBusServiceRegistry> getDBusServiceRegistry() = 0;
     virtual const std::shared_ptr<DBusObjectManager> getDBusObjectManager() = 0;
diff --git a/src/CommonAPI/DBus/DBusSelectiveEvent.h b/src/CommonAPI/DBus/DBusSelectiveEvent.h
new file mode 100644
index 0000000..e3f2484
--- /dev/null
+++ b/src/CommonAPI/DBus/DBusSelectiveEvent.h
@@ -0,0 +1,98 @@
+/* Copyright (C) 2013 BMW Group
+ * Author: Manfred Bathelt (manfred.bathelt@bmw.de)
+ * Author: Juergen Gehring (juergen.gehring@bmw.de)
+ * 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/. */
+
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#error "Only <CommonAPI/CommonAPI.h> can be included directly, this file may disappear or change contents."
+#endif
+
+#ifndef COMMONAPI_DBUS_DBUS_SELECTIVE_EVENT_H_
+#define COMMONAPI_DBUS_DBUS_SELECTIVE_EVENT_H_
+
+#include "DBusEvent.h"
+
+namespace CommonAPI {
+namespace DBus {
+
+template<typename _EventType, typename _DBusProxy = DBusProxyBase>
+class DBusSelectiveEvent: public DBusEvent<_EventType, _DBusProxy> {
+public:
+    typedef typename DBusEvent<_EventType, _DBusProxy>::CancellableListener CancellableListener;
+    typedef DBusEvent<_EventType, _DBusProxy> DBusEventBase;
+
+    DBusSelectiveEvent(DBusProxy& associatedDbusProxy,
+                       const char* eventName,
+                       const char* eventSignature) :
+                    DBusEventBase(associatedDbusProxy, eventName, eventSignature),
+                    associatedDbusProxy_(associatedDbusProxy) {
+    }
+
+    DBusSelectiveEvent(DBusProxy& associatedDbusProxy, const char* eventName,
+                       const char* eventSignature,
+                       const char* objPath,
+                       const char* interfaceName) :
+
+                    DBusEvent<_EventType, _DBusProxy>(
+                                    associatedDbusProxy,
+                                    eventName,
+                                    eventSignature,
+                                    objPath,
+                                    interfaceName),
+                    associatedDbusProxy_(associatedDbusProxy) {
+    }
+
+    virtual ~DBusSelectiveEvent() { }
+
+    typename _EventType::Subscription subscribe(typename _EventType::Listener listener, bool& success) {
+
+        DBusEventBase::listenerListMutex_.lock();
+        const bool firstListenerAdded = DBusEventBase::listenersList_.empty();
+
+        typename _EventType::CancellableListenerWrapper wrappedListener(std::move(listener));
+        DBusEventBase::listenersList_.emplace_front(std::move(wrappedListener));
+        typename _EventType::Subscription listenerSubscription = DBusEventBase::listenersList_.begin();
+
+        success = true;
+        DBusProxyConnection::DBusSignalHandlerToken dbusSignalHandlerToken;
+
+        if (firstListenerAdded) {
+            dbusSignalHandlerToken = associatedDbusProxy_.subscribeForSelectiveBroadcastOnConnection(
+                            success,
+                            DBusEventBase::objectPath_,
+                            DBusEventBase::interfaceName_,
+                            DBusEventBase::eventName_,
+                            DBusEventBase::eventSignature_,
+                            this
+                            );
+        }
+
+        if (success) {
+            // actually add subscription
+            DBusEventBase::subscription_ = dbusSignalHandlerToken;
+            this->onListenerAdded(*listenerSubscription);
+        }
+        else {
+            DBusEventBase::listenersList_.erase(listenerSubscription);
+            listenerSubscription = DBusEventBase::listenersList_.end();
+        }
+        DBusEventBase::listenerListMutex_.unlock();
+
+        return listenerSubscription;
+    }
+
+protected:
+    virtual void onLastListenerRemoved(const CancellableListener&) {
+        associatedDbusProxy_.unsubsribeFromSelectiveBroadcast(DBusEventBase::eventName_, DBusEventBase::subscription_);
+    }
+
+private:
+    DBusProxy& associatedDbusProxy_;
+};
+
+} // namespace DBus
+} // namespace CommonAPI
+
+#endif // COMMONAPI_DBUS_DBUS_SELECTIVE_EVENT_H_
diff --git a/src/CommonAPI/DBus/DBusStubAdapter.h b/src/CommonAPI/DBus/DBusStubAdapter.h
index 5bac530..a9646fd 100644
--- a/src/CommonAPI/DBus/DBusStubAdapter.h
+++ b/src/CommonAPI/DBus/DBusStubAdapter.h
@@ -49,8 +49,7 @@ class DBusStubAdapter: virtual public CommonAPI::StubAdapter {
 
     virtual const char* getMethodsDBusIntrospectionXmlData() const = 0;
     virtual bool onInterfaceDBusMessage(const DBusMessage& dbusMessage) = 0;
-
- private:
+private:
     const std::string commonApiDomain_;
     const std::string commonApiServiceId_;
     const std::string commonApiParticipantId_;
diff --git a/src/CommonAPI/DBus/DBusStubAdapterHelper.h b/src/CommonAPI/DBus/DBusStubAdapterHelper.h
index 71fcd5d..650230c 100644
--- a/src/CommonAPI/DBus/DBusStubAdapterHelper.h
+++ b/src/CommonAPI/DBus/DBusStubAdapterHelper.h
@@ -52,7 +52,7 @@ class DBusStubAdapterHelper: public DBusStubAdapter, public std::enable_shared_f
 
     virtual ~DBusStubAdapterHelper() {
         DBusStubAdapter::deinit();
-    	stub_.reset();
+        stub_.reset();
     }
 
     virtual void init() {
@@ -62,7 +62,7 @@ class DBusStubAdapterHelper: public DBusStubAdapter, public std::enable_shared_f
 
     virtual void deinit() {
         DBusStubAdapter::deinit();
-    	stub_.reset();
+        stub_.reset();
     }
 
     inline std::shared_ptr<StubAdapterType> getStubAdapter() {
@@ -147,7 +147,7 @@ template <
 class DBusMethodStubDispatcher<_StubClass, _In<_InArgs...> >: public DBusStubAdapterHelper<_StubClass>::StubDispatcher {
  public:
     typedef DBusStubAdapterHelper<_StubClass> DBusStubAdapterHelperType;
-    typedef void (_StubClass::*_StubFunctor)(CommonAPI::ClientId&, _InArgs...);
+    typedef void (_StubClass::*_StubFunctor)(std::shared_ptr<CommonAPI::ClientId>, _InArgs...);
 
     DBusMethodStubDispatcher(_StubFunctor stubFunctor):
             stubFunctor_(stubFunctor) {
@@ -160,7 +160,7 @@ class DBusMethodStubDispatcher<_StubClass, _In<_InArgs...> >: public DBusStubAda
  private:
     template <int... _InArgIndices, int... _OutArgIndices>
     inline bool handleDBusMessage(const DBusMessage& dbusMessage,
-    							  const std::shared_ptr<_StubClass>& stub,
+                                  const std::shared_ptr<_StubClass>& stub,
                                   DBusStubAdapterHelperType& dbusStubAdapterHelper,
                                   index_sequence<_InArgIndices...>) const {
         std::tuple<_InArgs...> argTuple;
@@ -172,7 +172,7 @@ class DBusMethodStubDispatcher<_StubClass, _In<_InArgs...> >: public DBusStubAda
                 return false;
         }
 
-        const DBusClientId clientId = DBusClientId(std::string(dbusMessage.getSenderName()));
+        std::shared_ptr<DBusClientId> clientId = std::make_shared<DBusClientId>(std::string(dbusMessage.getSenderName()));
 
         (stub.get()->*stubFunctor_)(clientId, std::move(std::get<_InArgIndices>(argTuple))...);
 
@@ -194,7 +194,7 @@ class DBusMethodWithReplyStubDispatcher<_StubClass, _In<_InArgs...>, _Out<_OutAr
             public DBusStubAdapterHelper<_StubClass>::StubDispatcher {
  public:
     typedef DBusStubAdapterHelper<_StubClass> DBusStubAdapterHelperType;
-    typedef void (_StubClass::*_StubFunctor)(const CommonAPI::ClientId&, _InArgs..., _OutArgs&...);
+    typedef void (_StubClass::*_StubFunctor)(std::shared_ptr<CommonAPI::ClientId>, _InArgs..., _OutArgs&...);
 
     DBusMethodWithReplyStubDispatcher(_StubFunctor stubFunctor, const char* dbusReplySignature):
             stubFunctor_(stubFunctor),
@@ -213,7 +213,7 @@ class DBusMethodWithReplyStubDispatcher<_StubClass, _In<_InArgs...>, _Out<_OutAr
  private:
     template <int... _InArgIndices, int... _OutArgIndices>
     inline bool handleDBusMessage(const DBusMessage& dbusMessage,
-    							  const std::shared_ptr<_StubClass>& stub,
+                                  const std::shared_ptr<_StubClass>& stub,
                                   DBusStubAdapterHelperType& dbusStubAdapterHelper,
                                   index_sequence<_InArgIndices...>,
                                   index_sequence<_OutArgIndices...>) const {
@@ -226,7 +226,7 @@ class DBusMethodWithReplyStubDispatcher<_StubClass, _In<_InArgs...>, _Out<_OutAr
                 return false;
         }
 
-        const DBusClientId clientId = DBusClientId(std::string(dbusMessage.getSenderName()));
+        std::shared_ptr<DBusClientId> clientId = std::make_shared<DBusClientId>(std::string(dbusMessage.getSenderName()));
 
         (stub.get()->*stubFunctor_)(clientId, std::move(std::get<_InArgIndices>(argTuple))..., std::get<_OutArgIndices>(argTuple)...);
 
@@ -248,12 +248,77 @@ class DBusMethodWithReplyStubDispatcher<_StubClass, _In<_InArgs...>, _Out<_OutAr
     const char* dbusReplySignature_;
 };
 
+template< class, class, class, class >
+class DBusMethodWithReplyAdapterDispatcher;
+
+template <
+    typename _StubClass,
+    typename _StubAdapterClass,
+    template <class...> class _In, class... _InArgs,
+    template <class...> class _Out, class... _OutArgs>
+class DBusMethodWithReplyAdapterDispatcher<_StubClass, _StubAdapterClass, _In<_InArgs...>, _Out<_OutArgs...> >:
+            public DBusStubAdapterHelper<_StubClass>::StubDispatcher {
+ public:
+    typedef DBusStubAdapterHelper<_StubClass> DBusStubAdapterHelperType;
+    typedef void (_StubAdapterClass::*_StubFunctor)(std::shared_ptr<CommonAPI::ClientId>, _InArgs..., _OutArgs&...);
+
+    DBusMethodWithReplyAdapterDispatcher(_StubFunctor stubFunctor, const char* dbusReplySignature):
+            stubFunctor_(stubFunctor),
+            dbusReplySignature_(dbusReplySignature) {
+    }
+
+    bool dispatchDBusMessage(const DBusMessage& dbusMessage, const std::shared_ptr<_StubClass>& stub, DBusStubAdapterHelperType& dbusStubAdapterHelper) {
+        return handleDBusMessage(
+                        dbusMessage,
+                        stub,
+                        dbusStubAdapterHelper,
+                        typename make_sequence_range<sizeof...(_InArgs), 0>::type(),
+                        typename make_sequence_range<sizeof...(_OutArgs), sizeof...(_InArgs)>::type());
+    }
+
+ private:
+    template <int... _InArgIndices, int... _OutArgIndices>
+    inline bool handleDBusMessage(const DBusMessage& dbusMessage,
+                                  const std::shared_ptr<_StubClass>& stub,
+                                  DBusStubAdapterHelperType& dbusStubAdapterHelper,
+                                  index_sequence<_InArgIndices...>,
+                                  index_sequence<_OutArgIndices...>) const {
+        std::tuple<_InArgs..., _OutArgs...> argTuple;
+
+        if (sizeof...(_InArgs) > 0) {
+            DBusInputStream dbusInputStream(dbusMessage);
+            const bool success = DBusSerializableArguments<_InArgs...>::deserialize(dbusInputStream, std::get<_InArgIndices>(argTuple)...);
+            if (!success)
+                return false;
+        }
+
+        std::shared_ptr<DBusClientId> clientId = std::make_shared<DBusClientId>(std::string(dbusMessage.getSenderName()));
+
+        (dbusStubAdapterHelper.getStubAdapter().get()->*stubFunctor_)(clientId, std::move(std::get<_InArgIndices>(argTuple))..., std::get<_OutArgIndices>(argTuple)...);
+        DBusMessage dbusMessageReply = dbusMessage.createMethodReturn(dbusReplySignature_);
+
+        if (sizeof...(_OutArgs) > 0) {
+            DBusOutputStream dbusOutputStream(dbusMessageReply);
+            const bool success = DBusSerializableArguments<_OutArgs...>::serialize(dbusOutputStream, std::get<_OutArgIndices>(argTuple)...);
+            if (!success)
+                return false;
+
+            dbusOutputStream.flush();
+        }
+
+        return dbusStubAdapterHelper.getDBusConnection()->sendDBusMessage(dbusMessageReply);
+    }
+
+    _StubFunctor stubFunctor_;
+    const char* dbusReplySignature_;
+};
+
 
 template <typename _StubClass, typename _AttributeType>
 class DBusGetAttributeStubDispatcher: public DBusStubAdapterHelper<_StubClass>::StubDispatcher {
  public:
     typedef DBusStubAdapterHelper<_StubClass> DBusStubAdapterHelperType;
-    typedef const _AttributeType& (_StubClass::*GetStubFunctor)(const CommonAPI::ClientId&);
+    typedef const _AttributeType& (_StubClass::*GetStubFunctor)(std::shared_ptr<CommonAPI::ClientId>);
 
     DBusGetAttributeStubDispatcher(GetStubFunctor getStubFunctor, const char* dbusSignature):
         getStubFunctor_(getStubFunctor),
@@ -269,7 +334,7 @@ class DBusGetAttributeStubDispatcher: public DBusStubAdapterHelper<_StubClass>::
         DBusMessage dbusMessageReply = dbusMessage.createMethodReturn(dbusSignature_);
         DBusOutputStream dbusOutputStream(dbusMessageReply);
 
-        const DBusClientId clientId = DBusClientId(std::string(dbusMessage.getSenderName()));
+        std::shared_ptr<DBusClientId> clientId = std::make_shared<DBusClientId>(std::string(dbusMessage.getSenderName()));
 
         dbusOutputStream << (stub.get()->*getStubFunctor_)(clientId);
         dbusOutputStream.flush();
@@ -289,7 +354,7 @@ class DBusSetAttributeStubDispatcher: public DBusGetAttributeStubDispatcher<_Stu
     typedef typename DBusStubAdapterHelperType::RemoteEventHandlerType RemoteEventHandlerType;
 
     typedef typename DBusGetAttributeStubDispatcher<_StubClass, _AttributeType>::GetStubFunctor GetStubFunctor;
-    typedef bool (RemoteEventHandlerType::*OnRemoteSetFunctor)(const CommonAPI::ClientId&, _AttributeType);
+    typedef bool (RemoteEventHandlerType::*OnRemoteSetFunctor)(std::shared_ptr<CommonAPI::ClientId>, _AttributeType);
     typedef void (RemoteEventHandlerType::*OnRemoteChangedFunctor)();
 
     DBusSetAttributeStubDispatcher(GetStubFunctor getStubFunctor,
@@ -315,16 +380,16 @@ class DBusSetAttributeStubDispatcher: public DBusGetAttributeStubDispatcher<_Stu
 
  protected:
     inline bool setAttributeValue(const DBusMessage& dbusMessage,
-    							  const std::shared_ptr<_StubClass>& stub,
-    							  DBusStubAdapterHelperType& dbusStubAdapterHelper,
-    							  bool& attributeValueChanged) {
+                                  const std::shared_ptr<_StubClass>& stub,
+                                  DBusStubAdapterHelperType& dbusStubAdapterHelper,
+                                  bool& attributeValueChanged) {
         DBusInputStream dbusInputStream(dbusMessage);
         _AttributeType attributeValue;
         dbusInputStream >> attributeValue;
         if (dbusInputStream.hasError())
             return false;
 
-        const DBusClientId clientId = DBusClientId(std::string(dbusMessage.getSenderName()));
+        std::shared_ptr<DBusClientId> clientId = std::make_shared<DBusClientId>(std::string(dbusMessage.getSenderName()));
 
         attributeValueChanged = (dbusStubAdapterHelper.getRemoteEventHandler()->*onRemoteSetFunctor_)(clientId, std::move(attributeValue));
 
@@ -335,7 +400,7 @@ class DBusSetAttributeStubDispatcher: public DBusGetAttributeStubDispatcher<_Stu
         (dbusStubAdapterHelper.getRemoteEventHandler()->*onRemoteChangedFunctor_)();
     }
 
-    inline const _AttributeType& getAttributeValue(const CommonAPI::ClientId& clientId, const std::shared_ptr<_StubClass>& stub) {
+    inline const _AttributeType& getAttributeValue(std::shared_ptr<CommonAPI::ClientId> clientId, const std::shared_ptr<_StubClass>& stub) {
         return (stub.get()->*(this->getStubFunctor_))(clientId);
     }
 
@@ -373,7 +438,7 @@ class DBusSetObservableAttributeStubDispatcher: public DBusSetAttributeStubDispa
             return false;
 
         if (attributeValueChanged) {
-            const DBusClientId clientId = DBusClientId(std::string(dbusMessage.getSenderName()));
+            std::shared_ptr<DBusClientId> clientId = std::make_shared<DBusClientId>(std::string(dbusMessage.getSenderName()));
             fireAttributeValueChanged(clientId, dbusStubAdapterHelper, stub);
             this->notifyOnRemoteChanged(dbusStubAdapterHelper);
         }
@@ -381,7 +446,7 @@ class DBusSetObservableAttributeStubDispatcher: public DBusSetAttributeStubDispa
     }
 
  private:
-    inline void fireAttributeValueChanged(const CommonAPI::ClientId& clientId, DBusStubAdapterHelperType& dbusStubAdapterHelper, const std::shared_ptr<_StubClass> stub) {
+    inline void fireAttributeValueChanged(std::shared_ptr<CommonAPI::ClientId> clientId, DBusStubAdapterHelperType& dbusStubAdapterHelper, const std::shared_ptr<_StubClass> stub) {
         (dbusStubAdapterHelper.getStubAdapter().get()->*fireChangedFunctor_)(this->getAttributeValue(clientId, stub));
     }
 
diff --git a/src/test/DBusClientIdTest.cpp b/src/test/DBusClientIdTest.cpp
index 85fbe75..e0aa72f 100644
--- a/src/test/DBusClientIdTest.cpp
+++ b/src/test/DBusClientIdTest.cpp
@@ -29,6 +29,10 @@ public:
         return false; // doesn't matter, as we are just comparing this class with DBusClientId;
     }
 
+    std::size_t hashCode() {
+        return 0;
+    }
+
 };
 
 TEST_F(DBusClientIdTest, TestClientIdImplementation) {
diff --git a/src/test/DBusSelectiveBroadcastTest.cpp b/src/test/DBusSelectiveBroadcastTest.cpp
new file mode 100644
index 0000000..8f5df33
--- /dev/null
+++ b/src/test/DBusSelectiveBroadcastTest.cpp
@@ -0,0 +1,280 @@
+/* Copyright (C) 2013 BMW Group
+ * Author: Manfred Bathelt (manfred.bathelt@bmw.de)
+ * Author: Juergen Gehring (juergen.gehring@bmw.de)
+ * 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/. */
+
+#include <gtest/gtest.h>
+
+#include <cassert>
+#include <cstdint>
+#include <iostream>
+#include <functional>
+#include <memory>
+#include <stdint.h>
+#include <string>
+#include <utility>
+#include <tuple>
+#include <type_traits>
+
+#include <CommonAPI/CommonAPI.h>
+
+#define COMMONAPI_INTERNAL_COMPILATION
+
+#include <CommonAPI/DBus/DBusConnection.h>
+#include <CommonAPI/DBus/DBusProxy.h>
+#include <CommonAPI/DBus/DBusRuntime.h>
+
+#include "commonapi/tests/PredefinedTypeCollection.h"
+#include "commonapi/tests/DerivedTypeCollection.h"
+#include "commonapi/tests/TestInterfaceProxy.h"
+#include "commonapi/tests/TestInterfaceStubDefault.h"
+#include "commonapi/tests/TestInterfaceDBusStubAdapter.h"
+
+#include "commonapi/tests/TestInterfaceDBusProxy.h"
+
+class SelectiveBroadcastSender: public commonapi::tests::TestInterfaceStubDefault {
+public:
+
+    SelectiveBroadcastSender():
+        acceptSubs(true),
+        sentBroadcasts(0) {
+
+    }
+
+    void startSending() {
+        sentBroadcasts = 0;
+        selectiveBroadcastSender = std::thread(&SelectiveBroadcastSender::send, this);
+        selectiveBroadcastSender.detach();
+    }
+
+    void send() {
+        sentBroadcasts++;
+        fireTestSelectiveBroadcastSelective();
+    }
+
+    void onTestSelectiveBroadcastSelectiveSubscriptionChanged(
+            const std::shared_ptr<CommonAPI::ClientId> clientId,
+            const CommonAPI::SelectiveBroadcastSubscriptionEvent event) {
+
+        if(event == CommonAPI::SelectiveBroadcastSubscriptionEvent::SUBSCRIBED)
+            lastSubscribedClient = clientId;
+    }
+
+    bool onTestSelectiveBroadcastSelectiveSubscriptionRequested(
+                    const std::shared_ptr<CommonAPI::ClientId> clientId) {
+        return acceptSubs;
+    }
+
+    void sendToLastSubscribedClient()
+    {
+        sentBroadcasts++;
+        CommonAPI::ClientIdList receivers = { lastSubscribedClient };
+
+        fireTestSelectiveBroadcastSelective(&receivers);
+    }
+
+
+    int getNumberOfSubscribedClients() {
+        return getSubscribersForTestSelectiveBroadcastSelective()->size();
+
+    }
+
+    bool acceptSubs;
+
+private:
+    std::thread selectiveBroadcastSender;
+    int sentBroadcasts;
+
+    std::shared_ptr<CommonAPI::ClientId> lastSubscribedClient;
+};
+
+
+
+class DBusSelectiveBroadcastTest: public ::testing::Test {
+protected:
+   virtual void SetUp() {
+       runtime_ = CommonAPI::Runtime::load();
+       ASSERT_TRUE((bool)runtime_);
+       CommonAPI::DBus::DBusRuntime* dbusRuntime = dynamic_cast<CommonAPI::DBus::DBusRuntime*>(&(*runtime_));
+       ASSERT_TRUE(dbusRuntime != NULL);
+
+       proxyFactory_ = runtime_->createFactory();
+       ASSERT_TRUE((bool)proxyFactory_);
+
+       proxyFactory2_ = runtime_->createFactory();
+       ASSERT_TRUE((bool)proxyFactory2_);
+
+       stubFactory_ = runtime_->createFactory();
+       ASSERT_TRUE((bool)stubFactory_);
+
+       servicePublisher_ = runtime_->getServicePublisher();
+       ASSERT_TRUE((bool)servicePublisher_);
+
+       selectiveBroadcastArrivedAtProxyFromSameFactory1 = 0;
+       selectiveBroadcastArrivedAtProxyFromSameFactory2 = 0;
+       selectiveBroadcastArrivedAtProxyFromOtherFactory = 0;
+   }
+
+   virtual void TearDown() {
+   }
+
+
+
+
+   std::shared_ptr<CommonAPI::Runtime> runtime_;
+   std::shared_ptr<CommonAPI::Factory> proxyFactory_;
+   std::shared_ptr<CommonAPI::Factory> proxyFactory2_;
+   std::shared_ptr<CommonAPI::Factory> stubFactory_;
+   std::shared_ptr<CommonAPI::ServicePublisher> servicePublisher_;
+
+   static const std::string serviceAddress_;
+   static const std::string serviceAddress2_;
+   static const std::string serviceAddress3_;
+   static const std::string serviceAddress4_;
+   static const std::string nonstandardAddress_;
+
+   int selectiveBroadcastArrivedAtProxyFromSameFactory1;
+   int selectiveBroadcastArrivedAtProxyFromSameFactory2;
+   int selectiveBroadcastArrivedAtProxyFromOtherFactory;
+public:
+   CommonAPI::SubscriptionStatus selectiveBroadcastCallbackForProxyFromSameFactory1() {
+       selectiveBroadcastArrivedAtProxyFromSameFactory1++;
+       return CommonAPI::SubscriptionStatus::RETAIN;
+   }
+
+   CommonAPI::SubscriptionStatus selectiveBroadcastCallbackForProxyFromSameFactory2() {
+       selectiveBroadcastArrivedAtProxyFromSameFactory2++;
+       return CommonAPI::SubscriptionStatus::RETAIN;
+   }
+
+   CommonAPI::SubscriptionStatus selectiveBroadcastCallbackForProxyFromOtherFactory() {
+       selectiveBroadcastArrivedAtProxyFromOtherFactory++;
+       return CommonAPI::SubscriptionStatus::RETAIN;
+   }
+};
+
+const std::string DBusSelectiveBroadcastTest::serviceAddress_ = "local:CommonAPI.DBus.tests.DBusProxyTestInterface:CommonAPI.DBus.tests.DBusProxyTestService";
+const std::string DBusSelectiveBroadcastTest::serviceAddress2_ = "local:CommonAPI.DBus.tests.DBusProxyTestInterface:CommonAPI.DBus.tests.DBusProxyTestService2";
+const std::string DBusSelectiveBroadcastTest::serviceAddress3_ = "local:CommonAPI.DBus.tests.DBusProxyTestInterface:CommonAPI.DBus.tests.DBusProxyTestService3";
+const std::string DBusSelectiveBroadcastTest::serviceAddress4_ = "local:CommonAPI.DBus.tests.DBusProxyTestInterface:CommonAPI.DBus.tests.DBusProxyTestService4";
+const std::string DBusSelectiveBroadcastTest::nonstandardAddress_ = "local:non.standard.ServiceName:non.standard.participand.ID";
+
+
+TEST_F(DBusSelectiveBroadcastTest, ProxysCanSubscribe)
+{
+    auto proxyFromSameFactory1 = proxyFactory_->buildProxy<commonapi::tests::TestInterfaceProxy>(serviceAddress4_);
+    ASSERT_TRUE((bool)proxyFromSameFactory1);
+    auto proxyFromSameFactory2 = proxyFactory_->buildProxy<commonapi::tests::TestInterfaceProxy>(serviceAddress4_);
+    ASSERT_TRUE((bool)proxyFromSameFactory2);
+    auto proxyFromOtherFactory = proxyFactory2_->buildProxy<commonapi::tests::TestInterfaceProxy>(serviceAddress4_);
+    ASSERT_TRUE((bool)proxyFromOtherFactory);
+
+    auto stub = std::make_shared<SelectiveBroadcastSender>();
+
+
+    bool serviceRegistered = servicePublisher_->registerService(stub, serviceAddress4_, stubFactory_);
+    for (unsigned int i = 0; !serviceRegistered && i < 100; ++i) {
+        serviceRegistered = servicePublisher_->registerService(stub, serviceAddress4_, stubFactory_);
+        usleep(10000);
+    }
+    ASSERT_TRUE(serviceRegistered);
+
+    for (unsigned int i = 0; !proxyFromSameFactory1->isAvailable() && i < 200; ++i) {
+        usleep(10000);
+    }
+    ASSERT_TRUE(proxyFromSameFactory1->isAvailable());
+
+    auto subscriptionResult1 = proxyFromSameFactory1->getTestSelectiveBroadcastSelectiveEvent().subscribe(std::bind(&DBusSelectiveBroadcastTest::selectiveBroadcastCallbackForProxyFromSameFactory1, this));
+
+    ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1);
+
+    stub->send();
+
+    usleep(20000);
+    ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 1);
+    ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory2, 0);
+
+
+    auto subscriptionResult2 = proxyFromSameFactory2->getTestSelectiveBroadcastSelectiveEvent().subscribe(std::bind(&DBusSelectiveBroadcastTest::selectiveBroadcastCallbackForProxyFromSameFactory2, this));
+    ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1); // should still be one because these were created by the same factory thus using the same connection
+
+    stub->send();
+    usleep(20000);
+    ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 2);
+    ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory2, 1);
+
+    auto subscriptionResult3 = proxyFromOtherFactory->getTestSelectiveBroadcastSelectiveEvent().subscribe(std::bind(&DBusSelectiveBroadcastTest::selectiveBroadcastCallbackForProxyFromOtherFactory, this));
+    ASSERT_EQ(stub->getNumberOfSubscribedClients(), 2); // should still be two because proxyFromSameFactory1_ is still subscribed
+
+    proxyFromSameFactory2->getTestSelectiveBroadcastSelectiveEvent().unsubscribe(subscriptionResult2);
+    ASSERT_EQ(stub->getNumberOfSubscribedClients(), 2); // should still be two because proxyFromSameFactory1_ is still subscribed
+
+    stub->send();
+    usleep(20000);
+    ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 3);
+    ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory2, 1);
+    ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromOtherFactory, 1);
+
+    // now only the last subscribed client (which is the one from the other factory) should receive the signal
+    stub->sendToLastSubscribedClient();
+    usleep(20000);
+    ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 3);
+    ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory2, 1);
+    ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromOtherFactory, 2);
+
+    proxyFromSameFactory1->getTestSelectiveBroadcastSelectiveEvent().unsubscribe(subscriptionResult1);
+    ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1);
+
+    servicePublisher_->unregisterService(serviceAddress4_);
+}
+
+TEST_F(DBusSelectiveBroadcastTest, ProxysCanBeRejected) {
+    auto proxyFromSameFactory1 = proxyFactory_->buildProxy<commonapi::tests::TestInterfaceProxy>(serviceAddress4_);
+    ASSERT_TRUE((bool)proxyFromSameFactory1);
+    auto proxyFromOtherFactory = proxyFactory2_->buildProxy<commonapi::tests::TestInterfaceProxy>(serviceAddress4_);
+    ASSERT_TRUE((bool)proxyFromOtherFactory);
+
+
+    auto stub = std::make_shared<SelectiveBroadcastSender>();
+
+    bool serviceRegistered = servicePublisher_->registerService(stub, serviceAddress4_, stubFactory_);
+    for (unsigned int i = 0; !serviceRegistered && i < 100; ++i) {
+        serviceRegistered = servicePublisher_->registerService(stub, serviceAddress4_, stubFactory_);
+        usleep(10000);
+    }
+    ASSERT_TRUE(serviceRegistered);
+
+    for (unsigned int i = 0; !proxyFromSameFactory1->isAvailable() && i < 200; ++i) {
+        usleep(10000);
+    }
+    ASSERT_TRUE(proxyFromSameFactory1->isAvailable());
+
+    bool subbed = false;
+
+    auto subscriptionResult1 = proxyFromSameFactory1->getTestSelectiveBroadcastSelectiveEvent().subscribe(
+                    std::bind(&DBusSelectiveBroadcastTest::selectiveBroadcastCallbackForProxyFromSameFactory1, this),
+                    subbed);
+    ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1);
+    ASSERT_TRUE(subbed);
+
+    stub->acceptSubs = false;
+
+    auto subscriptionResult2 = proxyFromOtherFactory->getTestSelectiveBroadcastSelectiveEvent().subscribe(
+                    std::bind(&DBusSelectiveBroadcastTest::selectiveBroadcastCallbackForProxyFromOtherFactory, this),
+                    subbed);
+    ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1);
+    ASSERT_FALSE(subbed);
+
+    stub->send();
+
+    usleep(20000);
+    ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 1);
+    ASSERT_EQ(selectiveBroadcastArrivedAtProxyFromOtherFactory, 0);
+}
+
+int main(int argc, char** argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
diff --git a/src/test/commonapi/tests/DerivedTypeCollection.h b/src/test/commonapi/tests/DerivedTypeCollection.h
index 23d8a43..0ca1d79 100644
--- a/src/test/commonapi/tests/DerivedTypeCollection.h
+++ b/src/test/commonapi/tests/DerivedTypeCollection.h
@@ -234,88 +234,88 @@ static inline const char* getTypeCollectionName() {
 } // namespace commonapi
 
 namespace CommonAPI {
-	
-	template<>
-	struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnum> {
-	    inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
-	        typeStream.writeInt32EnumType();
-	    }
-	};
-	
-	template<>
-	struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnum> {
-	    static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnum>& vectorValue) {
-	        inputStream.beginReadInt32EnumVector();
-	    }
-	};
-	
-	template <>
-	struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnum> {
-	    static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnum>& vectorValue) {
-	        outputStream.beginWriteInt32EnumVector(vectorValue.size());
-	    }
-	};
-	template<>
-	struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnumExtended2> {
-	    inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
-	        typeStream.writeInt32EnumType();
-	    }
-	};
-	
-	template<>
-	struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended2> {
-	    static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended2>& vectorValue) {
-	        inputStream.beginReadInt32EnumVector();
-	    }
-	};
-	
-	template <>
-	struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended2> {
-	    static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended2>& vectorValue) {
-	        outputStream.beginWriteInt32EnumVector(vectorValue.size());
-	    }
-	};
-	template<>
-	struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue> {
-	    inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
-	        typeStream.writeInt32EnumType();
-	    }
-	};
-	
-	template<>
-	struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue> {
-	    static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue>& vectorValue) {
-	        inputStream.beginReadInt32EnumVector();
-	    }
-	};
-	
-	template <>
-	struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue> {
-	    static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue>& vectorValue) {
-	        outputStream.beginWriteInt32EnumVector(vectorValue.size());
-	    }
-	};
-	template<>
-	struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnumExtended> {
-	    inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
-	        typeStream.writeInt32EnumType();
-	    }
-	};
-	
-	template<>
-	struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended> {
-	    static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended>& vectorValue) {
-	        inputStream.beginReadInt32EnumVector();
-	    }
-	};
-	
-	template <>
-	struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended> {
-	    static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended>& vectorValue) {
-	        outputStream.beginWriteInt32EnumVector(vectorValue.size());
-	    }
-	};
-	
+
+    template<>
+    struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnum> {
+        inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
+            typeStream.writeInt32EnumType();
+        }
+    };
+    
+    template<>
+    struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnum> {
+        static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnum>& vectorValue) {
+            inputStream.beginReadInt32EnumVector();
+        }
+    };
+    
+    template <>
+    struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnum> {
+        static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnum>& vectorValue) {
+            outputStream.beginWriteInt32EnumVector(vectorValue.size());
+        }
+    };
+    template<>
+    struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnumExtended2> {
+        inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
+            typeStream.writeInt32EnumType();
+        }
+    };
+    
+    template<>
+    struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended2> {
+        static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended2>& vectorValue) {
+            inputStream.beginReadInt32EnumVector();
+        }
+    };
+    
+    template <>
+    struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended2> {
+        static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended2>& vectorValue) {
+            outputStream.beginWriteInt32EnumVector(vectorValue.size());
+        }
+    };
+    template<>
+    struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue> {
+        inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
+            typeStream.writeInt32EnumType();
+        }
+    };
+    
+    template<>
+    struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue> {
+        static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue>& vectorValue) {
+            inputStream.beginReadInt32EnumVector();
+        }
+    };
+    
+    template <>
+    struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue> {
+        static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumMissingValue>& vectorValue) {
+            outputStream.beginWriteInt32EnumVector(vectorValue.size());
+        }
+    };
+    template<>
+    struct BasicTypeWriter<commonapi::tests::DerivedTypeCollection::TestEnumExtended> {
+        inline static void writeType (CommonAPI::TypeOutputStream& typeStream) {
+            typeStream.writeInt32EnumType();
+        }
+    };
+    
+    template<>
+    struct InputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended> {
+        static void beginReadVector(InputStream& inputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended>& vectorValue) {
+            inputStream.beginReadInt32EnumVector();
+        }
+    };
+    
+    template <>
+    struct OutputStreamVectorHelper<commonapi::tests::DerivedTypeCollection::TestEnumExtended> {
+        static void beginWriteVector(OutputStream& outputStream, const std::vector<commonapi::tests::DerivedTypeCollection::TestEnumExtended>& vectorValue) {
+            outputStream.beginWriteInt32EnumVector(vectorValue.size());
+        }
+    };
+
 }
 
 
diff --git a/src/test/commonapi/tests/PredefinedTypeCollection.h b/src/test/commonapi/tests/PredefinedTypeCollection.h
index f5c65fd..3cf55ff 100644
--- a/src/test/commonapi/tests/PredefinedTypeCollection.h
+++ b/src/test/commonapi/tests/PredefinedTypeCollection.h
@@ -66,8 +66,8 @@ static inline const char* getTypeCollectionName() {
 } // namespace commonapi
 
 namespace CommonAPI {
-	
-	
+
+
 }
 
 
diff --git a/src/test/commonapi/tests/TestInterfaceDBusProxy.cpp b/src/test/commonapi/tests/TestInterfaceDBusProxy.cpp
index 6bd4408..e20db65 100644
--- a/src/test/commonapi/tests/TestInterfaceDBusProxy.cpp
+++ b/src/test/commonapi/tests/TestInterfaceDBusProxy.cpp
@@ -34,7 +34,9 @@ TestInterfaceDBusProxy::TestInterfaceDBusProxy(
 ,        testPredefinedTypeAttribute_(*this, "onTestPredefinedTypeAttributeAttributeChanged", "setTestPredefinedTypeAttributeAttribute", "u", "getTestPredefinedTypeAttributeAttribute"),
         testDerivedStructAttribute_(*this, "onTestDerivedStructAttributeAttributeChanged", "setTestDerivedStructAttributeAttribute", "(sqi)", "getTestDerivedStructAttributeAttribute"),
         testDerivedArrayAttribute_(*this, "onTestDerivedArrayAttributeAttributeChanged", "setTestDerivedArrayAttributeAttribute", "at", "getTestDerivedArrayAttributeAttribute")
-,        testPredefinedTypeBroadcast_(*this, "TestPredefinedTypeBroadcast", "us")
+,        testPredefinedTypeBroadcast_(*this, "TestPredefinedTypeBroadcast", "us"),
+                        testSelectiveBroadcastSelective_(*this, "TestSelectiveBroadcast", ""),
+                        testBroadcastWithOutArgsSelective_(*this, "TestBroadcastWithOutArgs", "us")
                  {
 }
 
@@ -51,6 +53,12 @@ TestInterfaceDBusProxy::TestDerivedArrayAttributeAttribute& TestInterfaceDBusPro
 TestInterfaceDBusProxy::TestPredefinedTypeBroadcastEvent& TestInterfaceDBusProxy::getTestPredefinedTypeBroadcastEvent() {
     return testPredefinedTypeBroadcast_;
 }
+TestInterfaceDBusProxy::TestSelectiveBroadcastSelectiveEvent& TestInterfaceDBusProxy::getTestSelectiveBroadcastSelectiveEvent() {
+    return testSelectiveBroadcastSelective_;
+}
+TestInterfaceDBusProxy::TestBroadcastWithOutArgsSelectiveEvent& TestInterfaceDBusProxy::getTestBroadcastWithOutArgsSelectiveEvent() {
+    return testBroadcastWithOutArgsSelective_;
+}
 
 void TestInterfaceDBusProxy::testEmptyMethod(CommonAPI::CallStatus& callStatus) {
     CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>,
@@ -146,6 +154,7 @@ std::future<CommonAPI::CallStatus> TestInterfaceDBusProxy::testDerivedTypeMethod
         std::move(callback));
 }
 
+
 void TestInterfaceDBusProxy::getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const {
     ownVersionMajor = 1;
     ownVersionMinor = 0;
diff --git a/src/test/commonapi/tests/TestInterfaceDBusProxy.h b/src/test/commonapi/tests/TestInterfaceDBusProxy.h
index 592e181..86d8fb3 100644
--- a/src/test/commonapi/tests/TestInterfaceDBusProxy.h
+++ b/src/test/commonapi/tests/TestInterfaceDBusProxy.h
@@ -18,6 +18,8 @@
 #include <CommonAPI/DBus/DBusProxy.h>
 #include <CommonAPI/DBus/DBusAttribute.h>
 #include <CommonAPI/DBus/DBusEvent.h>
+#include <CommonAPI/types.h>
+#include <CommonAPI/DBus/DBusSelectiveEvent.h>
 
 #undef COMMONAPI_INTERNAL_COMPILATION
 
@@ -42,23 +44,20 @@ class TestInterfaceDBusProxy: virtual public TestInterfaceProxyBase, virtual pub
     virtual TestDerivedArrayAttributeAttribute& getTestDerivedArrayAttributeAttribute();
 
     virtual TestPredefinedTypeBroadcastEvent& getTestPredefinedTypeBroadcastEvent();
-
+    virtual TestSelectiveBroadcastSelectiveEvent& getTestSelectiveBroadcastSelectiveEvent();
+    virtual TestBroadcastWithOutArgsSelectiveEvent& getTestBroadcastWithOutArgsSelectiveEvent();
 
     virtual void testEmptyMethod(CommonAPI::CallStatus& callStatus);
     virtual std::future<CommonAPI::CallStatus> testEmptyMethodAsync(TestEmptyMethodAsyncCallback callback);
-
     virtual void testVoidPredefinedTypeMethod(const uint32_t& uint32Value, const std::string& stringValue, CommonAPI::CallStatus& callStatus);
     virtual std::future<CommonAPI::CallStatus> testVoidPredefinedTypeMethodAsync(const uint32_t& uint32Value, const std::string& stringValue, TestVoidPredefinedTypeMethodAsyncCallback callback);
-
     virtual void testPredefinedTypeMethod(const uint32_t& uint32InValue, const std::string& stringInValue, CommonAPI::CallStatus& callStatus, uint32_t& uint32OutValue, std::string& stringOutValue);
     virtual std::future<CommonAPI::CallStatus> testPredefinedTypeMethodAsync(const uint32_t& uint32InValue, const std::string& stringInValue, TestPredefinedTypeMethodAsyncCallback callback);
-
     virtual void testVoidDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, CommonAPI::CallStatus& callStatus);
     virtual std::future<CommonAPI::CallStatus> testVoidDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, TestVoidDerivedTypeMethodAsyncCallback callback);
-
     virtual void testDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, CommonAPI::CallStatus& callStatus, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue);
     virtual std::future<CommonAPI::CallStatus> testDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, TestDerivedTypeMethodAsyncCallback callback);
-    
+
     virtual void getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const;
 
  private:
@@ -67,6 +66,8 @@ class TestInterfaceDBusProxy: virtual public TestInterfaceProxyBase, virtual pub
     CommonAPI::DBus::DBusObservableAttribute<CommonAPI::DBus::DBusAttribute<TestDerivedArrayAttributeAttribute>> testDerivedArrayAttribute_;
 
     CommonAPI::DBus::DBusEvent<TestPredefinedTypeBroadcastEvent> testPredefinedTypeBroadcast_;
+    CommonAPI::DBus::DBusSelectiveEvent<TestSelectiveBroadcastSelectiveEvent> testSelectiveBroadcastSelective_;
+    CommonAPI::DBus::DBusSelectiveEvent<TestBroadcastWithOutArgsSelectiveEvent> testBroadcastWithOutArgsSelective_;
 };
 
 } // namespace tests
diff --git a/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.cpp b/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.cpp
index cdbb6ab..ffe1005 100644
--- a/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.cpp
+++ b/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.cpp
@@ -39,7 +39,7 @@ TestInterfaceDBusStubAdapter::TestInterfaceDBusStubAdapter(
 const char* TestInterfaceDBusStubAdapter::getMethodsDBusIntrospectionXmlData() const {
     static const char* introspectionData =
         "<method name=\"getTestPredefinedTypeAttributeAttribute\">\n"
-        	"<arg name=\"value\" type=\"u\" direction=\"out\" />"
+            "<arg name=\"value\" type=\"u\" direction=\"out\" />"
         "</method>\n"
         "<method name=\"setTestPredefinedTypeAttributeAttribute\">\n"
             "<arg name=\"requestedValue\" type=\"u\" direction=\"in\" />\n"
@@ -49,7 +49,7 @@ const char* TestInterfaceDBusStubAdapter::getMethodsDBusIntrospectionXmlData() c
             "<arg name=\"changedValue\" type=\"u\" />\n"
         "</signal>\n"
         "<method name=\"getTestDerivedStructAttributeAttribute\">\n"
-        	"<arg name=\"value\" type=\"(sqi)\" direction=\"out\" />"
+            "<arg name=\"value\" type=\"(sqi)\" direction=\"out\" />"
         "</method>\n"
         "<method name=\"setTestDerivedStructAttributeAttribute\">\n"
             "<arg name=\"requestedValue\" type=\"(sqi)\" direction=\"in\" />\n"
@@ -59,7 +59,7 @@ const char* TestInterfaceDBusStubAdapter::getMethodsDBusIntrospectionXmlData() c
             "<arg name=\"changedValue\" type=\"(sqi)\" />\n"
         "</signal>\n"
         "<method name=\"getTestDerivedArrayAttributeAttribute\">\n"
-        	"<arg name=\"value\" type=\"at\" direction=\"out\" />"
+            "<arg name=\"value\" type=\"at\" direction=\"out\" />"
         "</method>\n"
         "<method name=\"setTestDerivedArrayAttributeAttribute\">\n"
             "<arg name=\"requestedValue\" type=\"at\" direction=\"in\" />\n"
@@ -72,6 +72,12 @@ const char* TestInterfaceDBusStubAdapter::getMethodsDBusIntrospectionXmlData() c
             "<arg name=\"uint32Value\" type=\"u\" />\n"
             "<arg name=\"stringValue\" type=\"s\" />\n"
         "</signal>\n"
+        "<signal name=\"TestSelectiveBroadcast\">\n"
+        "</signal>\n"
+        "<signal name=\"TestBroadcastWithOutArgs\">\n"
+            "<arg name=\"uint32Value\" type=\"u\" />\n"
+            "<arg name=\"stringValue\" type=\"s\" />\n"
+        "</signal>\n"
         "<method name=\"testEmptyMethod\">\n"
         "</method>\n"
         "<method name=\"testVoidPredefinedTypeMethod\">\n"
@@ -169,7 +175,7 @@ static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher<
     > testDerivedTypeMethodStubDispatcher(&TestInterfaceStub::testDerivedTypeMethod, "ia{ua(sq)}");
 
 void TestInterfaceDBusStubAdapter::fireTestPredefinedTypeAttributeAttributeChanged(const uint32_t& value) {
-	CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t>>
+    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<uint32_t>>
         ::sendSignal(
             *this,
             "onTestPredefinedTypeAttributeAttributeChanged",
@@ -178,7 +184,7 @@ void TestInterfaceDBusStubAdapter::fireTestPredefinedTypeAttributeAttributeChang
     );
 }
 void TestInterfaceDBusStubAdapter::fireTestDerivedStructAttributeAttributeChanged(const DerivedTypeCollection::TestStructExtended& value) {
-	CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<DerivedTypeCollection::TestStructExtended>>
+    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<DerivedTypeCollection::TestStructExtended>>
         ::sendSignal(
             *this,
             "onTestDerivedStructAttributeAttributeChanged",
@@ -187,7 +193,7 @@ void TestInterfaceDBusStubAdapter::fireTestDerivedStructAttributeAttributeChange
     );
 }
 void TestInterfaceDBusStubAdapter::fireTestDerivedArrayAttributeAttributeChanged(const DerivedTypeCollection::TestArrayUInt64& value) {
-	CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<DerivedTypeCollection::TestArrayUInt64>>
+    CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<DerivedTypeCollection::TestArrayUInt64>>
         ::sendSignal(
             *this,
             "onTestDerivedArrayAttributeAttributeChanged",
@@ -205,6 +211,130 @@ void TestInterfaceDBusStubAdapter::fireTestPredefinedTypeBroadcastEvent(const ui
                 uint32Value, stringValue
         );
 }
+static CommonAPI::DBus::DBusMethodWithReplyAdapterDispatcher<
+    TestInterfaceStub,
+    TestInterfaceStubAdapter,
+    std::tuple<>,
+    std::tuple<bool>
+    > subscribeTestSelectiveBroadcastSelectiveStubDispatcher(&TestInterfaceStubAdapter::subscribeForTestSelectiveBroadcastSelective, "b");
+
+static CommonAPI::DBus::DBusMethodWithReplyAdapterDispatcher<
+    TestInterfaceStub,
+    TestInterfaceStubAdapter,
+    std::tuple<>,
+    std::tuple<>
+    > unsubscribeTestSelectiveBroadcastSelectiveStubDispatcher(&TestInterfaceStubAdapter::unsubscribeFromTestSelectiveBroadcastSelective, "");
+
+
+void TestInterfaceDBusStubAdapter::fireTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) {
+    std::shared_ptr<CommonAPI::DBus::DBusClientId> dbusClientId = std::dynamic_pointer_cast<CommonAPI::DBus::DBusClientId, CommonAPI::ClientId>(clientId);
+
+    if(dbusClientId != NULL)
+    {
+        CommonAPI::DBus::DBusMessage dbusMethodCall = dbusClientId->createMessage(getObjectPath(), getInterfaceName(), "TestSelectiveBroadcast");
+        getDBusConnection()->sendDBusMessage(dbusMethodCall);
+    }
+}
+
+void TestInterfaceDBusStubAdapter::sendTestSelectiveBroadcastSelective(const CommonAPI::ClientIdList* receivers) {
+    const CommonAPI::ClientIdList* actualReceiverList;
+    actualReceiverList = receivers;
+
+    if(receivers == NULL)
+        actualReceiverList = &subscribersForTestSelectiveBroadcastSelective_;
+
+    for (auto clientIdIterator = actualReceiverList->cbegin();
+               clientIdIterator != actualReceiverList->cend();
+               clientIdIterator++) {
+        if(receivers == NULL || subscribersForTestSelectiveBroadcastSelective_.find(*clientIdIterator) != subscribersForTestSelectiveBroadcastSelective_.end()) {
+            fireTestSelectiveBroadcastSelective(*clientIdIterator);
+        }
+    }
+}
+
+void TestInterfaceDBusStubAdapter::subscribeForTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success) {
+    bool ok = stub_->onTestSelectiveBroadcastSelectiveSubscriptionRequested(clientId);
+    if (ok) {
+        subscribersForTestSelectiveBroadcastSelective_.insert(clientId);
+        stub_->onTestSelectiveBroadcastSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::SUBSCRIBED);
+        success = true;
+    } else {
+        success = false;
+    }
+}
+
+
+void TestInterfaceDBusStubAdapter::unsubscribeFromTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) {
+    subscribersForTestSelectiveBroadcastSelective_.erase(clientId);
+    stub_->onTestSelectiveBroadcastSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED);
+}
+
+CommonAPI::ClientIdList* const TestInterfaceDBusStubAdapter::getSubscribersForTestSelectiveBroadcastSelective() {
+    return &subscribersForTestSelectiveBroadcastSelective_;
+}
+
+static CommonAPI::DBus::DBusMethodWithReplyAdapterDispatcher<
+    TestInterfaceStub,
+    TestInterfaceStubAdapter,
+    std::tuple<>,
+    std::tuple<bool>
+    > subscribeTestBroadcastWithOutArgsSelectiveStubDispatcher(&TestInterfaceStubAdapter::subscribeForTestBroadcastWithOutArgsSelective, "b");
+
+static CommonAPI::DBus::DBusMethodWithReplyAdapterDispatcher<
+    TestInterfaceStub,
+    TestInterfaceStubAdapter,
+    std::tuple<>,
+    std::tuple<>
+    > unsubscribeTestBroadcastWithOutArgsSelectiveStubDispatcher(&TestInterfaceStubAdapter::unsubscribeFromTestBroadcastWithOutArgsSelective, "");
+
+
+void TestInterfaceDBusStubAdapter::fireTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, const uint32_t& uint32Value, const std::string& stringValue) {
+    std::shared_ptr<CommonAPI::DBus::DBusClientId> dbusClientId = std::dynamic_pointer_cast<CommonAPI::DBus::DBusClientId, CommonAPI::ClientId>(clientId);
+
+    if(dbusClientId != NULL)
+    {
+        CommonAPI::DBus::DBusMessage dbusMethodCall = dbusClientId->createMessage(getObjectPath(), getInterfaceName(), "TestBroadcastWithOutArgs");
+        getDBusConnection()->sendDBusMessage(dbusMethodCall);
+    }
+}
+
+void TestInterfaceDBusStubAdapter::sendTestBroadcastWithOutArgsSelective(const uint32_t& uint32Value, const std::string& stringValue, const CommonAPI::ClientIdList* receivers) {
+    const CommonAPI::ClientIdList* actualReceiverList;
+    actualReceiverList = receivers;
+
+    if(receivers == NULL)
+        actualReceiverList = &subscribersForTestBroadcastWithOutArgsSelective_;
+
+    for (auto clientIdIterator = actualReceiverList->cbegin();
+               clientIdIterator != actualReceiverList->cend();
+               clientIdIterator++) {
+        if(receivers == NULL || subscribersForTestBroadcastWithOutArgsSelective_.find(*clientIdIterator) != subscribersForTestBroadcastWithOutArgsSelective_.end()) {
+            fireTestBroadcastWithOutArgsSelective(*clientIdIterator, uint32Value, stringValue);
+        }
+    }
+}
+
+void TestInterfaceDBusStubAdapter::subscribeForTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success) {
+    bool ok = stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionRequested(clientId);
+    if (ok) {
+        subscribersForTestBroadcastWithOutArgsSelective_.insert(clientId);
+        stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::SUBSCRIBED);
+        success = true;
+    } else {
+        success = false;
+    }
+}
+
+
+void TestInterfaceDBusStubAdapter::unsubscribeFromTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) {
+    subscribersForTestBroadcastWithOutArgsSelective_.erase(clientId);
+    stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED);
+}
+
+CommonAPI::ClientIdList* const TestInterfaceDBusStubAdapter::getSubscribersForTestBroadcastWithOutArgsSelective() {
+    return &subscribersForTestBroadcastWithOutArgsSelective_;
+}
+
 
 const TestInterfaceDBusStubAdapter::StubDispatcherTable& TestInterfaceDBusStubAdapter::getStubDispatcherTable() {
     static const TestInterfaceDBusStubAdapter::StubDispatcherTable stubDispatcherTable = {
@@ -220,6 +350,11 @@ const TestInterfaceDBusStubAdapter::StubDispatcherTable& TestInterfaceDBusStubAd
             { { "testPredefinedTypeMethod", "us" }, &commonapi::tests::testPredefinedTypeMethodStubDispatcher },
             { { "testVoidDerivedTypeMethod", "ia{ua(sq)}" }, &commonapi::tests::testVoidDerivedTypeMethodStubDispatcher },
             { { "testDerivedTypeMethod", "ia{ua(sq)}" }, &commonapi::tests::testDerivedTypeMethodStubDispatcher }
+            ,
+            { { "subscribeForTestSelectiveBroadcastSelective", "" }, &commonapi::tests::subscribeTestSelectiveBroadcastSelectiveStubDispatcher },
+            { { "unsubscribeFromTestSelectiveBroadcastSelective", "" }, &commonapi::tests::unsubscribeTestSelectiveBroadcastSelectiveStubDispatcher },
+            { { "subscribeForTestBroadcastWithOutArgsSelective", "" }, &commonapi::tests::subscribeTestBroadcastWithOutArgsSelectiveStubDispatcher },
+            { { "unsubscribeFromTestBroadcastWithOutArgsSelective", "" }, &commonapi::tests::unsubscribeTestBroadcastWithOutArgsSelectiveStubDispatcher }
             };
     return stubDispatcherTable;
 }
diff --git a/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.h b/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.h
index 952e9b2..9a9022d 100644
--- a/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.h
+++ b/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.h
@@ -33,12 +33,22 @@ class TestInterfaceDBusStubAdapter: public TestInterfaceStubAdapter, public Test
             const std::string& dbusObjectPath,
             const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection,
             const std::shared_ptr<CommonAPI::StubBase>& stub);
-    
+
     void fireTestPredefinedTypeAttributeAttributeChanged(const uint32_t& value);
     void fireTestDerivedStructAttributeAttributeChanged(const DerivedTypeCollection::TestStructExtended& value);
     void fireTestDerivedArrayAttributeAttributeChanged(const DerivedTypeCollection::TestArrayUInt64& value);
 
     void fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue);
+    void fireTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId);
+    void sendTestSelectiveBroadcastSelective(const CommonAPI::ClientIdList* receivers = NULL);
+    void subscribeForTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success);
+    void unsubscribeFromTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId);
+    CommonAPI::ClientIdList* const getSubscribersForTestSelectiveBroadcastSelective();
+    void fireTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, const uint32_t& uint32Value, const std::string& stringValue);
+    void sendTestBroadcastWithOutArgsSelective(const uint32_t& uint32Value, const std::string& stringValue, const CommonAPI::ClientIdList* receivers = NULL);
+    void subscribeForTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success);
+    void unsubscribeFromTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId);
+    CommonAPI::ClientIdList* const getSubscribersForTestBroadcastWithOutArgsSelective();
 
     const StubDispatcherTable& getStubDispatcherTable();
 
diff --git a/src/test/commonapi/tests/TestInterfaceProxy.h b/src/test/commonapi/tests/TestInterfaceProxy.h
index 989765a..e206944 100644
--- a/src/test/commonapi/tests/TestInterfaceProxy.h
+++ b/src/test/commonapi/tests/TestInterfaceProxy.h
@@ -32,24 +32,27 @@ class TestInterfaceProxy: virtual public TestInterface, virtual public TestInter
     virtual TestPredefinedTypeAttributeAttribute& getTestPredefinedTypeAttributeAttribute() {
         return delegate_->getTestPredefinedTypeAttributeAttribute();
     }
-
     /// Returns the wrapper class that provides access to the attribute TestDerivedStructAttribute.
     virtual TestDerivedStructAttributeAttribute& getTestDerivedStructAttributeAttribute() {
         return delegate_->getTestDerivedStructAttributeAttribute();
     }
-
     /// Returns the wrapper class that provides access to the attribute TestDerivedArrayAttribute.
     virtual TestDerivedArrayAttributeAttribute& getTestDerivedArrayAttributeAttribute() {
         return delegate_->getTestDerivedArrayAttributeAttribute();
     }
 
-
-    /// Returns the wrapper class that provides access to the broadcast TestPredefinedTypeBroadcast.
+    // Returns the wrapper class that provides access to the broadcast TestPredefinedTypeBroadcast.
     virtual TestPredefinedTypeBroadcastEvent& getTestPredefinedTypeBroadcastEvent() {
         return delegate_->getTestPredefinedTypeBroadcastEvent();
     }
-
-
+    // Returns the wrapper class that provides access to the broadcast TestSelectiveBroadcast.
+    virtual TestSelectiveBroadcastSelectiveEvent& getTestSelectiveBroadcastSelectiveEvent() {
+        return delegate_->getTestSelectiveBroadcastSelectiveEvent();
+    }
+    // Returns the wrapper class that provides access to the broadcast TestBroadcastWithOutArgs.
+    virtual TestBroadcastWithOutArgsSelectiveEvent& getTestBroadcastWithOutArgsSelectiveEvent() {
+        return delegate_->getTestBroadcastWithOutArgsSelectiveEvent();
+    }
 
     /**
      * Calls testEmptyMethod with synchronous semantics.
@@ -70,7 +73,6 @@ class TestInterfaceProxy: virtual public TestInterface, virtual public TestInter
      * It will provide the same value for CallStatus as will be handed to the callback.
      */
     virtual std::future<CommonAPI::CallStatus> testEmptyMethodAsync(TestEmptyMethodAsyncCallback callback);
-
     /**
      * Calls testVoidPredefinedTypeMethod with synchronous semantics.
      * 
@@ -91,7 +93,6 @@ class TestInterfaceProxy: virtual public TestInterface, virtual public TestInter
      * It will provide the same value for CallStatus as will be handed to the callback.
      */
     virtual std::future<CommonAPI::CallStatus> testVoidPredefinedTypeMethodAsync(const uint32_t& uint32Value, const std::string& stringValue, TestVoidPredefinedTypeMethodAsyncCallback callback);
-
     /**
      * Calls testPredefinedTypeMethod with synchronous semantics.
      * 
@@ -113,7 +114,6 @@ class TestInterfaceProxy: virtual public TestInterface, virtual public TestInter
      * It will provide the same value for CallStatus as will be handed to the callback.
      */
     virtual std::future<CommonAPI::CallStatus> testPredefinedTypeMethodAsync(const uint32_t& uint32InValue, const std::string& stringInValue, TestPredefinedTypeMethodAsyncCallback callback);
-
     /**
      * Calls testVoidDerivedTypeMethod with synchronous semantics.
      * 
@@ -134,7 +134,6 @@ class TestInterfaceProxy: virtual public TestInterface, virtual public TestInter
      * It will provide the same value for CallStatus as will be handed to the callback.
      */
     virtual std::future<CommonAPI::CallStatus> testVoidDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, TestVoidDerivedTypeMethodAsyncCallback callback);
-
     /**
      * Calls testDerivedTypeMethod with synchronous semantics.
      * 
@@ -270,7 +269,6 @@ template <typename ... _AttributeExtensions>
 std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::testEmptyMethodAsync(TestEmptyMethodAsyncCallback callback) {
     return delegate_->testEmptyMethodAsync(callback);
 }
-
 template <typename ... _AttributeExtensions>
 void TestInterfaceProxy<_AttributeExtensions...>::testVoidPredefinedTypeMethod(const uint32_t& uint32Value, const std::string& stringValue, CommonAPI::CallStatus& callStatus) {
     delegate_->testVoidPredefinedTypeMethod(uint32Value, stringValue, callStatus);
@@ -280,7 +278,6 @@ template <typename ... _AttributeExtensions>
 std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::testVoidPredefinedTypeMethodAsync(const uint32_t& uint32Value, const std::string& stringValue, TestVoidPredefinedTypeMethodAsyncCallback callback) {
     return delegate_->testVoidPredefinedTypeMethodAsync(uint32Value, stringValue, callback);
 }
-
 template <typename ... _AttributeExtensions>
 void TestInterfaceProxy<_AttributeExtensions...>::testPredefinedTypeMethod(const uint32_t& uint32InValue, const std::string& stringInValue, CommonAPI::CallStatus& callStatus, uint32_t& uint32OutValue, std::string& stringOutValue) {
     delegate_->testPredefinedTypeMethod(uint32InValue, stringInValue, callStatus, uint32OutValue, stringOutValue);
@@ -290,7 +287,6 @@ template <typename ... _AttributeExtensions>
 std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::testPredefinedTypeMethodAsync(const uint32_t& uint32InValue, const std::string& stringInValue, TestPredefinedTypeMethodAsyncCallback callback) {
     return delegate_->testPredefinedTypeMethodAsync(uint32InValue, stringInValue, callback);
 }
-
 template <typename ... _AttributeExtensions>
 void TestInterfaceProxy<_AttributeExtensions...>::testVoidDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, CommonAPI::CallStatus& callStatus) {
     delegate_->testVoidDerivedTypeMethod(testEnumExtended2Value, testMapValue, callStatus);
@@ -300,7 +296,6 @@ template <typename ... _AttributeExtensions>
 std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::testVoidDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, TestVoidDerivedTypeMethodAsyncCallback callback) {
     return delegate_->testVoidDerivedTypeMethodAsync(testEnumExtended2Value, testMapValue, callback);
 }
-
 template <typename ... _AttributeExtensions>
 void TestInterfaceProxy<_AttributeExtensions...>::testDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, CommonAPI::CallStatus& callStatus, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) {
     delegate_->testDerivedTypeMethod(testEnumExtended2InValue, testMapInValue, callStatus, testEnumExtended2OutValue, testMapOutValue);
@@ -311,7 +306,6 @@ std::future<CommonAPI::CallStatus> TestInterfaceProxy<_AttributeExtensions...>::
     return delegate_->testDerivedTypeMethodAsync(testEnumExtended2InValue, testMapInValue, callback);
 }
 
-
 template <typename ... _AttributeExtensions>
 std::string TestInterfaceProxy<_AttributeExtensions...>::getAddress() const {
     return delegate_->getAddress();
diff --git a/src/test/commonapi/tests/TestInterfaceProxyBase.h b/src/test/commonapi/tests/TestInterfaceProxyBase.h
index 99d73c5..715df5c 100644
--- a/src/test/commonapi/tests/TestInterfaceProxyBase.h
+++ b/src/test/commonapi/tests/TestInterfaceProxyBase.h
@@ -1,75 +1,76 @@
- /*
- * This file was generated by the CommonAPI Generators.
- *
- * 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/.
- */
- #ifndef COMMONAPI_TESTS_Test_Interface_PROXY_BASE_H_
- #define COMMONAPI_TESTS_Test_Interface_PROXY_BASE_H_
- 
- #include "TestInterface.h"
- 
- 
- #include <commonapi/tests/DerivedTypeCollection.h>
- 
- #if !defined (COMMONAPI_INTERNAL_COMPILATION)
- #define COMMONAPI_INTERNAL_COMPILATION
- #endif
- 
- #include <CommonAPI/InputStream.h>
- #include <CommonAPI/OutputStream.h>
- #include <cstdint>
- #include <unordered_map>
- #include <vector>
+/*
+* This file was generated by the CommonAPI Generators.
+*
+* 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/.
+*/
+#ifndef COMMONAPI_TESTS_Test_Interface_PROXY_BASE_H_
+#define COMMONAPI_TESTS_Test_Interface_PROXY_BASE_H_
 
- #include <CommonAPI/Attribute.h>
- #include <CommonAPI/Event.h>
- #include <CommonAPI/Proxy.h>
- #include <functional>
- #include <future>
- 
- #undef COMMONAPI_INTERNAL_COMPILATION
+#include "TestInterface.h"
 
- namespace commonapi {
- namespace tests {
 
- class TestInterfaceProxyBase: virtual public CommonAPI::Proxy {
-  public:
-     typedef CommonAPI::ObservableAttribute<uint32_t> TestPredefinedTypeAttributeAttribute;
-     typedef CommonAPI::ObservableAttribute<DerivedTypeCollection::TestStructExtended> TestDerivedStructAttributeAttribute;
-     typedef CommonAPI::ObservableAttribute<DerivedTypeCollection::TestArrayUInt64> TestDerivedArrayAttributeAttribute;
-     typedef CommonAPI::Event<uint32_t, std::string> TestPredefinedTypeBroadcastEvent;
-     typedef std::function<void(const CommonAPI::CallStatus&)> TestEmptyMethodAsyncCallback;
-     typedef std::function<void(const CommonAPI::CallStatus&)> TestVoidPredefinedTypeMethodAsyncCallback;
-     typedef std::function<void(const CommonAPI::CallStatus&, const uint32_t&, const std::string&)> TestPredefinedTypeMethodAsyncCallback;
-     typedef std::function<void(const CommonAPI::CallStatus&)> TestVoidDerivedTypeMethodAsyncCallback;
-     typedef std::function<void(const CommonAPI::CallStatus&, const DerivedTypeCollection::TestEnumExtended2&, const DerivedTypeCollection::TestMap&)> TestDerivedTypeMethodAsyncCallback;
+#include <commonapi/tests/DerivedTypeCollection.h>
 
-     virtual TestPredefinedTypeAttributeAttribute& getTestPredefinedTypeAttributeAttribute() = 0;
-     virtual TestDerivedStructAttributeAttribute& getTestDerivedStructAttributeAttribute() = 0;
-     virtual TestDerivedArrayAttributeAttribute& getTestDerivedArrayAttributeAttribute() = 0;
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#define COMMONAPI_INTERNAL_COMPILATION
+#endif
 
-     virtual TestPredefinedTypeBroadcastEvent& getTestPredefinedTypeBroadcastEvent() = 0;
+#include <CommonAPI/InputStream.h>
+#include <CommonAPI/OutputStream.h>
+#include <cstdint>
+#include <unordered_map>
+#include <vector>
 
+#include <CommonAPI/Attribute.h>
+#include <CommonAPI/Event.h>
+#include <CommonAPI/SelectiveEvent.h>
+#include <CommonAPI/Proxy.h>
+#include <functional>
+#include <future>
 
-     virtual void testEmptyMethod(CommonAPI::CallStatus& callStatus) = 0;
-     virtual std::future<CommonAPI::CallStatus> testEmptyMethodAsync(TestEmptyMethodAsyncCallback callback) = 0;
+#undef COMMONAPI_INTERNAL_COMPILATION
 
-     virtual void testVoidPredefinedTypeMethod(const uint32_t& uint32Value, const std::string& stringValue, CommonAPI::CallStatus& callStatus) = 0;
-     virtual std::future<CommonAPI::CallStatus> testVoidPredefinedTypeMethodAsync(const uint32_t& uint32Value, const std::string& stringValue, TestVoidPredefinedTypeMethodAsyncCallback callback) = 0;
+namespace commonapi {
+namespace tests {
 
-     virtual void testPredefinedTypeMethod(const uint32_t& uint32InValue, const std::string& stringInValue, CommonAPI::CallStatus& callStatus, uint32_t& uint32OutValue, std::string& stringOutValue) = 0;
-     virtual std::future<CommonAPI::CallStatus> testPredefinedTypeMethodAsync(const uint32_t& uint32InValue, const std::string& stringInValue, TestPredefinedTypeMethodAsyncCallback callback) = 0;
+class TestInterfaceProxyBase: virtual public CommonAPI::Proxy {
+ public:
+    typedef CommonAPI::ObservableAttribute<uint32_t> TestPredefinedTypeAttributeAttribute;
+    typedef CommonAPI::ObservableAttribute<DerivedTypeCollection::TestStructExtended> TestDerivedStructAttributeAttribute;
+    typedef CommonAPI::ObservableAttribute<DerivedTypeCollection::TestArrayUInt64> TestDerivedArrayAttributeAttribute;
+    typedef CommonAPI::Event<uint32_t, std::string> TestPredefinedTypeBroadcastEvent;
+    typedef CommonAPI::SelectiveEvent<> TestSelectiveBroadcastSelectiveEvent;
+    typedef CommonAPI::SelectiveEvent<uint32_t, std::string> TestBroadcastWithOutArgsSelectiveEvent;
 
-     virtual void testVoidDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, CommonAPI::CallStatus& callStatus) = 0;
-     virtual std::future<CommonAPI::CallStatus> testVoidDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, TestVoidDerivedTypeMethodAsyncCallback callback) = 0;
+    typedef std::function<void(const CommonAPI::CallStatus&)> TestEmptyMethodAsyncCallback;
+    typedef std::function<void(const CommonAPI::CallStatus&)> TestVoidPredefinedTypeMethodAsyncCallback;
+    typedef std::function<void(const CommonAPI::CallStatus&, const uint32_t&, const std::string&)> TestPredefinedTypeMethodAsyncCallback;
+    typedef std::function<void(const CommonAPI::CallStatus&)> TestVoidDerivedTypeMethodAsyncCallback;
+    typedef std::function<void(const CommonAPI::CallStatus&, const DerivedTypeCollection::TestEnumExtended2&, const DerivedTypeCollection::TestMap&)> TestDerivedTypeMethodAsyncCallback;
 
-     virtual void testDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, CommonAPI::CallStatus& callStatus, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) = 0;
-     virtual std::future<CommonAPI::CallStatus> testDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, TestDerivedTypeMethodAsyncCallback callback) = 0;
- };
+    virtual TestPredefinedTypeAttributeAttribute& getTestPredefinedTypeAttributeAttribute() = 0;
+    virtual TestDerivedStructAttributeAttribute& getTestDerivedStructAttributeAttribute() = 0;
+    virtual TestDerivedArrayAttributeAttribute& getTestDerivedArrayAttributeAttribute() = 0;
 
- } // namespace tests
- } // namespace commonapi
+    virtual TestPredefinedTypeBroadcastEvent& getTestPredefinedTypeBroadcastEvent() = 0;
+    virtual TestSelectiveBroadcastSelectiveEvent& getTestSelectiveBroadcastSelectiveEvent() = 0;
+    virtual TestBroadcastWithOutArgsSelectiveEvent& getTestBroadcastWithOutArgsSelectiveEvent() = 0;
 
- #endif // COMMONAPI_TESTS_Test_Interface_PROXY_BASE_H_
+    virtual void testEmptyMethod(CommonAPI::CallStatus& callStatus) = 0;
+    virtual std::future<CommonAPI::CallStatus> testEmptyMethodAsync(TestEmptyMethodAsyncCallback callback) = 0;
+    virtual void testVoidPredefinedTypeMethod(const uint32_t& uint32Value, const std::string& stringValue, CommonAPI::CallStatus& callStatus) = 0;
+    virtual std::future<CommonAPI::CallStatus> testVoidPredefinedTypeMethodAsync(const uint32_t& uint32Value, const std::string& stringValue, TestVoidPredefinedTypeMethodAsyncCallback callback) = 0;
+    virtual void testPredefinedTypeMethod(const uint32_t& uint32InValue, const std::string& stringInValue, CommonAPI::CallStatus& callStatus, uint32_t& uint32OutValue, std::string& stringOutValue) = 0;
+    virtual std::future<CommonAPI::CallStatus> testPredefinedTypeMethodAsync(const uint32_t& uint32InValue, const std::string& stringInValue, TestPredefinedTypeMethodAsyncCallback callback) = 0;
+    virtual void testVoidDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, CommonAPI::CallStatus& callStatus) = 0;
+    virtual std::future<CommonAPI::CallStatus> testVoidDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, TestVoidDerivedTypeMethodAsyncCallback callback) = 0;
+    virtual void testDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, CommonAPI::CallStatus& callStatus, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) = 0;
+    virtual std::future<CommonAPI::CallStatus> testDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, TestDerivedTypeMethodAsyncCallback callback) = 0;
+};
+
+} // namespace tests
+} // namespace commonapi
+
+#endif // COMMONAPI_TESTS_Test_Interface_PROXY_BASE_H_
diff --git a/src/test/commonapi/tests/TestInterfaceStub.h b/src/test/commonapi/tests/TestInterfaceStub.h
index dd218a1..59ef632 100644
--- a/src/test/commonapi/tests/TestInterfaceStub.h
+++ b/src/test/commonapi/tests/TestInterfaceStub.h
@@ -22,10 +22,10 @@
 #include <CommonAPI/OutputStream.h>
 #include <cstdint>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 #include <CommonAPI/Stub.h>
-#include <CommonAPI/types.h>
 
 #undef COMMONAPI_INTERNAL_COMPILATION
 
@@ -52,6 +52,31 @@ class TestInterfaceStubAdapter: virtual public CommonAPI::StubAdapter, public Te
      * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
      */
     virtual void fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue) = 0;
+    /**
+     * Sends a selective broadcast event for TestSelectiveBroadcast. Should not be called directly.
+     * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
+     */
+    virtual void fireTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
+    virtual void sendTestSelectiveBroadcastSelective(const CommonAPI::ClientIdList* receivers = NULL) = 0;
+    virtual void subscribeForTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success) = 0;
+    virtual void unsubscribeFromTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
+    virtual CommonAPI::ClientIdList* const getSubscribersForTestSelectiveBroadcastSelective() = 0;
+    /**
+     * Sends a selective broadcast event for TestBroadcastWithOutArgs. Should not be called directly.
+     * Instead, the "fire<broadcastName>Event" methods of the stub should be used.
+     */
+    virtual void fireTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, const uint32_t& uint32Value, const std::string& stringValue) = 0;
+    virtual void sendTestBroadcastWithOutArgsSelective(const uint32_t& uint32Value, const std::string& stringValue, const CommonAPI::ClientIdList* receivers = NULL) = 0;
+    virtual void subscribeForTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success) = 0;
+    virtual void unsubscribeFromTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
+    virtual CommonAPI::ClientIdList* const getSubscribersForTestBroadcastWithOutArgsSelective() = 0;
+protected:
+    /**
+     * Defines properties for storing the ClientIds of clients / proxies that have
+     * subscribed to the selective broadcasts
+     */
+    CommonAPI::ClientIdList subscribersForTestSelectiveBroadcastSelective_;
+    CommonAPI::ClientIdList subscribersForTestBroadcastWithOutArgsSelective_;
 };
 
 
@@ -71,20 +96,20 @@ class TestInterfaceStubRemoteEvent {
  public:
     virtual ~TestInterfaceStubRemoteEvent() { }
 
-    /// Verification callback for remote set requests on the attribute TestPredefinedTypeAttribute.
-    virtual bool onRemoteSetTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId, uint32_t TestPredefinedTypeAttribute) = 0;
-    /// Action callback for remote set requests on the attribute TestPredefinedTypeAttribute.
-    virtual void onRemoteTestPredefinedTypeAttributeAttributeChanged() = 0;
+    /// Verification callback for remote set requests on the attribute TestPredefinedTypeAttribute
+     virtual bool onRemoteSetTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t TestPredefinedTypeAttribute) = 0;
+     /// Action callback for remote set requests on the attribute TestPredefinedTypeAttribute
+     virtual void onRemoteTestPredefinedTypeAttributeAttributeChanged() = 0;
 
-    /// Verification callback for remote set requests on the attribute TestDerivedStructAttribute.
-    virtual bool onRemoteSetTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestStructExtended TestDerivedStructAttribute) = 0;
-    /// Action callback for remote set requests on the attribute TestDerivedStructAttribute.
-    virtual void onRemoteTestDerivedStructAttributeAttributeChanged() = 0;
+    /// Verification callback for remote set requests on the attribute TestDerivedStructAttribute
+     virtual bool onRemoteSetTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestStructExtended TestDerivedStructAttribute) = 0;
+     /// Action callback for remote set requests on the attribute TestDerivedStructAttribute
+     virtual void onRemoteTestDerivedStructAttributeAttributeChanged() = 0;
 
-    /// Verification callback for remote set requests on the attribute TestDerivedArrayAttribute.
-    virtual bool onRemoteSetTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestArrayUInt64 TestDerivedArrayAttribute) = 0;
-    /// Action callback for remote set requests on the attribute TestDerivedArrayAttribute.
-    virtual void onRemoteTestDerivedArrayAttributeAttributeChanged() = 0;
+    /// Verification callback for remote set requests on the attribute TestDerivedArrayAttribute
+     virtual bool onRemoteSetTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestArrayUInt64 TestDerivedArrayAttribute) = 0;
+     /// Action callback for remote set requests on the attribute TestDerivedArrayAttribute
+     virtual void onRemoteTestDerivedArrayAttributeAttributeChanged() = 0;
 
 };
 
@@ -99,26 +124,49 @@ class TestInterfaceStub : public CommonAPI::Stub<TestInterfaceStubAdapter , Test
  public:
     virtual ~TestInterfaceStub() { }
 
-    /// Provides getter access to the attribute TestPredefinedTypeAttribute.
-    virtual const uint32_t& getTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId) = 0;
-    /// Provides getter access to the attribute TestDerivedStructAttribute.
-    virtual const DerivedTypeCollection::TestStructExtended& getTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId) = 0;
-    /// Provides getter access to the attribute TestDerivedArrayAttribute.
-    virtual const DerivedTypeCollection::TestArrayUInt64& getTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId) = 0;
+    /// Provides getter access to the attribute TestPredefinedTypeAttribute
+    virtual const uint32_t& getTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
+    /// Provides getter access to the attribute TestDerivedStructAttribute
+    virtual const DerivedTypeCollection::TestStructExtended& getTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
+    /// Provides getter access to the attribute TestDerivedArrayAttribute
+    virtual const DerivedTypeCollection::TestArrayUInt64& getTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
 
     /// This is the method that will be called on remote calls on the method testEmptyMethod.
-    virtual void testEmptyMethod(const CommonAPI::ClientId& clientId) = 0;
+    virtual void testEmptyMethod(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
     /// This is the method that will be called on remote calls on the method testVoidPredefinedTypeMethod.
-    virtual void testVoidPredefinedTypeMethod(const CommonAPI::ClientId& clientId, uint32_t uint32Value, std::string stringValue) = 0;
+    virtual void testVoidPredefinedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t uint32Value, std::string stringValue) = 0;
     /// This is the method that will be called on remote calls on the method testPredefinedTypeMethod.
-    virtual void testPredefinedTypeMethod(const CommonAPI::ClientId& clientId, uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue) = 0;
+    virtual void testPredefinedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue) = 0;
     /// This is the method that will be called on remote calls on the method testVoidDerivedTypeMethod.
-    virtual void testVoidDerivedTypeMethod(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue) = 0;
+    virtual void testVoidDerivedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue) = 0;
     /// This is the method that will be called on remote calls on the method testDerivedTypeMethod.
-    virtual void testDerivedTypeMethod(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) = 0;
-    
+    virtual void testDerivedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) = 0;
     /// Sends a broadcast event for TestPredefinedTypeBroadcast.
     virtual void fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue) = 0;
+    /**
+     * Sends a selective broadcast event for TestSelectiveBroadcast to the given ClientIds.
+     * The ClientIds must all be out of the set of subscribed clients.
+     * If no ClientIds are given, the selective broadcast is sent to all subscribed clients.
+     */
+    virtual void fireTestSelectiveBroadcastSelective(const CommonAPI::ClientIdList* receivers = NULL) = 0;
+    /// retreives the list of all subscribed clients for TestSelectiveBroadcast
+    virtual CommonAPI::ClientIdList* const getSubscribersForTestSelectiveBroadcastSelective() = 0;
+    /// Hook method for reacting on new subscriptions or removed subscriptions respectively for selective broadcasts.
+    virtual void onTestSelectiveBroadcastSelectiveSubscriptionChanged(const std::shared_ptr<CommonAPI::ClientId> clientId, const CommonAPI::SelectiveBroadcastSubscriptionEvent event) = 0;
+    /// Hook method for reacting accepting or denying new subscriptions 
+    virtual bool onTestSelectiveBroadcastSelectiveSubscriptionRequested(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
+    /**
+     * Sends a selective broadcast event for TestBroadcastWithOutArgs to the given ClientIds.
+     * The ClientIds must all be out of the set of subscribed clients.
+     * If no ClientIds are given, the selective broadcast is sent to all subscribed clients.
+     */
+    virtual void fireTestBroadcastWithOutArgsSelective(const uint32_t& uint32Value, const std::string& stringValue, const CommonAPI::ClientIdList* receivers = NULL) = 0;
+    /// retreives the list of all subscribed clients for TestBroadcastWithOutArgs
+    virtual CommonAPI::ClientIdList* const getSubscribersForTestBroadcastWithOutArgsSelective() = 0;
+    /// Hook method for reacting on new subscriptions or removed subscriptions respectively for selective broadcasts.
+    virtual void onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(const std::shared_ptr<CommonAPI::ClientId> clientId, const CommonAPI::SelectiveBroadcastSubscriptionEvent event) = 0;
+    /// Hook method for reacting accepting or denying new subscriptions 
+    virtual bool onTestBroadcastWithOutArgsSelectiveSubscriptionRequested(const std::shared_ptr<CommonAPI::ClientId> clientId) = 0;
 };
 
 } // namespace tests
diff --git a/src/test/commonapi/tests/TestInterfaceStubDefault.cpp b/src/test/commonapi/tests/TestInterfaceStubDefault.cpp
index 3f7d13b..e68bf40 100644
--- a/src/test/commonapi/tests/TestInterfaceStubDefault.cpp
+++ b/src/test/commonapi/tests/TestInterfaceStubDefault.cpp
@@ -23,7 +23,7 @@ const uint32_t& TestInterfaceStubDefault::getTestPredefinedTypeAttributeAttribut
     return testPredefinedTypeAttributeAttributeValue_;
 }
 
-const uint32_t& TestInterfaceStubDefault::getTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId) {
+const uint32_t& TestInterfaceStubDefault::getTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) {
     return getTestPredefinedTypeAttributeAttribute();
 }
 
@@ -33,7 +33,7 @@ void TestInterfaceStubDefault::setTestPredefinedTypeAttributeAttribute(uint32_t
         stubAdapter_->fireTestPredefinedTypeAttributeAttributeChanged(testPredefinedTypeAttributeAttributeValue_);
 }
 
-void TestInterfaceStubDefault::setTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId, uint32_t value) {
+void TestInterfaceStubDefault::setTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t value) {
        setTestPredefinedTypeAttributeAttribute(value);
 }
 
@@ -58,7 +58,7 @@ bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestPredefinedType
     return defaultStub_->trySetTestPredefinedTypeAttributeAttribute(std::move(value));
 }
 
-bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId, uint32_t value) {
+bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t value) {
     return onRemoteSetTestPredefinedTypeAttributeAttribute(value);
 }
 
@@ -70,7 +70,7 @@ const DerivedTypeCollection::TestStructExtended& TestInterfaceStubDefault::getTe
     return testDerivedStructAttributeAttributeValue_;
 }
 
-const DerivedTypeCollection::TestStructExtended& TestInterfaceStubDefault::getTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId) {
+const DerivedTypeCollection::TestStructExtended& TestInterfaceStubDefault::getTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) {
     return getTestDerivedStructAttributeAttribute();
 }
 
@@ -80,7 +80,7 @@ void TestInterfaceStubDefault::setTestDerivedStructAttributeAttribute(DerivedTyp
         stubAdapter_->fireTestDerivedStructAttributeAttributeChanged(testDerivedStructAttributeAttributeValue_);
 }
 
-void TestInterfaceStubDefault::setTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestStructExtended value) {
+void TestInterfaceStubDefault::setTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestStructExtended value) {
        setTestDerivedStructAttributeAttribute(value);
 }
 
@@ -105,7 +105,7 @@ bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestDerivedStructA
     return defaultStub_->trySetTestDerivedStructAttributeAttribute(std::move(value));
 }
 
-bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestStructExtended value) {
+bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestStructExtended value) {
     return onRemoteSetTestDerivedStructAttributeAttribute(value);
 }
 
@@ -117,7 +117,7 @@ const DerivedTypeCollection::TestArrayUInt64& TestInterfaceStubDefault::getTestD
     return testDerivedArrayAttributeAttributeValue_;
 }
 
-const DerivedTypeCollection::TestArrayUInt64& TestInterfaceStubDefault::getTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId) {
+const DerivedTypeCollection::TestArrayUInt64& TestInterfaceStubDefault::getTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId) {
     return getTestDerivedArrayAttributeAttribute();
 }
 
@@ -127,7 +127,7 @@ void TestInterfaceStubDefault::setTestDerivedArrayAttributeAttribute(DerivedType
         stubAdapter_->fireTestDerivedArrayAttributeAttributeChanged(testDerivedArrayAttributeAttributeValue_);
 }
 
-void TestInterfaceStubDefault::setTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestArrayUInt64 value) {
+void TestInterfaceStubDefault::setTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestArrayUInt64 value) {
        setTestDerivedArrayAttributeAttribute(value);
 }
 
@@ -152,7 +152,7 @@ bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestDerivedArrayAt
     return defaultStub_->trySetTestDerivedArrayAttributeAttribute(std::move(value));
 }
 
-bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestArrayUInt64 value) {
+bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestArrayUInt64 value) {
     return onRemoteSetTestDerivedArrayAttributeAttribute(value);
 }
 
@@ -161,61 +161,59 @@ void TestInterfaceStubDefault::RemoteEventHandler::onRemoteTestDerivedArrayAttri
 }
 
 
-void TestInterfaceStubDefault::testEmptyMethod() {
+void TestInterfaceStubDefault::testEmptyMethod(const std::shared_ptr<CommonAPI::ClientId> clientId) {
     // No operation in default
 }
 
-
-void TestInterfaceStubDefault::testEmptyMethod(const CommonAPI::ClientId& clientId) {
-    // Call compatibility interface
-    testEmptyMethod();
+void TestInterfaceStubDefault::testVoidPredefinedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t uint32Value, std::string stringValue) {
+    // No operation in default
 }
 
-void TestInterfaceStubDefault::testVoidPredefinedTypeMethod(uint32_t uint32Value, std::string stringValue) {
+void TestInterfaceStubDefault::testPredefinedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue) {
     // No operation in default
 }
 
-
-void TestInterfaceStubDefault::testVoidPredefinedTypeMethod(const CommonAPI::ClientId& clientId, uint32_t uint32Value, std::string stringValue) {
-    // Call compatibility interface
-    testVoidPredefinedTypeMethod(uint32Value, stringValue);
+void TestInterfaceStubDefault::testVoidDerivedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue) {
+    // No operation in default
 }
 
-void TestInterfaceStubDefault::testPredefinedTypeMethod(uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue) {
+void TestInterfaceStubDefault::testDerivedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) {
     // No operation in default
 }
 
 
-void TestInterfaceStubDefault::testPredefinedTypeMethod(const CommonAPI::ClientId& clientId, uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue) {
-    // Call compatibility interface
-    testPredefinedTypeMethod(uint32InValue, stringInValue, uint32OutValue, stringOutValue);
+void TestInterfaceStubDefault::fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue) {
+    stubAdapter_->fireTestPredefinedTypeBroadcastEvent(uint32Value, stringValue);
 }
-
-void TestInterfaceStubDefault::testVoidDerivedTypeMethod(DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue) {
+void TestInterfaceStubDefault::fireTestSelectiveBroadcastSelective(const CommonAPI::ClientIdList* receivers) {
+    stubAdapter_->sendTestSelectiveBroadcastSelective(receivers);
+}
+void TestInterfaceStubDefault::onTestSelectiveBroadcastSelectiveSubscriptionChanged(const std::shared_ptr<CommonAPI::ClientId> clientId, const CommonAPI::SelectiveBroadcastSubscriptionEvent event) {
     // No operation in default
 }
-
-
-void TestInterfaceStubDefault::testVoidDerivedTypeMethod(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue) {
-    // Call compatibility interface
-    testVoidDerivedTypeMethod(testEnumExtended2Value, testMapValue);
+bool TestInterfaceStubDefault::onTestSelectiveBroadcastSelectiveSubscriptionRequested(const std::shared_ptr<CommonAPI::ClientId> clientId) {
+    // Accept in default
+    return true;
+}
+CommonAPI::ClientIdList* const TestInterfaceStubDefault::getSubscribersForTestSelectiveBroadcastSelective() {
+    return(stubAdapter_->getSubscribersForTestSelectiveBroadcastSelective());
 }
 
-void TestInterfaceStubDefault::testDerivedTypeMethod(DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) {
+void TestInterfaceStubDefault::fireTestBroadcastWithOutArgsSelective(const uint32_t& uint32Value, const std::string& stringValue, const CommonAPI::ClientIdList* receivers) {
+    stubAdapter_->sendTestBroadcastWithOutArgsSelective(uint32Value, stringValue, receivers);
+}
+void TestInterfaceStubDefault::onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(const std::shared_ptr<CommonAPI::ClientId> clientId, const CommonAPI::SelectiveBroadcastSubscriptionEvent event) {
     // No operation in default
 }
-
-
-void TestInterfaceStubDefault::testDerivedTypeMethod(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) {
-    // Call compatibility interface
-    testDerivedTypeMethod(testEnumExtended2InValue, testMapInValue, testEnumExtended2OutValue, testMapOutValue);
+bool TestInterfaceStubDefault::onTestBroadcastWithOutArgsSelectiveSubscriptionRequested(const std::shared_ptr<CommonAPI::ClientId> clientId) {
+    // Accept in default
+    return true;
 }
-
-
-void TestInterfaceStubDefault::fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue) {
-    stubAdapter_->fireTestPredefinedTypeBroadcastEvent(uint32Value, stringValue);
+CommonAPI::ClientIdList* const TestInterfaceStubDefault::getSubscribersForTestBroadcastWithOutArgsSelective() {
+    return(stubAdapter_->getSubscribersForTestBroadcastWithOutArgsSelective());
 }
 
+
 TestInterfaceStubDefault::RemoteEventHandler::RemoteEventHandler(TestInterfaceStubDefault* defaultStub):
         defaultStub_(defaultStub) {
 }
diff --git a/src/test/commonapi/tests/TestInterfaceStubDefault.h b/src/test/commonapi/tests/TestInterfaceStubDefault.h
index f149d37..0128b8e 100644
--- a/src/test/commonapi/tests/TestInterfaceStubDefault.h
+++ b/src/test/commonapi/tests/TestInterfaceStubDefault.h
@@ -18,7 +18,7 @@ namespace tests {
  * TestInterfaceStub. Method callbacks have an empty implementation,
  * remote set calls on attributes will always change the value of the attribute
  * to the one received.
- * 
+ *
  * Override this stub if you only want to provide a subset of the functionality
  * that would be defined for this service, and/or if you do not need any non-default
  * behaviour.
@@ -30,65 +30,69 @@ class TestInterfaceStubDefault : public TestInterfaceStub {
     TestInterfaceStubRemoteEvent* initStubAdapter(const std::shared_ptr<TestInterfaceStubAdapter>& stubAdapter);
 
     virtual const uint32_t& getTestPredefinedTypeAttributeAttribute();
-    virtual const uint32_t& getTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId);
+    virtual const uint32_t& getTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId);
     virtual void setTestPredefinedTypeAttributeAttribute(uint32_t value);
-    virtual void setTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId, uint32_t value);
+    virtual void setTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t value);
     virtual const DerivedTypeCollection::TestStructExtended& getTestDerivedStructAttributeAttribute();
-    virtual const DerivedTypeCollection::TestStructExtended& getTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId);
+    virtual const DerivedTypeCollection::TestStructExtended& getTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId);
     virtual void setTestDerivedStructAttributeAttribute(DerivedTypeCollection::TestStructExtended value);
-    virtual void setTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestStructExtended value);
+    virtual void setTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestStructExtended value);
     virtual const DerivedTypeCollection::TestArrayUInt64& getTestDerivedArrayAttributeAttribute();
-    virtual const DerivedTypeCollection::TestArrayUInt64& getTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId);
+    virtual const DerivedTypeCollection::TestArrayUInt64& getTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId);
     virtual void setTestDerivedArrayAttributeAttribute(DerivedTypeCollection::TestArrayUInt64 value);
-    virtual void setTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestArrayUInt64 value);
+    virtual void setTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestArrayUInt64 value);
 
-    virtual void testEmptyMethod();
-    virtual void testEmptyMethod(const CommonAPI::ClientId& clientId);
+    virtual void testEmptyMethod(const std::shared_ptr<CommonAPI::ClientId> clientId);
 
-    virtual void testVoidPredefinedTypeMethod(uint32_t uint32Value, std::string stringValue);
-    virtual void testVoidPredefinedTypeMethod(const CommonAPI::ClientId& clientId, uint32_t uint32Value, std::string stringValue);
+    virtual void testVoidPredefinedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t uint32Value, std::string stringValue);
 
-    virtual void testPredefinedTypeMethod(uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue);
-    virtual void testPredefinedTypeMethod(const CommonAPI::ClientId& clientId, uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue);
+    virtual void testPredefinedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue);
 
-    virtual void testVoidDerivedTypeMethod(DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue);
-    virtual void testVoidDerivedTypeMethod(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue);
+    virtual void testVoidDerivedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue);
+
+    virtual void testDerivedTypeMethod(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue);
 
-    virtual void testDerivedTypeMethod(DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue);
-    virtual void testDerivedTypeMethod(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue);
 
-    
     virtual void fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue);
+    virtual void fireTestSelectiveBroadcastSelective(const CommonAPI::ClientIdList* receivers = NULL);
+    virtual CommonAPI::ClientIdList* const getSubscribersForTestSelectiveBroadcastSelective();
+    /// Hook method for reacting on new subscriptions or removed subscriptions respectively for selective broadcasts.
+    virtual void onTestSelectiveBroadcastSelectiveSubscriptionChanged(const std::shared_ptr<CommonAPI::ClientId> clientId, const CommonAPI::SelectiveBroadcastSubscriptionEvent event);
+    /// Hook method for reacting accepting or denying new subscriptions 
+    virtual bool onTestSelectiveBroadcastSelectiveSubscriptionRequested(const std::shared_ptr<CommonAPI::ClientId> clientId);
+    virtual void fireTestBroadcastWithOutArgsSelective(const uint32_t& uint32Value, const std::string& stringValue, const CommonAPI::ClientIdList* receivers = NULL);
+    virtual CommonAPI::ClientIdList* const getSubscribersForTestBroadcastWithOutArgsSelective();
+    /// Hook method for reacting on new subscriptions or removed subscriptions respectively for selective broadcasts.
+    virtual void onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(const std::shared_ptr<CommonAPI::ClientId> clientId, const CommonAPI::SelectiveBroadcastSubscriptionEvent event);
+    /// Hook method for reacting accepting or denying new subscriptions 
+    virtual bool onTestBroadcastWithOutArgsSelectiveSubscriptionRequested(const std::shared_ptr<CommonAPI::ClientId> clientId);
 
  protected:
     virtual void onRemoteTestPredefinedTypeAttributeAttributeChanged();
     virtual bool trySetTestPredefinedTypeAttributeAttribute(uint32_t value);
     virtual bool validateTestPredefinedTypeAttributeAttributeRequestedValue(const uint32_t& value);
-
     virtual void onRemoteTestDerivedStructAttributeAttributeChanged();
     virtual bool trySetTestDerivedStructAttributeAttribute(DerivedTypeCollection::TestStructExtended value);
     virtual bool validateTestDerivedStructAttributeAttributeRequestedValue(const DerivedTypeCollection::TestStructExtended& value);
-
     virtual void onRemoteTestDerivedArrayAttributeAttributeChanged();
     virtual bool trySetTestDerivedArrayAttributeAttribute(DerivedTypeCollection::TestArrayUInt64 value);
     virtual bool validateTestDerivedArrayAttributeAttributeRequestedValue(const DerivedTypeCollection::TestArrayUInt64& value);
-
-    
+    std::shared_ptr<TestInterfaceStubAdapter> stubAdapter_;
  private:
     class RemoteEventHandler: public TestInterfaceStubRemoteEvent {
      public:
         RemoteEventHandler(TestInterfaceStubDefault* defaultStub);
 
         virtual bool onRemoteSetTestPredefinedTypeAttributeAttribute(uint32_t value);
-        virtual bool onRemoteSetTestPredefinedTypeAttributeAttribute(const CommonAPI::ClientId& clientId, uint32_t value);
+        virtual bool onRemoteSetTestPredefinedTypeAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, uint32_t value);
         virtual void onRemoteTestPredefinedTypeAttributeAttributeChanged();
 
         virtual bool onRemoteSetTestDerivedStructAttributeAttribute(DerivedTypeCollection::TestStructExtended value);
-        virtual bool onRemoteSetTestDerivedStructAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestStructExtended value);
+        virtual bool onRemoteSetTestDerivedStructAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestStructExtended value);
         virtual void onRemoteTestDerivedStructAttributeAttributeChanged();
 
         virtual bool onRemoteSetTestDerivedArrayAttributeAttribute(DerivedTypeCollection::TestArrayUInt64 value);
-        virtual bool onRemoteSetTestDerivedArrayAttributeAttribute(const CommonAPI::ClientId& clientId, DerivedTypeCollection::TestArrayUInt64 value);
+        virtual bool onRemoteSetTestDerivedArrayAttributeAttribute(const std::shared_ptr<CommonAPI::ClientId> clientId, DerivedTypeCollection::TestArrayUInt64 value);
         virtual void onRemoteTestDerivedArrayAttributeAttributeChanged();
 
 
@@ -97,7 +101,6 @@ class TestInterfaceStubDefault : public TestInterfaceStub {
     };
 
     RemoteEventHandler remoteEventHandler_;
-    std::shared_ptr<TestInterfaceStubAdapter> stubAdapter_;
 
     uint32_t testPredefinedTypeAttributeAttributeValue_;
     DerivedTypeCollection::TestStructExtended testDerivedStructAttributeAttributeValue_;
diff --git a/src/test/test-interface-proxy.fidl b/src/test/test-interface-proxy.fidl
index 774c1a8..0dd97fe 100644
--- a/src/test/test-interface-proxy.fidl
+++ b/src/test/test-interface-proxy.fidl
@@ -57,5 +57,15 @@ interface TestInterface {
 			String stringValue
 		}
 	}
+
+	broadcast TestSelectiveBroadcast selective {
+	}
+		
+	broadcast TestBroadcastWithOutArgs selective {
+        out {
+            UInt32 uint32Value
+            String stringValue
+        }	    
+	}
 }