gconnman_agent: Register object in worker thread

Call the register object in the dbus in the worker thread.
The latter makes the callback to be executed also in the worker thread.
The creation of the agent block the thread until the worker thread
register the object.
This solves #21.

Signed-off-by: Eduardo Gonzalez <eduardo.gonzalez@amarulasolutions.com>

Author: EddyTheCo

include/amarula/dbus/connman/gagent.hpp

@@ -2,6 +2,7 @@
 #include <gio/gio.h>
 #include <glib.h>
 
+#include <amarula/dbus/gdbus.hpp>
 #include <functional>
 #include <string>
 #include <utility>
@@ -15,8 +16,7 @@ class Agent {
     GDBusConnection *connection_{nullptr};
     std::string path_{"/net/amarula/gconnman/agent"};
 
-    explicit Agent(GDBusConnection *connection,
-                   const std::string &path = std::string());
+    explicit Agent(DBus *dbus, const std::string &path = std::string());
 
     using RequestInputCallback =
         std::function<GVariant *(const gchar *service, GVariant *fields)>;

src/dbus/gconnman_agent.cpp

@@ -4,6 +4,7 @@
 
 #include <amarula/dbus/connman/gagent.hpp>
 #include <amarula/log.hpp>
+#include <condition_variable>
 #include <iostream>
 #include <stdexcept>
 #include <string>
@@ -28,8 +29,8 @@ static constexpr const char *INTROSPECTION_XML =
     "  </interface>"
     "</node>";
 
-Agent::Agent(GDBusConnection *connection, const std::string &path)
-    : connection_{connection} {
+Agent::Agent(DBus *dbus, const std::string &path)
+    : connection_{dbus->connection()} {
     if (!path.empty()) {
         path_ = path;
     }
@@ -42,16 +43,54 @@ Agent::Agent(GDBusConnection *connection, const std::string &path)
         throw std::runtime_error(msg);
     }
 
-    registration_id_ = g_dbus_connection_register_object(
-        connection, path_.c_str(), *(node_info_->interfaces), &INTERFACE_VTABLE,
-        this, nullptr, &err);
+    struct Data {
+        Agent *self;
+        std::mutex mtx;
+        std::condition_variable cv;
+        bool done{false};
+        std::string error;
+    };
+
+    auto data = Data{this};
+
+    g_main_context_invoke_full(
+        dbus->context(), G_PRIORITY_HIGH,
+        [](gpointer user_data) -> gboolean {
+            auto *data = static_cast<Data *>(user_data);
+
+            GError *err = nullptr;
+
+            data->self->registration_id_ = g_dbus_connection_register_object(
+                data->self->connection_, data->self->path_.c_str(),
+                *(data->self->node_info_->interfaces), &INTERFACE_VTABLE,
+                data->self, nullptr, &err);
+
+            if (data->self->registration_id_ == 0) {
+                data->error =
+                    "Failed to register agent: " + std::string(err->message);
+                g_error_free(err);
+            }
+
+            return G_SOURCE_REMOVE;
+        },
+        &data,
+        [](gpointer user_data) {
+            auto *data = static_cast<Data *>(user_data);
+            {
+                std::lock_guard<std::mutex> const lock(data->mtx);
+                data->done = true;
+            }
+            data->cv.notify_all();
+        });
+
+    {
+        std::unique_lock<std::mutex> lock(data.mtx);
+        data.cv.wait(lock, [&] { return data.done; });
+    }
 
-    if (registration_id_ == 0) {
-        std::string const msg =
-            "Failed to register agent: " + std::string(err->message);
-        g_error_free(err);
+    if (!data.error.empty()) {
         g_dbus_node_info_unref(node_info_);
-        throw std::runtime_error(msg);
+        throw std::runtime_error(data.error);
     }
 }
 Agent::~Agent() {

src/dbus/gconnman_manager.cpp

@@ -43,8 +43,7 @@ void ManaProperties::update(const gchar* key, GVariant* value) {
 
 Manager::Manager(DBus* dbus, const std::string& agent_path)
     : DBusProxy(dbus, SERVICE, MANAGER_PATH, MANAGER_INTERFACE),
-      agent_{
-          std::unique_ptr<Agent>(new Agent(dbus->connection(), agent_path))} {
+      agent_{std::unique_ptr<Agent>(new Agent(dbus, agent_path))} {
     setup_agent();
     get_technologies();
     get_services();