[Common] Added throw-free methods for dbus

Change-Id: Ia2714beac15eee5b49036f4321d3e806aba4cead
Signed-off-by: Piotr Kosko <p.kosko@samsung.com>

diff --git a/src/common/dbus_operation.cc b/src/common/dbus_operation.cc
index 2d56e58f812acc3f451e67ef0b18f1c9f3837373..610d007fba1b28cce9cd7e8f148c3f14a3f7a765 100644 (file)
--- a/src/common/dbus_operation.cc
+++ b/src/common/dbus_operation.cc
@@ -103,7 +103,7 @@ void DBusOperationArguments::AddArgumentString(const std::string& val) {
     arguments_.push_back(ArgumentElement(ArgType::kTypeString, p_val));
 }
 
-void DBusOperationArguments::AppendVariant(DBusMessageIter* bus_msg_iter) {
+PlatformResult DBusOperationArguments::AppendVariant(DBusMessageIter* bus_msg_iter) {
     for (auto iter = arguments_.begin(); iter != arguments_.end(); ++iter) {
         ArgType type = iter->first;
         void *p_val = iter->second;
@@ -130,9 +130,10 @@ void DBusOperationArguments::AppendVariant(DBusMessageIter* bus_msg_iter) {
             break;
 
         default:
-            throw UnknownException("Wrong debug parameter type");
+            return PlatformResult(ErrorCode::UNKNOWN_ERR, "Wrong debug parameter type");
         }
     }
+    return PlatformResult(ErrorCode::NO_ERROR);
 }
 
 DBusOperationListener::DBusOperationListener() {
@@ -234,14 +235,81 @@ int DBusOperation::InvokeSyncGetInt(const std::string& method,
     return result;
 }
 
-void DBusOperation::RegisterSignalListener(const std::string& signal_name,
+PlatformResult DBusOperation::InvokeSyncGetInt(const std::string& method,
+                                    DBusOperationArguments* args, int* result) {
+
+    if (!connection_) {
+        connection_ = dbus_bus_get_private(DBUS_BUS_SYSTEM, nullptr);
+    }
+
+    if (!connection_) {
+        LoggerE("dbus_bus_get_private error");
+        return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get dbus connection");
+    }
+
+    DBusMessage* msg = dbus_message_new_method_call(destination_.c_str(),
+                                                    path_.c_str(),
+                                                    interface_.c_str(),
+                                                    method.c_str());
+
+    if (!msg) {
+        LoggerE("dbus_message_new_method_call error");
+        return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to create dbus message");
+    }
+
+    DBusMessageIter iter;
+    dbus_message_iter_init_append(msg, &iter);
+
+    if (nullptr != args) {
+        PlatformResult ret = args->AppendVariant(&iter);
+        if (ret.IsError()) {
+            LoggerE("append_variant error");
+            dbus_message_unref(msg);
+            return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to append dbus variable");
+        }
+    }
+
+    DBusError err;
+    dbus_error_init(&err);
+    DBusMessage* reply = dbus_connection_send_with_reply_and_block(connection_,
+                                                                   msg,
+                                                                   DBUS_REPLY_TIMEOUT,
+                                                                   &err);
+    dbus_message_unref(msg);
+
+    if (!reply) {
+        LoggerE("dbus_connection_send_with_reply_and_block error %s: %s", err.name, err.message);
+        dbus_error_free(&err);
+        return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to send request via dbus");
+    }
+
+    *result = 0;
+    dbus_bool_t ret = dbus_message_get_args(reply,
+                                            &err,
+                                            DBUS_TYPE_INT32,
+                                            result,
+                                            DBUS_TYPE_INVALID);
+    dbus_message_unref(reply);
+
+    if (!ret) {
+        LoggerE("dbus_message_get_args error %s: %s", err.name, err.message);
+        dbus_error_free(&err);
+        return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get reply from dbus");
+    }
+
+    return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+PlatformResult DBusOperation::RegisterSignalListener(const std::string& signal_name,
                                            DBusOperationListener* listener) {
-    AddDBusSignalFilter();
+    PlatformResult ret = AddDBusSignalFilter();
+    if (ret.IsError()) return ret;
 
     listeners_.insert(std::make_pair(signal_name, listener));
+    return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-void DBusOperation::UnregisterSignalListener(const std::string& signal_name,
+PlatformResult DBusOperation::UnregisterSignalListener(const std::string& signal_name,
                                              DBusOperationListener* listener) {
     bool signal_found = false;
 
@@ -257,22 +325,23 @@ void DBusOperation::UnregisterSignalListener(const std::string& signal_name,
 
     if (false == signal_found) {
         LoggerE("Failed to find signal handler");
-        throw UnknownException("Failed to find signal handler");
+        return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to find signal handler");
     }
 
     if (listeners_.size() == 0) {
-        RemoveDBusSignalFilter();
+        return RemoveDBusSignalFilter();
     }
+    return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-void DBusOperation::AddDBusSignalFilter() {
+PlatformResult DBusOperation::AddDBusSignalFilter() {
     if (!connection_) {
         connection_ = dbus_bus_get_private(DBUS_BUS_SYSTEM, nullptr);
     }
 
     if (!connection_) {
         LoggerE("dbus_bus_get_private error");
-        throw UnknownException("Failed to get dbus connection");
+        return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get dbus connection");
     }
 
     dbus_connection_setup_with_g_main(connection_, nullptr);
@@ -292,16 +361,17 @@ void DBusOperation::AddDBusSignalFilter() {
     if (dbus_error_is_set(&err)) {
         LoggerE("dbus_bus_add_match error %s: %s", err.name, err.message);
         dbus_error_free(&err);
-        throw UnknownException("Failed to set rule for dbus signal");
+        return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to set rule for dbus signal");
     }
 
     if (dbus_connection_add_filter(connection_, DBusSignalFilterHandler, this, nullptr) == FALSE) {
         LoggerE("dbus_connection_add_filter error %s: %s", err.name, err.message);
-        throw UnknownException("Failed to set handler for dbus signal");
+        return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to set handler for dbus signal");
     }
+    return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-void DBusOperation::RemoveDBusSignalFilter() {
+PlatformResult DBusOperation::RemoveDBusSignalFilter() {
     DBusError err;
     dbus_error_init(&err);
     dbus_bus_remove_match(connection_, rule_.c_str(), &err);
@@ -309,10 +379,11 @@ void DBusOperation::RemoveDBusSignalFilter() {
     if (dbus_error_is_set(&err)) {
         LoggerE("dbus_bus_remove_match error %s: %s", err.name, err.message);
         dbus_error_free(&err);
-        throw UnknownException("Failed to remove rule for dbus signal");
+        return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to remove rule for dbus signal");
     }
 
     dbus_connection_remove_filter(connection_, DBusSignalFilterHandler, this);
+    return PlatformResult(ErrorCode::NO_ERROR);
 }
 
 DBusHandlerResult DBusOperation::DBusSignalFilter(DBusConnection* /* conn */,

diff --git a/src/common/dbus_operation.h b/src/common/dbus_operation.h
index f5755c22682a148523d368b9273ad016171cefb4..55f23e0533ebb36cc30a991fbf5900c4e0518f11 100644 (file)
--- a/src/common/dbus_operation.h
+++ b/src/common/dbus_operation.h
@@ -10,6 +10,7 @@
 #include <set>
 
 #include <dbus/dbus.h>
+#include "platform_result.h"
 
 namespace common {
 
@@ -42,7 +43,7 @@ class DBusOperationArguments {
 
   friend class DBusOperation;
 
-  void AppendVariant(DBusMessageIter* bus_msg_iter);
+  common::PlatformResult AppendVariant(DBusMessageIter* bus_msg_iter);
 };
 
 class DBusOperationListener {
@@ -62,10 +63,13 @@ class DBusOperation {
 
   int InvokeSyncGetInt(const std::string& method,
              DBusOperationArguments* args);
+  //TODO remove throwing methods when they would be not needed any more.
+  common::PlatformResult InvokeSyncGetInt(const std::string& method,
+             DBusOperationArguments* args, int* result);
 
-  void RegisterSignalListener(const std::string& signal_name,
+  common::PlatformResult RegisterSignalListener(const std::string& signal_name,
                 DBusOperationListener* listener);
-  void UnregisterSignalListener(const std::string& signal_name,
+  common::PlatformResult UnregisterSignalListener(const std::string& signal_name,
                   DBusOperationListener* listener);
 
  private:
@@ -80,8 +84,8 @@ class DBusOperation {
   DBusConnection* connection_;
   std::string rule_;
 
-  void AddDBusSignalFilter();
-  void RemoveDBusSignalFilter();
+  common::PlatformResult AddDBusSignalFilter();
+  common::PlatformResult RemoveDBusSignalFilter();
 
   DBusHandlerResult DBusSignalFilter(DBusConnection* conn,
                      DBusMessage* message);