Remove eldbus.hpp and refactor all it's uses

All previous uses of eldbus.hpp functionality has been rewritten
to use new DBus.hpp wrapper.

Change-Id: I9a8457f7ba131cb382bf8c2f107dba9fb7a5d13c

diff --git a/src/Atspi.cpp b/src/Atspi.cpp
index 465b4fa..0005fc3 100644 (file)
--- a/src/Atspi.cpp
+++ b/src/Atspi.cpp
@@ -170,7 +170,6 @@ ADD_INTROSPECTION_FUNCTIONS(Text, text, TEXT);
 #undef ADD_INTROSPECTION_FUNCTIONS
 
 Atspi::Atspi()
-       : eldbus(), connection(efl::eldbus::session)
 {
        ConnectAtClient();
 
@@ -304,45 +303,8 @@ bool Atspi::setPropertyBool(const char *bus,
                                                        const char *property,
                                                        Eina_Bool value)
 {
-       std::unique_ptr<Eldbus_Object, void (*)(Eldbus_Object *)> dobj{eldbus_object_get(connection.native_handle(), bus, path), eldbus_object_unref};
-       if (!dobj) {
-               ERROR("Failed to create eldbus object");
-               return false;
-       }
-       std::unique_ptr<Eldbus_Proxy, void (*)(Eldbus_Proxy *)> proxy{
-               eldbus_proxy_get(dobj.get(), dbusLocators::freeDesktop::PROPERTIES_INTERFACE), eldbus_proxy_unref};
-       if (!proxy) {
-               ERROR("Failed to create proxy object for '%s'", dbusLocators::freeDesktop::PROPERTIES_INTERFACE);
-               return false;
-       }
-       std::unique_ptr<Eldbus_Message, void (*)(Eldbus_Message *)> req{
-               eldbus_proxy_method_call_new(proxy.get(), dbusLocators::freeDesktop::SET), eldbus_message_unref};
-       if (!req) {
-               ERROR("Failed to create method call on %s.%s", dbusLocators::freeDesktop::PROPERTIES_INTERFACE, dbusLocators::freeDesktop::SET);
-               return false;
-       }
-       eldbus_message_ref(req.get());
-
-       if (!eldbus_message_arguments_append(req.get(), "ss", interface, property)) {
-               ERROR("Failed to append message args");
-               return false;
-       }
-       Eldbus_Message_Iter *iter = eldbus_message_iter_container_new(eldbus_message_iter_get(req.get()), 'v', "b");
-       if (!iter) {
-               ERROR("Unable to create variant iterator");
-               return false;
-       }
-       if (!eldbus_message_iter_arguments_append(iter, "b", value)) {
-               ERROR("Unable to append to variant iterator");
-               return false;
-       }
-       if (!eldbus_message_iter_container_close(eldbus_message_iter_get(req.get()), iter)) {
-               ERROR("Failed to close variant iterator");
-               return false;
-       }
-       eldbus_proxy_send(proxy.get(), req.get(), NULL, NULL, -1.0);
-
-       return true;
+       DBus::DBusClient dbus { bus, path, interface, DBus::ConnectionType::SESSION };
+       return bool(dbus.property<bool>(property).set(value));
 }
 
 Optional<std::string> Atspi::getName(const AtspiAccessiblePtr &accessibleObj) const

diff --git a/src/Atspi.hpp b/src/Atspi.hpp
index a06889c..3d8bbe8 100644 (file)
--- a/src/Atspi.hpp
+++ b/src/Atspi.hpp
@@ -18,7 +18,6 @@
 #define ATSPI_HPP
 
 #include "Optional.hpp"
-#include "eldbus.hpp"
 #include "DBus.hpp"
 #include "Geometry.hpp"
 
@@ -937,8 +936,6 @@ private:
 
        bool setPropertyBool(const char *bus, const char *path, const char *interface, const char *property, Eina_Bool value);
 
-       efl::eldbus::eldbus_init eldbus;
-       efl::eldbus::connection connection;
        DBus::EldbusConnectionCallbackHandle eldbusConnection;
        AtspiEventListener *eventListener;
        std::vector<WatchCallback> watchedCallbacks;

diff --git a/src/DBus.cpp b/src/DBus.cpp
index 7362651..886d7c9 100644 (file)
--- a/src/DBus.cpp
+++ b/src/DBus.cpp
@@ -416,6 +416,11 @@ static void addInterfaceImpl(bool fallback, const std::string &pathName,
        }
 }
 
