Use gdbus instead of dbus-glib

Change-Id: I6d626e538986d6fcd3339f8a2690c9e84e379a7c
Signed-off-by: Hwankyu Jhun <h.jhun@samsung.com>

7 files changed, 173 insertions, 326 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index be7811c..f9df14f 100755
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -35,9 +35,9 @@ pkg_check_modules(pkgs REQUIRED
 	elementary
 	evas
 	ecore-evas
-	dbus-1
-	dbus-glib-1
 	bundle
+	glib-2.0
+	gio-2.0
 )
 
 FOREACH(flag ${pkgs_CFLAGS})
diff --git a/include/minicontrol-internal.h b/include/minicontrol-internal.h
index a958958..0ed1546 100755
--- a/include/minicontrol-internal.h
+++ b/include/minicontrol-internal.h
@@ -17,10 +17,11 @@
 #ifndef _MINICTRL_INTERNAL_H_
 #define _MINICTRL_INTERNAL_H_
 
-#include <dbus/dbus.h>
 #include <sys/types.h>
 #include <unistd.h>
+#include <glib.h>
 #include <bundle.h>
+
 #include "minicontrol-type.h"
 
 #ifndef EXPORT_API
@@ -28,7 +29,6 @@
 #endif /* EXPORT_API */
 
 #define MINICTRL_DBUS_SIG_RUNNING_REQ "minicontrol_running_request"
-
 #define MINICTRL_DBUS_SIG_TO_PROVIDER "minicontrol_signal_to_provider"
 #define MINICTRL_DBUS_SIG_TO_VIEWER   "minicontrol_signal_to_viewer"
 
@@ -83,20 +83,21 @@ typedef enum {
 
 typedef struct _minictrl_sig_handle minictrl_sig_handle;
 
-int _minictrl_provider_message_send(int event, const char *minicontrol_name, unsigned int witdh, unsigned int height, minicontrol_priority_e priority);
+int _minictrl_provider_message_send(int event, const char *minicontrol_name,
+		unsigned int witdh, unsigned int height,
+		minicontrol_priority_e priority);
 
 int _minictrl_viewer_req_message_send(void);
 
 minictrl_sig_handle *_minictrl_dbus_sig_handle_attach(const char *signal,
-				void (*callback)(void *data, DBusMessage *msg),
-				void *data);
+		void (*callback)(void *data, GVariant *parameters), void *data);
 
 void _minictrl_dbus_sig_handle_dettach(minictrl_sig_handle *handle);
 
 int _minictrl_provider_proc_send(int type);
 
-/* new */
-int _minictrl_send_event(const char *signal_name, const char *minicontrol_name, int event, bundle *signal_arg);
+int _minictrl_send_event(const char *signal_name, const char *minicontrol_name,
+		int event, bundle *signal_arg);
 
 #endif /* _MINICTRL_INTERNAL_H_ */
 
diff --git a/packaging/minicontrol.spec b/packaging/minicontrol.spec
index 100e2fb..12ccad3 100644
--- a/packaging/minicontrol.spec
+++ b/packaging/minicontrol.spec
@@ -5,8 +5,8 @@ Release:    1
 Group:      Application Framework/Other
 License:    Apache-2.0
 Source0:    %{name}-%{version}.tar.gz
-BuildRequires: pkgconfig(dbus-1)
-BuildRequires: pkgconfig(dbus-glib-1)
+BuildRequires: pkgconfig(glib-2.0)
+BuildRequires: pkgconfig(gio-2.0)
 BuildRequires: pkgconfig(elementary)
 BuildRequires: pkgconfig(evas)
 BuildRequires: pkgconfig(ecore-evas)
diff --git a/src/minicontrol-internal.c b/src/minicontrol-internal.c
index 196df03..9568933 100755
--- a/src/minicontrol-internal.c
+++ b/src/minicontrol-internal.c
@@ -15,8 +15,8 @@
  */
 
 #include <stdlib.h>
-#include <dbus/dbus.h>
-#include <dbus/dbus-glib-lowlevel.h>
+#include <glib.h>
+#include <gio/gio.h>
 #include <bundle.h>
 
 #include "minicontrol-error.h"
