Merge branch 'master' of https://asc-repo.bmwgroup.net/gerrit/ascgit017.CommonAPI-D-Bus

4 files changed, 92 insertions, 6 deletions

diff --git a/src/CommonAPI/DBus/DBusEvent.h b/src/CommonAPI/DBus/DBusEvent.h
index 7b43ba2..df21e24 100644
--- a/src/CommonAPI/DBus/DBusEvent.h
+++ b/src/CommonAPI/DBus/DBusEvent.h
@@ -58,7 +58,7 @@ class DBusEvent: public _EventType, public DBusProxyConnection::DBusSignalHandle
 
     virtual ~DBusEvent() {
         if (this->hasListeners())
-            dbusProxy_.removeSignalMemberHandler(subscription_);
+            dbusProxy_.removeSignalMemberHandler(subscription_, this);
     }
 
     virtual SubscriptionStatus onSignalDBusMessage(const DBusMessage& dbusMessage) {
@@ -74,7 +74,7 @@ class DBusEvent: public _EventType, public DBusProxyConnection::DBusSignalHandle
     }
 
     virtual void onLastListenerRemoved(const CancellableListener&) {
-        dbusProxy_.removeSignalMemberHandler(subscription_);
+        dbusProxy_.removeSignalMemberHandler(subscription_, this);
     }
 
     template<typename ... _Arguments>
diff --git a/src/CommonAPI/DBus/DBusProxyBase.cpp b/src/CommonAPI/DBus/DBusProxyBase.cpp
index f796cfb..a493606 100644
--- a/src/CommonAPI/DBus/DBusProxyBase.cpp
+++ b/src/CommonAPI/DBus/DBusProxyBase.cpp
@@ -59,8 +59,8 @@ DBusProxyConnection::DBusSignalHandlerToken DBusProxyBase::addSignalMemberHandle
                 justAddFilter);
 }
 
-bool DBusProxyBase::removeSignalMemberHandler(const DBusProxyConnection::DBusSignalHandlerToken& dbusSignalHandlerToken) {
-    return dbusConnection_->removeSignalMemberHandler(dbusSignalHandlerToken);
+bool DBusProxyBase::removeSignalMemberHandler(const DBusProxyConnection::DBusSignalHandlerToken& dbusSignalHandlerToken, const DBusProxyConnection::DBusSignalHandler* dbusSignalHandler) {
+    return dbusConnection_->removeSignalMemberHandler(dbusSignalHandlerToken, dbusSignalHandler);
 }
 
 } // namespace DBus
diff --git a/src/CommonAPI/DBus/DBusProxyBase.h b/src/CommonAPI/DBus/DBusProxyBase.h
index 2896d83..d1a3a51 100644
--- a/src/CommonAPI/DBus/DBusProxyBase.h
+++ b/src/CommonAPI/DBus/DBusProxyBase.h
@@ -55,7 +55,7 @@ class DBusProxyBase: public virtual CommonAPI::Proxy {
                 DBusProxyConnection::DBusSignalHandler* dbusSignalHandler,
                 const bool justAddFilter = false);
 
-    bool removeSignalMemberHandler(const DBusProxyConnection::DBusSignalHandlerToken& dbusSignalHandlerToken);
+    bool removeSignalMemberHandler(const DBusProxyConnection::DBusSignalHandlerToken& dbusSignalHandlerToken, const DBusProxyConnection::DBusSignalHandler* dbusSignalHandler = NULL);
 
     virtual void init() = 0;
 