+DBus::EldbusConnectionCallbackHandle DBus::DBusServer::getConnection()
+{
+       return connection;
+}
+
 void DBus::DBusServer::addInterface(const std::string &pathName, DBusInterfaceDescription &dscr, bool fallback)
 {
        addInterfaceImpl(fallback, pathName, connection, dscr.interfaceName, signalData, dscr.strings, dscr.methods, dscr.properties, dscr.signals, destructors);

diff --git a/src/DBus.hpp b/src/DBus.hpp
index ff09413..304f482 100644 (file)
--- a/src/DBus.hpp
+++ b/src/DBus.hpp
@@ -1022,7 +1022,7 @@ namespace DBus
                        */
                        static std::string name()
                        {
-                               return "";
+                               return "ValueOrError<void>";
                        }
                        /**
                        * @brief Returns DBUS' signature of type marshalled
@@ -1046,6 +1046,38 @@ namespace DBus
                        }
                };
                /**
+                * @brief Signature class for marshalling ValueOrError<> type
+                */
+               template <> struct signature<ValueOrError<>> {
+                       /**
+                       * @brief Returns name of type marshalled, for informative purposes
+                       */
+                       static std::string name()
+                       {
+                               return "ValueOrError<>";
+                       }
+                       /**
+                       * @brief Returns DBUS' signature of type marshalled
+                       */
+                       static std::string sig()
+                       {
+                               return "";
+                       }
+                       /**
+                       * @brief Marshals value v as marshalled type into message
+                       */
+                       static void set(Eldbus_Message_Iter *iter, const ValueOrError<> &args)
+                       {
+                       }
+                       /**
+                       * @brief Marshals value from marshalled type into variable v
+                       */
+                       static bool get(Eldbus_Message_Iter *iter, ValueOrError<> &args)
+                       {
+                               return true;
+                       }
+               };
+               /**
                 * @brief Signature class for marshalling pair of types
                 */
                template <typename A, typename B> struct signature<std::pair<A, B>> {
@@ -1733,6 +1765,16 @@ namespace DBus
                        {
                        }
                };
+               template <> struct EldbusArgGenerator_Helper<ValueOrError<void>, void> {
+                       static void add(std::vector<Eldbus_Arg_Info> &, StringStorage &)
+                       {
+                       }
+               };
+               template <> struct EldbusArgGenerator_Helper<ValueOrError<>, void> {
+                       static void add(std::vector<Eldbus_Arg_Info> &, StringStorage &)
+                       {
+                       }
+               };
                template <typename ... ARGS> struct EldbusArgGenerator_Helper<std::tuple<ARGS...>> {
                        static void add(std::vector<Eldbus_Arg_Info> &r, StringStorage &strings)
                        {
@@ -2120,6 +2162,7 @@ namespace DBus
                 */
                DBusInterfaceDescription(std::string interfaceName);
 
+
                /**
                 * @brief adds new, synchronous method to the interface
                 *
@@ -2353,6 +2396,13 @@ namespace DBus
                std::string getBusName() const;
 
                /**
+                * @brief Returns connection object for this dbus server object
+                *
+                * @return EldbusConnectionCallbackHandle connection object
+                */
+               EldbusConnectionCallbackHandle getConnection();
+
+               /**
                 * @brief Emits signal
                 *
                 * You must pass identifier of the signal, got as result of calling DBusInterfaceDescription::addSignal.

diff --git a/src/DBusInterface.cpp b/src/DBusInterface.cpp
index 9da7d09..34c8b9e 100644 (file)
--- a/src/DBusInterface.cpp
+++ b/src/DBusInterface.cpp
@@ -20,11 +20,11 @@
 #include "ActivityFactory.hpp"
 #include "UniversalSwitch.hpp"
 #include "localization.hpp"
-#include "eldbus.hpp"
 #include "CompositeSwitchProvider.hpp"
 #include "Switch.hpp"
 #include "ConditionAll.hpp"
 #include "Window.hpp"
+#include "DBus.hpp"
 
 #define BUS "org.tizen.UniversalSwitch"
 #define PATH "/org/tizen/UniversalSwitch"
@@ -33,11 +33,6 @@
 
 class DBusInterfaceImpl: public DBusInterface
 {
-public:
-       DBusInterfaceImpl(): eldbusInit(), connection(efl::eldbus::session), iface(connection, PATH, ifaceDescription)
-       {
-               eldbus_name_request(connection.native_handle(), BUS, ELDBUS_NAME_REQUEST_FLAG_DO_NOT_QUEUE, onNameRequest, iface.native_handle());
-       }
 
        static void onNameRequest(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED)
        {
@@ -61,70 +56,54 @@ public:
                }
        }
 
-       static Eldbus_Message *getAllSwitchConfigurationItems(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+       DBus::ValueOrError<std::vector<std::tuple<std::string, std::string, std::string, int32_t>>> getAllSwitchConfigurationItems(void)
        {
                DEBUG(IFACE ".getAllSwitchConfigurationItems called");
 
-               auto reply = eldbus_message_method_return_new(msg);
-               auto iter = eldbus_message_iter_get(reply);
-               Eldbus_Message_Iter *array;
-               eldbus_message_iter_arguments_append(iter, "a(sssi)", &array);
-
-               auto configuration = Singleton<UniversalSwitch>::instance().getConfiguration();
-               if (configuration) {
+               std::vector<std::tuple<std::string, std::string, std::string, int32_t>> result;
+               if (auto configuration = Singleton<UniversalSwitch>::instance().getConfiguration()) {
                        auto configurationItems = configuration->findAll();
 
                        for (auto &item : configurationItems) {
-                               Eldbus_Message_Iter *structure;
-                               DEBUG("configurationItem: id=%s userName=%s activityType=%s changeType=%d", item->getSwitchId().c_str(), item->getUserName().c_str(), item->getActivityType().c_str(), static_cast<int>(item->getChangeType()));
-                               eldbus_message_iter_arguments_append(array, "(sssi)", &structure);
-                               eldbus_message_iter_arguments_append(structure, "sssi", item->getSwitchId().c_str(), item->getUserName().c_str(), item->getActivityType().c_str(), static_cast<int>(item->getChangeType()));
-                               eldbus_message_iter_container_close(array, structure);
+                               result.push_back({ item->getSwitchId(), item->getUserName(), item->getActivityType(), static_cast<int>(item->getChangeType()) });
                        }
+                       return move(result);
                } else {
                        ERROR("configuration not defined");
+                       return DBus::Error{ "configuration not defined" };
                }
-
-               eldbus_message_iter_container_close(iter, array);
-               return reply;
        }
 
-
        template<class LocalizationClass>
-       static Eldbus_Message *sendStringsWithLocalizedNamesAndDescriptions(const Eldbus_Message *msg, const std::vector<std::string> &strings, bool descriptionAllowEmptyTranslation = false)
+       DBus::ValueOrError<std::vector<std::tuple<std::string, std::string, std::string>>>
+       sendStringsWithLocalizedNamesAndDescriptions(const std::vector<std::string> &strings, bool descriptionAllowEmptyTranslation = false)
        {
-               auto reply = eldbus_message_method_return_new(msg);
-
-               auto iter = eldbus_message_iter_get(reply);
-               Eldbus_Message_Iter *array;
-               eldbus_message_iter_arguments_append(iter, "a(sss)", &array);
-
+               std::vector<std::tuple<std::string, std::string, std::string>> result;
                for (auto &s : strings) {
-                       Eldbus_Message_Iter *structure;
-                       eldbus_message_iter_arguments_append(array, "(sss)", &structure);
-                       eldbus_message_iter_arguments_append(structure, "sss", s.c_str(), localization::get<LocalizationClass, localization::Name>(s).c_str(), localization::get<LocalizationClass, localization::Description>(s, descriptionAllowEmptyTranslation).c_str());
-                       eldbus_message_iter_container_close(array, structure);
+                       result.push_back({
+                               s,
+                               localization::get<LocalizationClass, localization::Name>(s),
+                               localization::get<LocalizationClass, localization::Description>(s, descriptionAllowEmptyTranslation)
+                       });
                }
-
-               eldbus_message_iter_container_close(iter, array);
-               return reply;
+               return result;
        }
 
-       static Eldbus_Message *getAllActivityTypes(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+       auto getAllActivityTypes(void)
        {
                DEBUG(IFACE ".getAllActivityTypes called");
                auto activityTypes = ActivityFactory::getInstance()->getAllActivityTypes();
-               return sendStringsWithLocalizedNamesAndDescriptions<Activity>(msg, activityTypes);
+               return sendStringsWithLocalizedNamesAndDescriptions<Activity>(activityTypes);
        }
 
-       static Eldbus_Message *getBindableActivityTypes(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+       auto getBindableActivityTypes(void)
        {
                DEBUG(IFACE ".getBindableActivityTypes called");
                auto activityTypes = ActivityFactory::getInstance()->getBindableActivityTypes();
-               return sendStringsWithLocalizedNamesAndDescriptions<Activity>(msg, activityTypes);
+               return sendStringsWithLocalizedNamesAndDescriptions<Activity>(activityTypes);
        }
 
-       static Eldbus_Message *getAllSwitchProviders(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+       auto getAllSwitchProviders(void)
        {
                DEBUG(IFACE ".getAllSwitchProviders called");
                std::vector<std::string> providerIds;
@@ -139,29 +118,18 @@ public:
                        ERROR("compositeSwitchProvider not defined");
                }
 
-               return sendStringsWithLocalizedNamesAndDescriptions<SwitchProvider>(msg, providerIds);
-       }
-
-       static std::string receivedString(const Eldbus_Message *msg)
-       {
-               const char *txt;
-               if (!eldbus_message_arguments_get(msg, "s", &txt)) {
-                       ERROR("Error on eldbus_message_arguments_get()");
-                       return std::string();
-               }
-               return txt;
+               return sendStringsWithLocalizedNamesAndDescriptions<SwitchProvider>(providerIds);
        }
 
-       static Eldbus_Message *getAllSwitchesByProviderId(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+       auto getAllSwitchesByProviderId(std::string providerId)
        {
                std::vector<std::string> switchesId;
                DEBUG(IFACE ".getAllSwitchesByProviderId called");
 
-               auto providerId = receivedString(msg);
                auto compositeSwitchProvider = Singleton<UniversalSwitch>::instance().getCompositeSwitchProvider();
                if (!compositeSwitchProvider) {
                        ERROR("compositeSwitchProvider not defined");
-                       return sendStringsWithLocalizedNamesAndDescriptions<Switch>(msg, switchesId);
+                       return sendStringsWithLocalizedNamesAndDescriptions<Switch>(switchesId);
                }
 
                auto provider = compositeSwitchProvider->getProviderById(providerId);
@@ -175,87 +143,68 @@ public:
                        ERROR("Provider with id: %s not found", providerId.c_str());
                }
 
-               return sendStringsWithLocalizedNamesAndDescriptions<Switch>(msg, switchesId, true);
+               return sendStringsWithLocalizedNamesAndDescriptions<Switch>(switchesId, true);
        }
 
-       static Eldbus_Message *addSwitchConfigurationItem(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+       DBus::ValueOrError<void> addSwitchConfigurationItem(std::string switchId, std::string userName, std::string activityType)
        {
                DEBUG(IFACE ".addSwitchConfigurationItem called");
-               auto reply = eldbus_message_method_return_new(msg);
-               const char *switchId, *activityType, *userName;
 
                auto configuration = Singleton<UniversalSwitch>::instance().getConfiguration();
                if (!configuration) {
                        ERROR("configuration not defined");
-                       return reply;
+                       return DBus::Error{ "configuration not defined" };
                }
 
-               if (eldbus_message_arguments_get(msg, "sss", &switchId, &userName, &activityType)) {
-                       DEBUG("adding SwitchConfigurationItem switchId: %s, userName: %s, activityType: %s", switchId, userName, activityType);
-                       auto configurationItem = std::make_shared<SwitchConfigurationItem>(switchId, activityType);
-                       configurationItem->setUserName(userName);
-                       configuration->add(configurationItem);
-               } else {
-                       ERROR("Error on eldbus_message_arguments_get()");
-               }
-               return reply;
+               DEBUG("adding SwitchConfigurationItem switchId: %s, userName: %s, activityType: %s", switchId.c_str(), userName.c_str(), activityType.c_str());
+               auto configurationItem = std::make_shared<SwitchConfigurationItem>(switchId, activityType);
+               configurationItem->setUserName(userName);
+               configuration->add(configurationItem);
+               return DBus::Success{};
        }
 
-       static Eldbus_Message *updateSwitchConfigurationItem(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+       DBus::ValueOrError<void> updateSwitchConfigurationItem(std::string switchId, std::string userName, std::string activityType)
        {
                DEBUG(IFACE ".addSwitchConfigurationItem called");
-               auto reply = eldbus_message_method_return_new(msg);
-               const char *switchId, *activityType, *userName;
 
                auto configuration = Singleton<UniversalSwitch>::instance().getConfiguration();
                if (!configuration) {
                        ERROR("configuration not defined");
-                       return reply;
+                       return DBus::Error{ "configuration not defined" };
                }
 
-               if (eldbus_message_arguments_get(msg, "sss", &switchId, &userName, &activityType)) {
-                       DEBUG("updating SwitchConfigurationItem switchId: %s, userName: %s, activityType: %s", switchId, userName, activityType);
-                       auto configurationItem = configuration->findBySwitchId(switchId);
-                       if (configurationItem) {
-                               configurationItem->setActivityType(activityType);
-                               configurationItem->setUserName(userName);
-                               configuration->update(configurationItem);
-                       } else {
-                               ERROR("configurationItem switchId: %s not found", switchId);
-                       }
+               DEBUG("updating SwitchConfigurationItem switchId: %s, userName: %s, activityType: %s", switchId.c_str(), userName.c_str(), activityType.c_str());
+               auto configurationItem = configuration->findBySwitchId(switchId);
+               if (configurationItem) {
+                       configurationItem->setActivityType(activityType);
+                       configurationItem->setUserName(userName);
+                       configuration->update(configurationItem);
+                       return DBus::Success{};
                } else {
-                       ERROR("Error on eldbus_message_arguments_get()");
+                       ERROR("configurationItem switchId: %s not found", switchId.c_str());
+                       return DBus::Error{ "configurationItem switchId: " + switchId + " not found" };
                }
-               return reply;
        }
 
-
-       static Eldbus_Message *removeSwitchConfigurationItem(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+       DBus::ValueOrError<void> removeSwitchConfigurationItem(std::string switchId)
        {
                DEBUG(IFACE ".addSwitchConfigurationItem called");
-               auto reply = eldbus_message_method_return_new(msg);
-               const char *switchId;
 
                auto configuration = Singleton<UniversalSwitch>::instance().getConfiguration();
                if (!configuration) {
                        ERROR("configuration not defined");
-                       return reply;
+                       return DBus::Error{ "configuration not defined" };
                }
 
-               if (eldbus_message_arguments_get(msg, "s", &switchId)) {
-                       DEBUG("removing SwitchConfigurationItem switchId: %s", switchId);
-                       configuration->remove(switchId);
-               } else {
-                       ERROR("Error on eldbus_message_arguments_get()");
-               }
-               return reply;
+               DEBUG("removing SwitchConfigurationItem switchId: %s", switchId.c_str());
+               configuration->remove(switchId);
+               return DBus::Success{};
        }
 
        class DBusSwitchObserver : public Observer<Switch>, public std::enable_shared_from_this<DBusSwitchObserver>
        {
        public:
-               DBusSwitchObserver(Eldbus_Message *reply, Eldbus_Connection *connection)
-                       : reply(reply), connection(connection) {};
+               DBusSwitchObserver(std::function<void(DBus::ValueOrError<std::string>)> doneCb) : doneCb(std::move(doneCb)) {}
 
                ~DBusSwitchObserver()
                {
@@ -277,22 +226,16 @@ public:
                                provider->detach(this, nullptr);
                                provider.reset();
                        }
-                       if (reply) {
-                               DEBUG("DBusSwitchObserver releasing reply message");
-                               eldbus_message_unref(reply);
-                               reply = NULL;
-                       }
+                       doneCb = {};
                }
 
                void replyMessage(const std::string &msg)
                {
-                       if (!reply)
-                               return;
-
-                       DEBUG("DBusSwitchObserver message reply: %s", msg.c_str());
-                       eldbus_message_arguments_append(reply, "s", msg.c_str());
-                       eldbus_connection_send(connection, reply, NULL, NULL, -1);
-                       reply = NULL;
+                       if (doneCb) {
+                               DEBUG("DBusSwitchObserver message reply: %s", msg.c_str());
+                               doneCb({ msg });
+                               doneCb = {};
+                       }
                }
 
                void update(const std::shared_ptr<Switch> &item) override
@@ -303,60 +246,79 @@ public:
                        detach();
                }
 
-               Eldbus_Message *reply;
-               Eldbus_Connection *connection;
+               std::function<void(DBus::ValueOrError<std::string>)> doneCb;
                std::shared_ptr<SwitchProvider> provider;
        };
 
-       static Eldbus_Message *captureSwitch(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+       void captureSwitch(std::function<void(DBus::ValueOrError<std::string>)> doneCb, std::string providerId)
        {
-               DEBUG(IFACE ".captureSwitch called");
-               auto reply = eldbus_message_method_return_new(msg);
-
                auto compositeSwitchProvider = Singleton<UniversalSwitch>::instance().getCompositeSwitchProvider();
                if (!compositeSwitchProvider) {
                        ERROR("compositeSwitchProvider not defined");
-                       return reply;
+                       doneCb(DBus::Error{ "compositeSwitchProvider not defined" });
+                       return;
                }
 
-               auto providerId = receivedString(msg);
                auto provider = compositeSwitchProvider->getProviderById(providerId);
                if (!provider) {
                        ERROR("Provider with id: %s not found", providerId.c_str());
-                       return reply;
-               }
-
-               auto dbusImpl = std::static_pointer_cast<DBusInterfaceImpl>(Singleton<UniversalSwitch>::instance().getDBusInterface());
-               if (!dbusImpl) {
-                       ERROR("DBusInterfaceImpl not found");
-                       return reply;
+                       doneCb(DBus::Error{ "Provider with id: " + providerId + " not found" });
+                       return;
                }
 
-               auto connection = eldbus_service_connection_get(iface);
-               dbusImpl->releaseSwitchObserver();
-
-               auto observer = std::make_shared<DBusSwitchObserver>(reply, connection);
+               releaseSwitchObserver();
+               auto observer = std::make_shared<DBusSwitchObserver>(std::move(doneCb));
                observer->attach(provider);
-               dbusImpl->switchObserver = observer;
-
-               //response to this request will be send asynchronous by
-               //DBusSwitchObserver when we obtain a switch, that is why we return NULL for now.
-               return NULL;
+               switchObserver = observer;
        }
 
-       static Eldbus_Message *cancelCaptureSwitch(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+       DBus::ValueOrError<void> cancelCaptureSwitch(void)
        {
                DEBUG(IFACE ".cancelCaptureSwitch called");
-               auto reply = eldbus_message_method_return_new(msg);
 
-               auto dbusImpl = std::static_pointer_cast<DBusInterfaceImpl>(Singleton<UniversalSwitch>::instance().getDBusInterface());
-               if (!dbusImpl) {
-                       ERROR("DBusInterfaceImpl not found");
-               } else {
-                       dbusImpl->releaseSwitchObserver();
-               }
+               releaseSwitchObserver();
+               return DBus::Success{};
+       }
+public:
+       DBusInterfaceImpl() : dbusServer(DBus::ConnectionType::SESSION)
+       {
+               DBus::DBusInterfaceDescription desc{ IFACE };
+               add(desc, "getAllSwitchConfigurationItems", &DBusInterfaceImpl::getAllSwitchConfigurationItems);
+               add(desc, "captureSwitch", &DBusInterfaceImpl::captureSwitch);
+               add(desc, "cancelCaptureSwitch", &DBusInterfaceImpl::cancelCaptureSwitch);
+               add(desc, "getAllActivityTypes", &DBusInterfaceImpl::getAllActivityTypes);
+               add(desc, "getBindableActivityTypes", &DBusInterfaceImpl::getBindableActivityTypes);
+               add(desc, "getAllSwitchProviders", &DBusInterfaceImpl::getAllSwitchProviders);
+               add(desc, "getAllSwitchesByProviderId", &DBusInterfaceImpl::getAllSwitchesByProviderId);
+               add(desc, "addSwitchConfigurationItem", &DBusInterfaceImpl::addSwitchConfigurationItem);
+               add(desc, "updateSwitchConfigurationItem", &DBusInterfaceImpl::updateSwitchConfigurationItem);
+               add(desc, "removeSwitchConfigurationItem", &DBusInterfaceImpl::removeSwitchConfigurationItem);
+               dbusServer.addInterface(PATH, desc);
+
+               eldbus_name_request(dbusServer.getConnection().get(), BUS, ELDBUS_NAME_REQUEST_FLAG_DO_NOT_QUEUE, onNameRequest, nullptr);
+       }
+private:
+       DBus::DBusServer dbusServer;
+       std::shared_ptr<DBusSwitchObserver> switchObserver;
+
+       template <typename ... RET, typename ... ARGS> void add(DBus::DBusInterfaceDescription &desc, const std::string &funcName,
+                       DBus::ValueOrError<RET...>(DBusInterfaceImpl::*funcPtr)(ARGS...))
+       {
+               desc.addMethod<DBus::ValueOrError<RET...>(ARGS...)>(funcName,
+               [ = ](ARGS ... args) -> DBus::ValueOrError<RET...> {
+                       return (this->*funcPtr)(std::move(args)...);
+               });
+       }
 
-               return reply;
+       template <typename ... RET, typename ... ARGS> void add(DBus::DBusInterfaceDescription &desc, const std::string &funcName,
+                       void (DBusInterfaceImpl::*funcPtr)(std::function<void(DBus::ValueOrError<RET...>)> callback, ARGS...))
+       {
+               DEBUG("%s", DBus::detail::signature<DBus::ValueOrError<RET...>>::name().c_str());
+               DEBUG("%s", DBus::detail::signature<DBus::ValueOrError<ARGS...>>::name().c_str());
+               desc.addAsyncMethod<DBus::ValueOrError<RET...>(ARGS...)>(funcName,
+               [ = ](std::function<void(DBus::ValueOrError<RET...>)> callback, ARGS ... args) {
+                       (this->*funcPtr)(std::move(callback), std::move(args)...);
+               });
        }
 
        void releaseSwitchObserver()
@@ -366,68 +328,8 @@ public:
                        switchObserver.reset();
                }
        }
-
-private:
-       static const Eldbus_Method methods[];
-       static const Eldbus_Service_Interface_Desc ifaceDescription;
-
-       std::shared_ptr<DBusSwitchObserver> switchObserver;
-
-       efl::eldbus::eldbus_init eldbusInit;
-       efl::eldbus::connection connection;
-       efl::eldbus::service_interface iface;
-
-};
-
-const Eldbus_Method DBusInterfaceImpl::methods[] = {
-       {
-               "getAllSwitchConfigurationItems", NULL, ELDBUS_ARGS({"a(sssi)", "array_configuration_item"}),
-               getAllSwitchConfigurationItems, 0
-       },
-       {
-               "captureSwitch", ELDBUS_ARGS({"s", "providerId"}), ELDBUS_ARGS({"s", "switchId"}),
-               captureSwitch, 0
-       },
-       {
-               "cancelCaptureSwitch", NULL, NULL,
-               cancelCaptureSwitch, 0
-       },
-       {
-               "getAllActivityTypes", NULL, ELDBUS_ARGS({"a(sss)", "array_activityTypes"}),
-               getAllActivityTypes, 0
-       },
-       {
-               "getBindableActivityTypes", NULL, ELDBUS_ARGS({"a(sss)", "array_activityTypes"}),
-               getBindableActivityTypes, 0
-       },
-       {
-               "getAllSwitchProviders", NULL, ELDBUS_ARGS({"a(sss)", "array_providers"}),
-               getAllSwitchProviders, 0
-       },
-       {
-               "getAllSwitchesByProviderId", ELDBUS_ARGS({"s", "providerId"}), ELDBUS_ARGS({"a(sss)", "array_switches"}),
-               getAllSwitchesByProviderId, 0
-       },
-       {
-               "addSwitchConfigurationItem", ELDBUS_ARGS({"sss", "switchConfigurationItem"}), NULL,
-               addSwitchConfigurationItem, 0
-       },
-       {
-               "updateSwitchConfigurationItem", ELDBUS_ARGS({"sss", "switchConfigurationItem"}), NULL,
-               updateSwitchConfigurationItem, 0
-       },
-       {
-               "removeSwitchConfigurationItem", ELDBUS_ARGS({"s", "switchId"}), NULL,
-               removeSwitchConfigurationItem, 0
-       },
-       { }
-};
-
-const Eldbus_Service_Interface_Desc DBusInterfaceImpl::ifaceDescription = {
-       IFACE, methods, nullptr, nullptr, nullptr, nullptr
 };
 
-
 std::shared_ptr<DBusInterface> DBusInterface::create()
 {
        return std::make_shared<DBusInterfaceImpl>();

diff --git a/src/eldbus.hpp b/src/eldbus.hpp
deleted file mode 100644 (file)
index 7687df7..0000000
--- a/src/eldbus.hpp
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright 2017  Samsung Electronics Co., Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
-
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ELDBUS_HPP
-#define ELDBUS_HPP
-
-//based on efl c++ bindings efl/src/bindings/eldbus_cxx/eldbus_basic.hh
-
-#include <Eldbus.h>
-#include "UniversalSwitchLog.hpp"
-
-namespace efl
-{
-       namespace eldbus
-       {
-
-               struct unknown_t {};
-               struct session_t {};
-               struct system_t {};
-               struct start_t {};
-               struct address_t {};
-
-               unknown_t const unknown = unknown_t();
-               session_t const session = session_t();
-               system_t const system = system_t();
-               start_t const start = start_t();
-               address_t const address = address_t();
-
-               struct eldbus_init {
-                       eldbus_init()
-                       {
-                               ::eldbus_init();
-                       }
-                       ~eldbus_init()
-                       {
-                               ::eldbus_shutdown();
-                       }
-               };
-
-               struct connection {
-                       typedef Eldbus_Connection *native_handle_type;
-                       typedef Eldbus_Connection const *const_native_handle_type;
-
-                       explicit connection(native_handle_type connection_)
-                               : _connection(connection_) {}
-                       ~connection()
-                       {
-                               eldbus_connection_unref(_connection);
-                       }
-                       connection(unknown_t)
-                               : _connection(eldbus_connection_get(ELDBUS_CONNECTION_TYPE_UNKNOWN))
-                       {
-                               _check_connection();
-                       }
-                       connection(session_t)
-                               : _connection(eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION))
-                       {
-                               _check_connection();
-                       }
-                       connection(system_t)
-                               : _connection(eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM))
-                       {
-                               _check_connection();
-                       }
-                       connection(address_t)
-                               : _connection(eldbus_connection_get(ELDBUS_CONNECTION_TYPE_ADDRESS))
-                       {
-                               _check_connection();
-                       }
-
-                       native_handle_type native_handle()
-                       {
-                               return _connection;
-                       }
-                       const_native_handle_type native_handle() const
-                       {
-                               return _connection;
-                       }
-               private:
-                       void _check_connection()
-                       {
-                               if (!_connection) {
-                                       ASSERT(_connection, "eldbus connection error");
-                               }
-                       }
-
-                       native_handle_type _connection;
-               };
-
-               struct service_interface {
-                       service_interface(connection &connection, const std::string &path, const Eldbus_Service_Interface_Desc &iface_desc):
-                               _iface(eldbus_service_interface_register(connection.native_handle(), path.c_str(), &iface_desc)) {}
-
-                       ~service_interface()
-                       {
-                               eldbus_service_interface_unregister(_iface);
-                       }
-
-
-                       typedef Eldbus_Service_Interface *native_handle_type;
-                       native_handle_type native_handle()
-                       {
-                               return _iface;
-                       }
-                       native_handle_type native_handle() const
-                       {
-                               return _iface;
-                       }
-               private:
-                       native_handle_type _iface;
-               };
-
-
-       }
-}
-
-#endif