@@ -34,362 +34,234 @@
 #define PROC_DBUS_INCLUDE	"include"
 
 struct _minictrl_sig_handle {
-	DBusConnection *conn;
-	void (*callback) (void *data, DBusMessage *msg);
+	GDBusConnection *conn;
+	guint s_id;
+	void (*callback)(void *data, GVariant *parameters);
 	void *user_data;
 	char *signal;
 };
 
-int _minictrl_viewer_req_message_send(void)
+static int __send_signal(const char *object_path, const char *interface_name,
+		const char *signal_name, GVariant *parameters)
 {
-	DBusConnection *connection = NULL;
-	DBusMessage *message = NULL;
-	DBusError err;
-	dbus_bool_t dbus_ret;
-	int ret = MINICONTROL_ERROR_NONE;
-
-	dbus_error_init(&err);
-	connection = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
-	if (!connection) {
-		ERR("Fail to dbus_bus_get : %s", err.message);
-		ret = MINICONTROL_ERROR_IPC_FAILURE;
-		goto release_n_return;
-	}
-
-	message = dbus_message_new_signal(MINICTRL_DBUS_PATH,
-				MINICTRL_DBUS_INTERFACE,
-				MINICTRL_DBUS_SIG_RUNNING_REQ);
-	if (!message) {
-		ERR("fail to create dbus message");
-		ret = MINICONTROL_ERROR_OUT_OF_MEMORY;
-		goto release_n_return;
+	GError *err = NULL;
+	GDBusConnection *conn;
+	gboolean ret;
+
+	conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+	if (conn == NULL) {
+		ERR("g_bus_get_sync() failed. %s", err->message);
+		g_error_free(err);
+		return MINICONTROL_ERROR_IPC_FAILURE;
 	}
 
-	dbus_ret = dbus_connection_send(connection, message, NULL);
-	if (!dbus_ret) {
-		ERR("fail to send dbus viewer req message");
-		ret = MINICONTROL_ERROR_IPC_FAILURE;
-		goto release_n_return;
+	ret = g_dbus_connection_emit_signal(conn, NULL, object_path,
+			interface_name, signal_name, parameters, &err);
+	if (!ret) {
+		ERR("g_dbus_connection_emit_signal() failed. %s", err->message);
+		g_error_free(err);
+		g_object_unref(conn);
+		return MINICONTROL_ERROR_IPC_FAILURE;
 	}
 
-	dbus_connection_flush(connection);
+	g_dbus_connection_flush_sync(conn, NULL, &err);
+	g_object_unref(conn);
+	g_clear_error(&err);
 
-release_n_return:
-	dbus_error_free(&err);
+	return MINICONTROL_ERROR_NONE;
+}
 
-	if (message)
-		dbus_message_unref(message);
+int _minictrl_viewer_req_message_send(void)
+{
+	int ret;
 
-	if (connection)
-		dbus_connection_unref(connection);
+	ret = __send_signal(MINICTRL_DBUS_PATH, MINICTRL_DBUS_INTERFACE,
+			MINICTRL_DBUS_SIG_RUNNING_REQ, NULL);
 
 	return ret;
 }
 
 int _minictrl_provider_proc_send(int type)
 {
-	DBusError err;
-	DBusConnection *conn = NULL;
-	DBusMessage *msg = NULL;
-	int ret = -1;
+	int ret;
+	GVariant *param;
+	const char *type_str;
 	int pid = getpid();
-	dbus_uint32_t serial = 0;
-	char *typestr;
-	if (type == MINICONTROL_DBUS_PROC_EXCLUDE)
-		typestr = PROC_DBUS_EXCLUDE;
-	else if  (type == MINICONTROL_DBUS_PROC_INCLUDE)
-		typestr = PROC_DBUS_INCLUDE;
-	else {
+
+	switch (type) {
+	case MINICONTROL_DBUS_PROC_EXCLUDE:
+		type_str = PROC_DBUS_EXCLUDE;
+		break;
+	case MINICONTROL_DBUS_PROC_INCLUDE:
+		type_str = PROC_DBUS_INCLUDE;
+		break;
+	default:
 		ERR("Check unsupported type : %d", type);
-		return ret;
+		return -1;
 	}
-	DBG("_minictrl_provider_proc_send : %d, %d", pid, type);
-	dbus_error_init(&err);
-	conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
-	if (!conn) {
-		ERR("Fail to dbus_bus_get : %s", err.message);
-		ret = MINICONTROL_ERROR_IPC_FAILURE;
-		goto release_n_return;
-	}
-	msg = dbus_message_new_signal(PROC_DBUS_OBJECT, /* object name of the signal */
-			    PROC_DBUS_INTERFACE, /* interface name of the signal */
-			    PROC_DBUS_METHOD); /* name of the signal */
-	if (!msg) {
-		ERR("ERR Could not create DBus Message");
-		goto release_n_return;
+
+	DBG("pid: %d, type: %d(%s)", pid, type, type_str);
+
+	param = g_variant_new("(si)", type_str, pid);
+	if (param == NULL) {
+		ERR("out of memory");
+		return MINICONTROL_ERROR_OUT_OF_MEMORY;
 	}
-	ret = dbus_message_append_args(msg,
-			    DBUS_TYPE_STRING, &typestr,
-			    DBUS_TYPE_INT32, &pid,
-			    DBUS_TYPE_INVALID);
-	if (!dbus_connection_send(conn, msg, &serial))
-		ERR("ERR send DBus Message");
-	dbus_connection_flush(conn);
-release_n_return:
-	dbus_error_free(&err);
-
-	if (msg)
-		dbus_message_unref(msg);
-
-	if (conn)
-		dbus_connection_unref(conn);
+
+	ret = __send_signal(PROC_DBUS_OBJECT, PROC_DBUS_INTERFACE,
+			PROC_DBUS_METHOD, param);
 
 	return ret;
 }
 
-int _minictrl_send_event(const char *signal_name, const char *minicontrol_name, int event, bundle *signal_arg)
+int _minictrl_send_event(const char *signal_name, const char *minicontrol_name,
+		int event, bundle *signal_arg)
 {
-	DBusConnection *connection = NULL;
-	DBusMessage *message = NULL;
-	DBusError err;
-	dbus_bool_t dbus_ret;
+	int ret;
 	bundle_raw *serialized_arg = NULL;
 	unsigned int serialized_arg_length = 0;
-	int ret = MINICONTROL_ERROR_NONE;
+	GVariant *param;
 
-	if (minicontrol_name == NULL) {
+	if (minicontrol_name == NULL || signal_name == NULL) {
 		ERR("Invaild parameter");
 		return MINICONTROL_ERROR_INVALID_PARAMETER;
 	}
 
-	dbus_error_init(&err);
-	connection = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
-	if (!connection) {
-		ERR("Fail to dbus_bus_get : %s", err.message);
-		ret = MINICONTROL_ERROR_IPC_FAILURE;
-		goto release_n_return;
-	}
-
-	message = dbus_message_new_signal(MINICTRL_DBUS_PATH, MINICTRL_DBUS_INTERFACE, signal_name);
-
-	if (!message) {
-		ERR("fail to create dbus message");
-		ret = MINICONTROL_ERROR_OUT_OF_MEMORY;
-		goto release_n_return;
-	}
-
-	if (signal_arg != NULL) {
-		if (bundle_encode(signal_arg, &serialized_arg, (int *)&serialized_arg_length) != BUNDLE_ERROR_NONE) {
-			ERR("fail to serialize bundle argument");
-			ret = MINICONTROL_ERROR_OUT_OF_MEMORY;
-			goto release_n_return;
+	if (signal_arg) {
+		ret = bundle_encode(signal_arg, &serialized_arg,
+				(int *)&serialized_arg_length);
+		if (ret != BUNDLE_ERROR_NONE) {
+			ERR("Failed to serialize bundle argument");
+			return MINICONTROL_ERROR_OUT_OF_MEMORY;
 		}
 	} else {
 		serialized_arg = (bundle_raw *)strdup("");
+		if (serialized_arg == NULL) {
+			ERR("out of memory");
+			return MINICONTROL_ERROR_OUT_OF_MEMORY;
+		}
 		serialized_arg_length = 0;
 	}
 
-	dbus_ret = dbus_message_append_args(message,
-			DBUS_TYPE_STRING, &minicontrol_name,
-			DBUS_TYPE_INT32,  &event,
-			DBUS_TYPE_STRING, &serialized_arg,
-			DBUS_TYPE_UINT32,  &serialized_arg_length,
-			DBUS_TYPE_INVALID);
-
-	if (!dbus_ret) {
-		ERR("fail to append arguments to dbus message : [%s][%d]", minicontrol_name, event);
-		ret = MINICONTROL_ERROR_OUT_OF_MEMORY;
-		goto release_n_return;
-	}
-
-	dbus_ret = dbus_connection_send(connection, message, NULL);
-
-	if (!dbus_ret) {
-		ERR("fail to send dbus message : %s", minicontrol_name);
-		ret = MINICONTROL_ERROR_IPC_FAILURE;
-		goto release_n_return;
-	}
-
-	dbus_connection_flush(connection);
-
-release_n_return:
-	dbus_error_free(&err);
-
-	if (serialized_arg)
+	param = g_variant_new("(sisu)", minicontrol_name, event,
+			serialized_arg, serialized_arg_length);
+	if (param == NULL) {
+		ERR("out of memory");
 		free(serialized_arg);
+		return MINICONTROL_ERROR_OUT_OF_MEMORY;
+	}
 
-	if (message)
-		dbus_message_unref(message);
+	ret = __send_signal(MINICTRL_DBUS_PATH, MINICTRL_DBUS_INTERFACE,
+			signal_name, param);
 
-	if (connection)
-		dbus_connection_unref(connection);
+	free(serialized_arg);
 
 	return ret;
 }
 
-
-int _minictrl_provider_message_send(int event, const char *minicontrol_name, unsigned int witdh, unsigned int height, minicontrol_priority_e priority)
+int _minictrl_provider_message_send(int event, const char *minicontrol_name,
+		unsigned int witdh, unsigned int height,
+		minicontrol_priority_e priority)
 {
-	bundle *event_arg_bundle = NULL;
-	int ret = MINICONTROL_ERROR_NONE;
-	char bundle_value_buffer[BUNDLE_BUFFER_LENGTH] = { 0, };
+	int ret;
+	bundle *event_arg_bundle;
+	char bundle_value_buffer[BUNDLE_BUFFER_LENGTH];
 
 	event_arg_bundle = bundle_create();
-
 	if (event_arg_bundle == NULL) {
-		ERR("fail to create a bundle instance");
-		ret = MINICONTROL_ERROR_OUT_OF_MEMORY;
-		goto out;
+		ERR("Fail to create a bundle instance");
+		return MINICONTROL_ERROR_OUT_OF_MEMORY;
 	}
 
-	snprintf(bundle_value_buffer, BUNDLE_BUFFER_LENGTH, "%s", minicontrol_name);
+	snprintf(bundle_value_buffer, sizeof(bundle_value_buffer),
+			"%s", minicontrol_name);
 
-	bundle_add_str(event_arg_bundle, "minicontrol_name", bundle_value_buffer);
+	bundle_add_str(event_arg_bundle, "minicontrol_name",
+			bundle_value_buffer);
 	bundle_add_byte(event_arg_bundle, "width", (void *)&witdh, sizeof(int));
-	bundle_add_byte(event_arg_bundle, "height", (void *)&height, sizeof(int));
-	bundle_add_byte(event_arg_bundle, "priority", (void *)&priority, sizeof(int));
+	bundle_add_byte(event_arg_bundle, "height", (void *)&height,
+			sizeof(int));
+	bundle_add_byte(event_arg_bundle, "priority", (void *)&priority,
+			sizeof(int));
 
-	_minictrl_send_event(MINICTRL_DBUS_SIG_TO_VIEWER, minicontrol_name, event, event_arg_bundle);
-
-out:
-	if (event_arg_bundle)
-		bundle_free(event_arg_bundle);
+	ret = _minictrl_send_event(MINICTRL_DBUS_SIG_TO_VIEWER,
+			minicontrol_name, event, event_arg_bundle);
 
 	return ret;
 }
 
-static DBusHandlerResult _minictrl_signal_filter(DBusConnection *conn, DBusMessage *msg, void *user_data)
+static void __minictrl_signal_filter(GDBusConnection *connection,
+		const gchar *sender_name, const gchar *object_path,
+		const gchar *interface_name, const gchar *signal_name,
+		GVariant *parameters, gpointer user_data)
 {
-	minictrl_sig_handle *handle = NULL;
-	const char *interface;
-	DBusError error;
-	dbus_bool_t ret;
-
-	if (!user_data)
-		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-
-	handle = user_data;
+	minictrl_sig_handle *handle = (minictrl_sig_handle *)user_data;
 
-	dbus_error_init(&error);
-
-	interface = dbus_message_get_interface(msg);
-	if (!interface)
-		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-
-	if (strcmp(MINICTRL_DBUS_INTERFACE, interface))
-		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+	if (handle == NULL)
+		return;
 
-	ret = dbus_message_is_signal(msg, interface, handle->signal);
-	if (!ret) {
-		DBG("this msg is not signal");
-		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+	if (g_strcmp0(signal_name, handle->signal) == 0) {
+		if (handle->callback)
+			handle->callback(handle->user_data, parameters);
 	}
-
-	if (handle->callback)
-		handle->callback(handle->user_data, msg);
-
-	return DBUS_HANDLER_RESULT_HANDLED;
 }
 
-
 minictrl_sig_handle *_minictrl_dbus_sig_handle_attach(const char *signal,
-				void (*callback) (void *data, DBusMessage *msg),
-				void *data)
+		void (*callback)(void *data, GVariant *parameters), void *data)
 {
-	minictrl_sig_handle *handle = NULL;
-	DBusError err;
-	DBusConnection *conn = NULL;
-	char rule[1024] = {'\0', };
+	GError *err = NULL;
+	minictrl_sig_handle *handle;
 
-	if (!signal) {
-		ERR("signal is NULL");
+	if (signal == NULL || callback == NULL) {
+		ERR("Invalid prameter");
 		return NULL;
 	}
 
-	if (!callback) {
-		ERR("call is NULL");
+	handle = (minictrl_sig_handle *)malloc(sizeof(minictrl_sig_handle));
+	if (handle == NULL) {
+		ERR("out of memory");
 		return NULL;
 	}
 
-	handle = malloc(sizeof(minictrl_sig_handle));
-	if (!handle) {
-		ERR("fail to alloc handle");
+	handle->conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+	if (handle->conn == NULL) {
+		ERR("g_bus_get_sync() failed. %s", err->message);
+		g_error_free(err);
+		free(handle);
 		return NULL;
 	}
 
-	dbus_error_init(&err);
-	conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
-	if (!conn) {
-		ERR("fail to get bus : %s", err.message);
-		goto error_n_return;
-	}
-
-	dbus_connection_setup_with_g_main(conn, NULL);
-	snprintf(rule, 1024,
-		"path='%s',type='signal',interface='%s',member='%s'",
-		MINICTRL_DBUS_PATH,
-		MINICTRL_DBUS_INTERFACE,
-		signal);
-
-	dbus_bus_add_match(conn, rule, &err);
-	if (dbus_error_is_set(&err)) {
-		ERR("fail to dbus_bus_remove_match : %s",
-				err.message);
-		goto error_n_return;
-	}
-
-	if (dbus_connection_add_filter(conn, _minictrl_signal_filter,
-					handle, NULL) == FALSE) {
-		ERR("fail to dbus_connection_add_filter : %s",
-				err.message);
-		goto error_n_return;
+	handle->s_id = g_dbus_connection_signal_subscribe(handle->conn,
+			NULL, MINICTRL_DBUS_INTERFACE, signal,
+			MINICTRL_DBUS_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
+			__minictrl_signal_filter, handle, NULL);
+	if (handle->s_id == 0) {
+		ERR("g_dbus_connection_signal_subscribe() failed.");
+		g_object_unref(handle->conn);
+		free(handle);
+		return NULL;
 	}
 
-	dbus_connection_set_exit_on_disconnect(conn, FALSE);
-
-	handle->conn = conn;
 	handle->callback = callback;
 	handle->user_data = data;
 	handle->signal = strdup(signal);
 
 	INFO("success to attach signal[%s]-[%p, %p]", signal, callback, data);
+	g_clear_error(&err);
 
 	return handle;
-
-
-error_n_return:
-	if (handle)
-		free(handle);
-
-	dbus_error_free(&err);
-
-	if (conn)
-		dbus_connection_close(conn);
-
-	return NULL;
 }
 
 void _minictrl_dbus_sig_handle_dettach(minictrl_sig_handle *handle)
 {
-	DBusError err;
-	char rule[1024] = {'\0', };
-
 	if (!handle) {
 		ERR("handle is NULL");
 		return;
 	}
 
-	dbus_error_init(&err);
-
-	dbus_connection_remove_filter(handle->conn, _minictrl_signal_filter, handle);
-
-	snprintf(rule, 1024,
-		"path='%s',type='signal',interface='%s',member='%s'",
-		MINICTRL_DBUS_PATH,
-		MINICTRL_DBUS_INTERFACE,
-		handle->signal);
-
-	dbus_bus_remove_match(handle->conn, rule, &err);
-	if (dbus_error_is_set(&err)) {
-		ERR("fail to dbus_bus_remove_match : %s", err.message);
-		dbus_error_free(&err);
-	}
-
-	dbus_connection_close(handle->conn);
-
+	g_dbus_connection_signal_unsubscribe(handle->conn, handle->s_id);
+	g_object_unref(handle->conn);
 	free(handle->signal);
 	free(handle);
-
-	return;
 }
 
diff --git a/src/minicontrol-monitor.c b/src/minicontrol-monitor.c
index 40041a5..f26388e 100755
--- a/src/minicontrol-monitor.c
+++ b/src/minicontrol-monitor.c
@@ -15,7 +15,6 @@
  */
 
 #include <stdlib.h>
-#include <dbus/dbus.h>
 
 #include "minicontrol-error.h"
 #include "minicontrol-internal.h"
diff --git a/src/minicontrol-provider.c b/src/minicontrol-provider.c
index 3790921..1cee113 100755
--- a/src/minicontrol-provider.c
+++ b/src/minicontrol-provider.c
@@ -63,7 +63,7 @@ static void __minicontrol_provider_free(struct _minicontrol_provider *pd)
 	}
 }
 
-static void _running_req_cb(void *data, DBusMessage *msg)
+static void _running_req_cb(void *data, GVariant *parameters)
 {
 	struct _minicontrol_provider *pd;
 
@@ -81,17 +81,16 @@ static void _running_req_cb(void *data, DBusMessage *msg)
 	}
 }
 
-static void _sig_to_provider_handler_cb(void *data, DBusMessage *msg)
+static void _sig_to_provider_handler_cb(void *data, GVariant *parameters)
 {
 	struct _minicontrol_provider *pd;
-	DBusError err;
 	char *minicontrol_name = NULL;
 	minicontrol_viewer_event_e event;
-	dbus_bool_t dbus_ret;
-	bundle *event_arg_bundle = NULL;
+	bundle *event_arg_bundle;
 	bundle_raw *serialized_arg = NULL;
 	unsigned int serialized_arg_length = 0;
-
+	Evas_Coord width;
+	Evas_Coord height;
 
 	if (!data) {
 		ERR("data is NULL");
@@ -99,33 +98,23 @@ static void _sig_to_provider_handler_cb(void *data, DBusMessage *msg)
 	}
 	pd = data;
 
-	dbus_error_init(&err); /* Does not allocate any memory. the error only needs to be freed if it is set at some point. */
-
-	dbus_ret = dbus_message_get_args(msg, &err,
-				DBUS_TYPE_STRING, &minicontrol_name,
-				DBUS_TYPE_INT32,  &event,
-				DBUS_TYPE_STRING, &serialized_arg,
-				DBUS_TYPE_UINT32, &serialized_arg_length,
-				DBUS_TYPE_INVALID);
-
-	if (!dbus_ret) {
-		ERR("fail to get args : %s", err.message);
-		dbus_error_free(&err);
-		return;
-	}
-
-	INFO("minicontrol_name[%s] event[%d] pd->name[%s]", minicontrol_name, event, pd->name);
+	g_variant_get(parameters, "(&si&su)", &minicontrol_name, &event,
+			&serialized_arg, &serialized_arg_length);
 
-	if (minicontrol_name && pd->name && strcmp(minicontrol_name, pd->name) == 0) {
-		event_arg_bundle = bundle_decode(serialized_arg, serialized_arg_length);
-		/* event argument can be null */
+	INFO("minicontrol_name[%s] event[%d] pd->name[%s]",
+			minicontrol_name, event, pd->name);
 
+	if (minicontrol_name && pd->name &&
+			strcmp(minicontrol_name, pd->name) == 0) {
+		event_arg_bundle = bundle_decode(serialized_arg,
+				serialized_arg_length);
 		if (event == MINICONTROL_VIEWER_EVENT_SHOW) {
-			Evas_Coord width;
-			Evas_Coord height;
-			evas_object_geometry_get(pd->obj, NULL, NULL, &width, &height);
+			evas_object_geometry_get(pd->obj, NULL, NULL,
+					&width, &height);
 			INFO("width[%d] height[%d]", width, height);
-			_minictrl_provider_message_send(MINICONTROL_EVENT_RESIZE, pd->name, width, height, 0);
+			_minictrl_provider_message_send(
+					MINICONTROL_EVENT_RESIZE, pd->name,
+					width, height, 0);
 		}
 
 		if (pd->event_callback)
@@ -136,8 +125,6 @@ static void _sig_to_provider_handler_cb(void *data, DBusMessage *msg)
 	}
 }
 
-
-
 static char *_minictrl_create_name(const char *name)
 {
 	char *buf;
diff --git a/src/minicontrol-viewer.c b/src/minicontrol-viewer.c
index 050eec0..f8ab37b 100755
--- a/src/minicontrol-viewer.c
+++ b/src/minicontrol-viewer.c
@@ -48,45 +48,33 @@ EXPORT_API int minicontrol_viewer_send_event(const char *minicontrol_name, minic
 }
 
 
-static void _sig_to_viewer_handler_cb(void *data, DBusMessage *msg)
+static void _sig_to_viewer_handler_cb(void *data, GVariant *parameters)
 {
-	DBusError err;
 	char *minicontrol_name = NULL;
 	minicontrol_event_e event;
-	dbus_bool_t dbus_ret;
 	bundle *event_arg_bundle = NULL;
 	bundle_raw *serialized_arg = NULL;
 	unsigned int serialized_arg_length = 0;
 
-	dbus_error_init(&err); /* Does not allocate any memory. the error only needs to be freed if it is set at some point. */
-
-	dbus_ret = dbus_message_get_args(msg, &err,
-				DBUS_TYPE_STRING, &minicontrol_name,
-				DBUS_TYPE_INT32, &event,
-				DBUS_TYPE_STRING, &serialized_arg,
-				DBUS_TYPE_UINT32, &serialized_arg_length,
-				DBUS_TYPE_INVALID);
-
-	if (!dbus_ret) {
-		ERR("fail to get args : %s", err.message);
-		dbus_error_free(&err);
-		return;
-	}
+	g_variant_get(parameters, "(&si&su)", &minicontrol_name, &event,
+			&serialized_arg, &serialized_arg_length);
 
 	if (serialized_arg_length != 0) {
-		event_arg_bundle = bundle_decode(serialized_arg, serialized_arg_length);
-
+		event_arg_bundle = bundle_decode(serialized_arg,
+				serialized_arg_length);
 		if (event_arg_bundle == NULL) {
 			ERR("fail to deserialize arguments");
 			return;
 		}
 	}
 
-	if (g_minicontrol_viewer_h->callback)
-		g_minicontrol_viewer_h->callback(event, minicontrol_name, event_arg_bundle, g_minicontrol_viewer_h->user_data);
+	if (g_minicontrol_viewer_h->callback) {
+		g_minicontrol_viewer_h->callback(event, minicontrol_name,
+				event_arg_bundle,
+				g_minicontrol_viewer_h->user_data);
+	}
 
 	bundle_free(event_arg_bundle);
-	dbus_error_free(&err);
 }