diff --git a/src/test/DBusBroadcastTest.cpp b/src/test/DBusBroadcastTest.cpp
index 491baab..b07571a 100644
--- a/src/test/DBusBroadcastTest.cpp
+++ b/src/test/DBusBroadcastTest.cpp
@@ -348,7 +348,7 @@ TEST_F(DBusBroadcastTest, ProxysCanCancelSubscriptionAndSubscribeAgainWithOtherP
 
     bool callbackArrived = false;
 
-    auto broadcastSubscription = broadcastEvent.subscribeCancellableListener([&](uint32_t intParam, std::string stringParam) -> CommonAPI::SubscriptionStatus {
+    broadcastEvent.subscribeCancellableListener([&](uint32_t intParam, std::string stringParam) -> CommonAPI::SubscriptionStatus {
             EXPECT_EQ(intParam, 1);
             callbackArrived = true;
             return CommonAPI::SubscriptionStatus::CANCEL;
@@ -383,6 +383,92 @@ TEST_F(DBusBroadcastTest, ProxysCanCancelSubscriptionAndSubscribeAgainWithOtherP
 
     ASSERT_TRUE(callbackArrived);
 
+    broadcastEvent2.unsubscribe(broadcastSubscription2);
+}
+
+TEST_F(DBusBroadcastTest, ProxysCanUnsubscribeFromBroadcastAndSubscribeAgainWhileOtherProxyIsStillSubscribed) {
+    // register service
+    auto stub = std::make_shared<SelectiveBroadcastSender>();
+
+    bool serviceRegistered = servicePublisher_->registerService(stub, serviceAddress_, stubFactory_);
+    for (unsigned int i = 0; !serviceRegistered && i < 100; ++i) {
+        serviceRegistered = servicePublisher_->registerService(stub, serviceAddress_, stubFactory_);
+        usleep(10000);
+    }
+    ASSERT_TRUE(serviceRegistered);
+
+    // build 2 proxies from same factory
+    auto proxy = proxyFactory_->buildProxy<commonapi::tests::TestInterfaceProxy>(serviceAddress_);
+    auto proxy2 = proxyFactory_->buildProxy<commonapi::tests::TestInterfaceProxy>(serviceAddress_);
+
+    commonapi::tests::TestInterfaceProxyDefault::TestPredefinedTypeBroadcastEvent& broadcastEvent =
+                    proxy->getTestPredefinedTypeBroadcastEvent();
+
+    commonapi::tests::TestInterfaceProxyDefault::TestPredefinedTypeBroadcastEvent& broadcastEvent2 =
+                    proxy2->getTestPredefinedTypeBroadcastEvent();
+
+    bool callback1Arrived = false;
+    bool callback2Arrived = false;
+
+    // subscribe for each proxy's broadcast event
+    auto broadcastSubscription = broadcastEvent.subscribeCancellableListener([&](uint32_t intParam, std::string stringParam) -> CommonAPI::SubscriptionStatus {
+            callback1Arrived = true;
+            return CommonAPI::SubscriptionStatus::RETAIN;
+    });
+
+    auto broadcastSubscription2 = broadcastEvent2.subscribeCancellableListener([&](uint32_t intParam, std::string stringParam) -> CommonAPI::SubscriptionStatus {
+            callback2Arrived = true;
+            return CommonAPI::SubscriptionStatus::RETAIN;
+    });
+
+    // fire broadcast and wait for results
+    stub->fireTestPredefinedTypeBroadcastEvent(1, "xyz");
+
+    for(unsigned int i=0; i<100 && !(callback1Arrived && callback2Arrived); i++) {
+        usleep(10000);
+    }
+
+    const bool callbackOnBothSubscriptionsArrived = callback1Arrived && callback2Arrived;
+
+    EXPECT_TRUE(callbackOnBothSubscriptionsArrived);
+
+    // unsubscribe from one proxy's broadcast
+    broadcastEvent.unsubscribe(broadcastSubscription);
+
+    // fire broadcast again
+    callback1Arrived = false;
+    callback2Arrived = false;
+
+    stub->fireTestPredefinedTypeBroadcastEvent(2, "xyz");
+
+    for(unsigned int i=0; i<100; i++) {
+        usleep(10000);
+    }
+
+    const bool onlyCallback2Arrived = !callback1Arrived && callback2Arrived;
+
+    EXPECT_TRUE(onlyCallback2Arrived);
+
+    // subscribe first proxy again
+    broadcastSubscription = broadcastEvent.subscribeCancellableListener([&](uint32_t intParam, std::string stringParam) -> CommonAPI::SubscriptionStatus {
+            callback1Arrived = true;
+            return CommonAPI::SubscriptionStatus::RETAIN;
+    });
+
+    // fire broadcast another time
+    callback1Arrived = false;
+    callback2Arrived = false;
+
+    stub->fireTestPredefinedTypeBroadcastEvent(1, "xyz");
+
+    for(unsigned int i=0; i<100 && !(callback1Arrived && callback2Arrived); i++) {
+        usleep(10000);
+    }
+
+    const bool callbackOnBothSubscriptionsArrivedAgain = callback1Arrived && callback2Arrived;
+
+    EXPECT_TRUE(callbackOnBothSubscriptionsArrivedAgain);
+
     broadcastEvent.unsubscribe(broadcastSubscription);
     broadcastEvent2.unsubscribe(broadcastSubscription2);
 }