Multiple connection names from one factory

[profile/ivi/common-api-dbus-runtime.git] / src / CommonAPI / DBus / DBusFactory.cpp

diff --git a/src/CommonAPI/DBus/DBusFactory.cpp b/src/CommonAPI/DBus/DBusFactory.cpp
index c75a393..39bfb7a 100644 (file)
--- a/src/CommonAPI/DBus/DBusFactory.cpp
+++ b/src/CommonAPI/DBus/DBusFactory.cpp
@@ -11,6 +11,7 @@
 #include "DBusAddressTranslator.h"
 #include "DBusServiceRegistry.h"
 #include "DBusUtils.h"
+#include "DBusServicePublisher.h"
 
 #include <algorithm>
 #include <cassert>
@@ -44,7 +45,6 @@ void DBusFactory::registerAdapterFactoryMethod(std::string interfaceName, DBusAd
 DBusFactory::DBusFactory(std::shared_ptr<Runtime> runtime, const MiddlewareInfo* middlewareInfo, std::shared_ptr<MainLoopContext> mainLoopContext) :
                 CommonAPI::Factory(runtime, middlewareInfo),
                 dbusConnection_(CommonAPI::DBus::DBusConnection::getSessionBus()),
-                acquiredConnectionName_(""),
                 mainLoopContext_(mainLoopContext) {
     bool startDispatchThread = !mainLoopContext_;
     dbusConnection_->connect(startDispatchThread);
@@ -64,6 +64,11 @@ std::vector<std::string> DBusFactory::getAvailableServiceInstances(const std::st
 }
 
 
+void DBusFactory::getAvailableServiceInstancesAsync(Factory::GetAvailableServiceInstancesCallback callback, const std::string& serviceName, const std::string& serviceDomainName) {
+    dbusConnection_->getDBusServiceRegistry()->getAvailableServiceInstancesAsync(callback, serviceName, serviceDomainName);
+}
+
+
 bool DBusFactory::isServiceInstanceAlive(const std::string& serviceAddress) {
     std::vector<std::string> parts = split(serviceAddress, ':');
     assert(parts[0] == "local");
@@ -85,6 +90,33 @@ bool DBusFactory::isServiceInstanceAlive(const std::string& participantId,
 }
 
 
+SubscriptionStatus DBusFactory::isServiceInstanceAliveCallbackThunk(Factory::IsServiceInstanceAliveCallback callback, const AvailabilityStatus& status) {
+    callback(status == AvailabilityStatus::AVAILABLE);
+    return SubscriptionStatus::CANCEL;
+}
+
+void DBusFactory::isServiceInstanceAliveAsync(Factory::IsServiceInstanceAliveCallback callback, const std::string& serviceAddress) {
+    std::string interfaceName;
+    std::string connectionName;
+    std::string objectPath;
+
+    DBusAddressTranslator::getInstance().searchForDBusAddress(serviceAddress, interfaceName, connectionName, objectPath);
+
+    dbusConnection_->getDBusServiceRegistry()->subscribeAvailabilityListener(
+                    serviceAddress,
+                    std::bind(&DBusFactory::isServiceInstanceAliveCallbackThunk,
+                              this,
+                              callback,
+                              std::placeholders::_1)
+    );
+}
+
+void DBusFactory::isServiceInstanceAliveAsync(Factory::IsServiceInstanceAliveCallback callback, const std::string& serviceInstanceID, const std::string& serviceName, const std::string& serviceDomainName) {
+    std::string commonApiAddress = serviceDomainName + ":" + serviceName + ":" + serviceInstanceID;
+    isServiceInstanceAliveAsync(callback, commonApiAddress);
+}
+
+
 std::shared_ptr<Proxy> DBusFactory::createProxy(const char* interfaceId,
                                                 const std::string& participantId,
                                                 const std::string& serviceName,
@@ -125,13 +157,8 @@ bool DBusFactory::registerAdapter(std::shared_ptr<StubBase> stubBase,
 
     DBusAddressTranslator::getInstance().searchForDBusAddress(commonApiAddress, interfaceName, connectionName, objectPath);
 
-    if(acquiredConnectionName_ == "") {
-        bool isServiceNameAcquired = dbusConnection_->requestServiceNameAndBlock(connectionName);
-        if(!isServiceNameAcquired) {
-            return false;
-        }
-        acquiredConnectionName_ = connectionName;
-    } else if (acquiredConnectionName_ != connectionName) {
+    bool isServiceNameAcquired = dbusConnection_->requestServiceNameAndBlock(connectionName);
+    if (!isServiceNameAcquired) {
         return false;
     }
 
@@ -141,11 +168,11 @@ bool DBusFactory::registerAdapter(std::shared_ptr<StubBase> stubBase,
 
     auto foundFunction = registeredAdapterFactoryFunctions_->find(interfaceId);
     if(foundFunction != registeredAdapterFactoryFunctions_->end()) {
-        std::shared_ptr<DBusStubAdapter> dbusStubAdapter =  (foundFunction->second)(commonApiAddress, interfaceName, connectionName, objectPath, dbusConnection_, stubBase);
+        std::shared_ptr<DBusStubAdapter> dbusStubAdapter = (foundFunction->second)(commonApiAddress, interfaceName, connectionName, objectPath, dbusConnection_, stubBase);
         if(!dbusStubAdapter) {
             return false;
         }
-        if(registeredServices_.insert( {std::move(commonApiAddress), dbusStubAdapter} ).second) {
+        if(DBusServicePublisher::getInstance()->registerService(commonApiAddress, dbusStubAdapter)) {
             dbusStubAdapter->init();
             return true;
         }
@@ -155,14 +182,8 @@ bool DBusFactory::registerAdapter(std::shared_ptr<StubBase> stubBase,
 }
 
 bool DBusFactory::unregisterService(const std::string& participantId, const std::string& serviceName, const std::string& domain) {
-    std::string commonApiAddress = domain + ":" + serviceName + ":" + participantId;
-       auto foundStubAdapter = registeredServices_.find(commonApiAddress);
-       if(foundStubAdapter != registeredServices_.end()) {
-               std::shared_ptr<DBusStubAdapter> stubAdapter = foundStubAdapter->second;
-               stubAdapter->deinit();
-               return registeredServices_.erase(commonApiAddress);
-       }
-       return false;
+    std::string serviceAddress(domain + ":" + serviceName + ":" + participantId);
+    return DBusServicePublisher::getInstance()->unregisterService(serviceAddress);
 }