Merged from tizen_2.4tizen_3.0.m2.a1_tv_releasetizen_3.0.m2.a1_mobile_releasetizen_3.0.m1_tv_releasetizen_3.0.m1_mobile_releasesubmit/tizen_3.0.2015.q2_common/20150615.075539submit/tizen/20150610.023351submit/tizen/20150610.012936accepted/tizen/wearable/20150610.100015accepted/tizen/tv/20150610.100020accepted/tizen/mobile/20150610.095952accepted/tizen/common/20150610.092641accepted/tizen/3.0.2015.q2/common/20150615.091816tizen_3.0.m1_tvtizen_3.0.m1_mobiletizen_3.0.2015.q2_commonaccepted/tizen_3.0.2015.q2_common

Change-Id: I73bf7ba6fb5a56a1c7b9a110a16596a83c7cf068
Signed-off-by: Kyuho Jo <kyuho.jo@samsung.com>

4 files changed, 672 insertions, 379 deletions

diff --git a/src/minicontrol-internal.c b/src/minicontrol-internal.c
index b62be1e..b414169 100755
--- a/src/minicontrol-internal.c
+++ b/src/minicontrol-internal.c
@@ -1,14 +1,14 @@
 /*
- * Copyright 2012  Samsung Electronics Co., Ltd
+ * Copyright (c)  2013-2015 Samsung Electronics Co., Ltd All Rights Reserved
  *
- * Licensed under the Flora License, Version 1.1 (the "License");
+ * 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://floralicense.org/license/
+ * 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,
+ * 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.
@@ -17,6 +17,7 @@
 #include <stdlib.h>
 #include <dbus/dbus.h>
 #include <dbus/dbus-glib-lowlevel.h>
+#include <bundle.h>
 
 #include "minicontrol-error.h"
 #include "minicontrol-type.h"
@@ -26,6 +27,12 @@
 #define MINICTRL_DBUS_PATH "/org/tizen/minicontrol"
 #define MINICTRL_DBUS_INTERFACE "org.tizen.minicontrol.signal"
 
+#define PROC_DBUS_OBJECT 	"/Org/Tizen/ResourceD/Process"
+#define PROC_DBUS_INTERFACE 	"org.tizen.resourced.process"
+#define PROC_DBUS_METHOD 	"ProcExclude"
+#define PROC_DBUS_EXCLUDE	"exclude"
+#define PROC_DBUS_INCLUDE	"include"
+
 struct _minictrl_sig_handle {
 	DBusConnection *conn;
 	void (*callback) (void *data, DBusMessage *msg);
@@ -45,7 +52,7 @@ int _minictrl_viewer_req_message_send(void)
 	connection = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
 	if (!connection) {
 		ERR("Fail to dbus_bus_get : %s", err.message);
-		ret = MINICONTROL_ERROR_DBUS;
+		ret = MINICONTROL_ERROR_IPC_FAILURE;
 		goto release_n_return;
 	}
 
@@ -61,7 +68,7 @@ int _minictrl_viewer_req_message_send(void)
 	dbus_ret = dbus_connection_send(connection, message, NULL);
 	if (!dbus_ret) {
 		ERR("fail to send dbus viewer req message");
-		ret = MINICONTROL_ERROR_DBUS;
+		ret = MINICONTROL_ERROR_IPC_FAILURE;
 		goto release_n_return;
 	}
 
@@ -79,23 +86,70 @@ release_n_return:
 	return ret;
 }
 
-int _minictrl_provider_message_send(const char *sig_name, const char *svr_name,
-				unsigned int witdh, unsigned int height,
-				minicontrol_priority_e priority)
+int _minictrl_provider_proc_send(int type)
+{
+	DBusError err;
+	DBusConnection* conn = NULL;
+	DBusMessage* msg = NULL;
+	int ret = -1;
+	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 {
+		ERR("Check unsupported type : %d", type);
+		return ret;
+	}
+	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;
+	}
+	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);
+
+	return ret;
+
+}
+
+int _minictrl_send_event(const char *signal_name, const char *provider_app_id, int event, bundle *signal_arg)
 {
 	DBusConnection *connection = NULL;
 	DBusMessage *message = NULL;
 	DBusError err;
 	dbus_bool_t dbus_ret;
+	bundle_raw *serialized_arg = NULL;
+	unsigned int serialized_arg_length = 0;
 	int ret = MINICONTROL_ERROR_NONE;
 
-	if (!sig_name) {
-		ERR("sig_name is NULL, invaild parameter");
-		return MINICONTROL_ERROR_INVALID_PARAMETER;
-	}
-
-	if (!svr_name) {
-		ERR("svr_name is NULL, invaild parameter");
+	if (provider_app_id == NULL) {
+		ERR("Invaild parameter");
 		return MINICONTROL_ERROR_INVALID_PARAMETER;
 	}
 
@@ -103,13 +157,11 @@ int _minictrl_provider_message_send(const char *sig_name, const char *svr_name,
 	connection = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
 	if (!connection) {
 		ERR("Fail to dbus_bus_get : %s", err.message);
-		ret = MINICONTROL_ERROR_DBUS;
+		ret = MINICONTROL_ERROR_IPC_FAILURE;
 		goto release_n_return;
 	}
 
-	message = dbus_message_new_signal(MINICTRL_DBUS_PATH,
-				MINICTRL_DBUS_INTERFACE,
-				sig_name);
+	message = dbus_message_new_signal(MINICTRL_DBUS_PATH, MINICTRL_DBUS_INTERFACE, signal_name);
 
 	if (!message) {
 		ERR("fail to create dbus message");
@@ -117,32 +169,47 @@ int _minictrl_provider_message_send(const char *sig_name, const char *svr_name,
 		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;
+		}
+	}
+	else {
+		serialized_arg = (bundle_raw*)strdup("");
+		serialized_arg_length = 0;
+	}
+
 	dbus_ret = dbus_message_append_args(message,
-			DBUS_TYPE_STRING, &svr_name,
-			DBUS_TYPE_UINT32, &witdh,
-			DBUS_TYPE_UINT32, &height,
-			DBUS_TYPE_UINT32, &priority,
+			DBUS_TYPE_STRING, &provider_app_id,
+			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 name to dbus message : %s", svr_name);
+		ERR("fail to append arguments to dbus message : [%s][%d]", provider_app_id, 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", svr_name);
-		ret = MINICONTROL_ERROR_DBUS;
+		ERR("fail to send dbus message : %s", provider_app_id);
+		ret = MINICONTROL_ERROR_IPC_FAILURE;
 		goto release_n_return;
 	}
 
 	dbus_connection_flush(connection);
-	INFO("[%s][%s] size-[%ux%u] priority[%u]",
-		sig_name, svr_name, witdh, height, priority);
 
 release_n_return:
 	dbus_error_free(&err);
 
+	if (serialized_arg)
+		free(serialized_arg);
+
 	if (message)
 		dbus_message_unref(message);
 
@@ -152,8 +219,38 @@ release_n_return:
 	return ret;
 }
 
-static DBusHandlerResult _minictrl_signal_filter(DBusConnection *conn,
-		DBusMessage *msg, void *user_data)
+
+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, };
+
+	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;
+	}
+
+	snprintf(bundle_value_buffer, BUNDLE_BUFFER_LENGTH, "%s", minicontrol_name);
+
+	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));
+
+	_minictrl_send_event(MINICTRL_DBUS_SIG_TO_VIEWER, minicontrol_name, event, event_arg_bundle);
+
+out:
+	if (event_arg_bundle)
+		bundle_free(event_arg_bundle);
+
+	return ret;
+}
+
+static DBusHandlerResult _minictrl_signal_filter(DBusConnection *conn, DBusMessage *msg, void *user_data)
 {
 	minictrl_sig_handle *handle = NULL;
 	const char *interface;
@@ -276,8 +373,7 @@ void _minictrl_dbus_sig_handle_dettach(minictrl_sig_handle *handle)
 
 	dbus_error_init(&err);
 
-	dbus_connection_remove_filter(handle->conn,
-			_minictrl_signal_filter, handle);
+	dbus_connection_remove_filter(handle->conn, _minictrl_signal_filter, handle);
 
 	snprintf(rule, 1024,
 		"path='%s',type='signal',interface='%s',member='%s'",
diff --git a/src/minicontrol-monitor.c b/src/minicontrol-monitor.c
index 1f0024d..2f94835 100755
--- a/src/minicontrol-monitor.c
+++ b/src/minicontrol-monitor.c
@@ -1,14 +1,14 @@
 /*
- * Copyright 2012  Samsung Electronics Co., Ltd
+ * Copyright (c)  2013-2015 Samsung Electronics Co., Ltd All Rights Reserved
  *
- * Licensed under the Flora License, Version 1.1 (the "License");
+ * 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://floralicense.org/license/
+ * 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,
+ * 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.
@@ -20,18 +20,16 @@
 #include "minicontrol-error.h"
 #include "minicontrol-internal.h"
 #include "minicontrol-monitor.h"
+#include "minicontrol-viewer.h"
 #include "minicontrol-log.h"
 
 struct _minicontrol_monitor {
-	minictrl_sig_handle *start_sh;
-	minictrl_sig_handle *stop_sh;
-	minictrl_sig_handle *resize_sh;
-	minictrl_sig_handle *request_sh;
+	minictrl_sig_handle *event_sh;
 	minicontrol_monitor_cb callback;
 	void *user_data;
 };
 
-static struct _minicontrol_monitor *g_monitor_h;
+static struct _minicontrol_monitor *g_monitor_h = NULL;
 
 static minicontrol_priority_e _int_to_priority(unsigned int value)
 {
@@ -51,202 +49,74 @@ static minicontrol_priority_e _int_to_priority(unsigned int value)
 	return priority;
 }
 
-static void _provider_start_cb(void *data, DBusMessage *msg)
+static void _sig_to_viewer_handler_cb(minicontrol_event_e event, const char *minicontrol_name, bundle *event_arg, void *data)
 {
-	DBusError err;
-	char *svr_name = NULL;
-	unsigned int w = 0;
-	unsigned int h = 0;
-	unsigned int pri = 0;
-	minicontrol_priority_e priority;
-	dbus_bool_t dbus_ret;
-
-	dbus_error_init(&err);
-
-	dbus_ret = dbus_message_get_args(msg, &err,
-				DBUS_TYPE_STRING, &svr_name,
-				DBUS_TYPE_UINT32, &w,
-				DBUS_TYPE_UINT32, &h,
-				DBUS_TYPE_UINT32, &pri,
-				DBUS_TYPE_INVALID);
-	if (!dbus_ret) {
-		ERR("fail to get args : %s", err.message);
-		dbus_error_free(&err);
-		return;
-	}
-
-	priority = _int_to_priority(pri);
-
-	if (g_monitor_h->callback)
-		g_monitor_h->callback(MINICONTROL_ACTION_START,
-				svr_name, w, h, priority,
-				g_monitor_h->user_data);
+	minicontrol_action_e action;
+	int width = 0;
+	int height = 0;
+	int priority_from_signal = 0;
+	minicontrol_priority_e priority = 0;
+	size_t n_size;
+
+	switch(event) {
+	case MINICONTROL_EVENT_START:
+		action = MINICONTROL_ACTION_START;
+		break;
 
-	dbus_error_free(&err);
-}
+	case MINICONTROL_EVENT_STOP:
+		action = MINICONTROL_ACTION_STOP;
+		break;
 
-static void _provider_stop_cb(void *data, DBusMessage *msg)
-{
-	DBusError err;
-	char *svr_name = NULL;
-	dbus_bool_t dbus_ret;
+	case MINICONTROL_EVENT_RESIZE:
+		action = MINICONTROL_ACTION_RESIZE;
+		break;
 
-	dbus_error_init(&err);
+	case MINICONTROL_EVENT_REQUEST_HIDE:
+	case MINICONTROL_EVENT_REQUEST_ANGLE:
+		action = MINICONTROL_ACTION_REQUEST;
+		break;
 
-	dbus_ret = dbus_message_get_args(msg, &err,
-				DBUS_TYPE_STRING, &svr_name,
-				DBUS_TYPE_INVALID);
-	if (!dbus_ret) {
-		ERR("fail to get args : %s", err.message);
-		dbus_error_free(&err);
-		return;
+	default:
+		WARN("Not supported event [%d]", event);
+		action = event;
+		break;
 	}
 
-	if (g_monitor_h->callback)
-		g_monitor_h->callback(MINICONTROL_ACTION_STOP,
-				svr_name, 0, 0, MINICONTROL_PRIORITY_LOW,
-				g_monitor_h->user_data);
-
-	dbus_error_free(&err);
-}
-
-static void _provider_resize_cb(void *data, DBusMessage *msg)
-{
-	DBusError err;
-	char *svr_name = NULL;
-	unsigned int w = 0;
-	unsigned int h = 0;
-	unsigned int pri = 0;
-	minicontrol_priority_e priority;
-	dbus_bool_t dbus_ret;
-
-	dbus_error_init(&err);
-
-	dbus_ret = dbus_message_get_args(msg, &err,
-				DBUS_TYPE_STRING, &svr_name,
-				DBUS_TYPE_UINT32, &w,
-				DBUS_TYPE_UINT32, &h,
-				DBUS_TYPE_UINT32, &pri,
-				DBUS_TYPE_INVALID);
-	if (!dbus_ret) {
-		ERR("fail to get args : %s", err.message);
-		dbus_error_free(&err);
-		return;
+	if (action == MINICONTROL_ACTION_START || action == MINICONTROL_ACTION_RESIZE || action == MINICONTROL_ACTION_REQUEST) {
+		bundle_get_byte(event_arg, "width", (void*)&width, &n_size);
+		bundle_get_byte(event_arg, "height", (void*)&height, &n_size);
+		bundle_get_byte(event_arg, "priority", (void*)&priority_from_signal, &n_size);
+		priority = _int_to_priority(priority_from_signal);
 	}
-
-	priority = _int_to_priority(pri);
-
-	if (g_monitor_h->callback)
-		g_monitor_h->callback(MINICONTROL_ACTION_RESIZE,
-				svr_name, w, h, priority,
-				g_monitor_h->user_data);
-
-	dbus_error_free(&err);
-}
-
-static void _provider_request_cb(void *data, DBusMessage *msg)
-{
-	DBusError err;
-	char *svr_name = NULL;
-	unsigned int w = 0;
-	unsigned int h = 0;
-	unsigned int pri = 0;
-	minicontrol_priority_e priority;
-	dbus_bool_t dbus_ret;
-
-	dbus_error_init(&err);
-
-	dbus_ret = dbus_message_get_args(msg, &err,
-				DBUS_TYPE_STRING, &svr_name,
-				DBUS_TYPE_UINT32, &w,
-				DBUS_TYPE_UINT32, &h,
-				DBUS_TYPE_UINT32, &pri,
-				DBUS_TYPE_INVALID);
-	if (!dbus_ret) {
-		ERR("fail to get args : %s", err.message);
-		dbus_error_free(&err);
-		return;
+	else {
+		priority = MINICONTROL_PRIORITY_LOW;
 	}
 
-	priority = _int_to_priority(pri);
-
-	if (g_monitor_h->callback)
-		g_monitor_h->callback(MINICONTROL_ACTION_REQUEST,
-				svr_name, w, h, priority,
-				g_monitor_h->user_data);
-
-	dbus_error_free(&err);
+	g_monitor_h->callback(action, minicontrol_name, width, height, priority, g_monitor_h->user_data);
 }
 
-EXPORT_API minicontrol_error_e minicontrol_monitor_start(
-				minicontrol_monitor_cb callback, void *data)
+EXPORT_API minicontrol_error_e minicontrol_monitor_start(minicontrol_monitor_cb callback, void *data)
 {
 	if (!callback)
 		return MINICONTROL_ERROR_INVALID_PARAMETER;
 
-	if (!g_monitor_h) {
-		minictrl_sig_handle *start_sh;
-		minictrl_sig_handle *stop_sh;
-		minictrl_sig_handle *resize_sh;
-		minictrl_sig_handle *request_sh;
-		struct _minicontrol_monitor *monitor_h;
-
-		start_sh = _minictrl_dbus_sig_handle_attach(
-				MINICTRL_DBUS_SIG_START,
-				_provider_start_cb, NULL);
-		if (!start_sh) {
-			ERR("fail to _minictrl_dbus_sig_handle_attach - %s",
-				MINICTRL_DBUS_SIG_START);
-			return MINICONTROL_ERROR_DBUS;
-		}
-
-		stop_sh = _minictrl_dbus_sig_handle_attach(
-				MINICTRL_DBUS_SIG_STOP,
-				_provider_stop_cb, NULL);
-		if (!stop_sh) {
-			ERR("fail to _minictrl_dbus_sig_handle_attach - %s",
-				MINICTRL_DBUS_SIG_STOP);
-			return MINICONTROL_ERROR_DBUS;
-		}
-
-		resize_sh = _minictrl_dbus_sig_handle_attach(
-				MINICTRL_DBUS_SIG_RESIZE,
-				_provider_resize_cb, NULL);
-		if (!resize_sh) {
-			ERR("fail to _minictrl_dbus_sig_handle_attach - %s",
-				MINICTRL_DBUS_SIG_RESIZE);
-			return MINICONTROL_ERROR_DBUS;
-		}
-
-		request_sh = _minictrl_dbus_sig_handle_attach(
-				MINICTRL_DBUS_SIG_REQUEST,
-				_provider_request_cb, NULL);
-		if (!request_sh) {
-			ERR("fail to _minictrl_dbus_sig_handle_attach - %s",
-					MINICTRL_DBUS_SIG_REQUEST);
-			return MINICONTROL_ERROR_DBUS;
-		}
+	INFO("callback[%p], data[%p]", callback, data);
 
-		monitor_h = malloc(sizeof(struct _minicontrol_monitor));
-		if (!monitor_h) {
-			ERR("fail to alloc monitor_h");
-			_minictrl_dbus_sig_handle_dettach(start_sh);
-			_minictrl_dbus_sig_handle_dettach(stop_sh);
-			_minictrl_dbus_sig_handle_dettach(resize_sh);
-			_minictrl_dbus_sig_handle_dettach(request_sh);
-			return MINICONTROL_ERROR_OUT_OF_MEMORY;
-		}
+	if (g_monitor_h) {
+		ERR("Already started");
+		return MINICONTROL_ERROR_UNKNOWN;
+	}
 
-		monitor_h->start_sh = start_sh;
-		monitor_h->stop_sh = stop_sh;
-		monitor_h->resize_sh = resize_sh;
-		monitor_h->request_sh = request_sh;
-		g_monitor_h = monitor_h;
+	g_monitor_h = malloc(sizeof(struct _minicontrol_monitor));
+	if (g_monitor_h == NULL) {
+		ERR("fail to alloc monitor_h");
+		return MINICONTROL_ERROR_OUT_OF_MEMORY;
 	}
 
+	minicontrol_viewer_set_event_cb(_sig_to_viewer_handler_cb, data);
+
 	g_monitor_h->callback = callback;
 	g_monitor_h->user_data = data;
-	INFO("callback[%p], data[%p]", callback, data);
 
 	return _minictrl_viewer_req_message_send();
 }
@@ -256,21 +126,10 @@ EXPORT_API minicontrol_error_e minicontrol_monitor_stop(void)
 	if (!g_monitor_h)
 		return MINICONTROL_ERROR_NONE;
 
-	if (g_monitor_h->start_sh)
-		_minictrl_dbus_sig_handle_dettach(g_monitor_h->start_sh);
-
-	if (g_monitor_h->stop_sh)
-		_minictrl_dbus_sig_handle_dettach(g_monitor_h->stop_sh);
-
-	if (g_monitor_h->resize_sh)
-		_minictrl_dbus_sig_handle_dettach(g_monitor_h->resize_sh);
-
-	if (g_monitor_h->request_sh)
-		_minictrl_dbus_sig_handle_dettach(g_monitor_h->request_sh);
+	minicontrol_viewer_unset_event_cb();
 
 	free(g_monitor_h);
 	g_monitor_h = NULL;
 
 	return MINICONTROL_ERROR_NONE;
 }
-
diff --git a/src/minicontrol-provider.c b/src/minicontrol-provider.c
index 9f8178b..706c721 100755
--- a/src/minicontrol-provider.c
+++ b/src/minicontrol-provider.c
@@ -1,25 +1,27 @@
 /*
- * Copyright 2012  Samsung Electronics Co., Ltd
+ * Copyright (c)  2013-2015 Samsung Electronics Co., Ltd All Rights Reserved
  *
- * Licensed under the Flora License, Version 1.1 (the "License");
+ * 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://floralicense.org/license/
+ * 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,
+ * 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.
  */
 
 #include <Elementary.h>
+#include <Ecore_Evas.h>
 
 #include "minicontrol-error.h"
 #include "minicontrol-type.h"
 #include "minicontrol-internal.h"
 #include "minicontrol-provider.h"
+#include "minicontrol-provider-internal.h"
 #include "minicontrol-log.h"
 
 #define MINICTRL_PRIORITY_SUFFIX_TOP "__minicontrol_top"
@@ -31,50 +33,65 @@ enum {
 	MINICTRL_STATE_RUNNING,
 };
 
-struct _provider_data {
+struct _minicontrol_provider {
 	char *name;
 	int state;
-	minicontrol_priority_e priority;
 	Evas_Object *obj;
-	minictrl_sig_handle *sh;
+	minictrl_sig_handle *running_sh;
+	minictrl_sig_handle *event_sh;
+	minicontrol_event_cb event_callback;
 };
 
-static void __provider_data_free(struct _provider_data *pd)
+static void _minictrl_win_del_cb(void *data, Evas *e, Evas_Object *obj, void *event_info);
+static void _minictrl_win_hide_cb(void *data, Evas *e, Evas_Object *obj, void *event_info);
+static void _minictrl_win_show_cb(void *data, Evas *e, Evas_Object *obj, void *event_info);
+static void _minictrl_win_resize_cb(void *data, Evas *e, Evas_Object *obj, void *event_info);
+
+static void __minicontrol_provider_free(struct _minicontrol_provider *pd)
 {
 	if (pd) {
 		if (pd->name)
 			free(pd->name);
 
-		if (pd->sh)
-			_minictrl_dbus_sig_handle_dettach(pd->sh);
+		if (pd->running_sh)
+			_minictrl_dbus_sig_handle_dettach(pd->running_sh);
+
+		if (pd->event_sh)
+			_minictrl_dbus_sig_handle_dettach(pd->event_sh);
 
 		free(pd);
 	}
 }
 
-static int __str_has_suffix(const char *str, const char *suffix)
+static void _running_req_cb(void *data, DBusMessage *msg)
 {
-	int str_len;
-	int suffix_len;
-
-	if (!str)
-		return -1;
-
-	if (!suffix)
-		return -1;
-
-	str_len = strlen (str);
-	suffix_len = strlen (suffix);
+	struct _minicontrol_provider *pd;
 
-	if (str_len < suffix_len)
-		return -1;
+	if (!data) {
+		ERR("data is NULL");
+		return;
+	}
+	pd = data;
 
-	return strcmp(str + str_len - suffix_len, suffix);
+	if (pd->state == MINICTRL_STATE_RUNNING) {
+		Evas_Coord w = 0;
+		Evas_Coord h = 0;
+		evas_object_geometry_get(pd->obj, NULL, NULL, &w, &h);
+		_minictrl_provider_message_send(MINICONTROL_EVENT_START, pd->name, w, h, 0);
+	}
 }
 
-static void _running_req_cb(void *data, DBusMessage *msg)
+static void _sig_to_provider_handler_cb(void *data, DBusMessage *msg)
 {
-	struct _provider_data *pd;
+	struct _minicontrol_provider *pd;
+	DBusError err;
+	char *provider_app_id = NULL;
+	minicontrol_viewer_event_e event;
+	dbus_bool_t dbus_ret;
+	bundle *event_arg_bundle = NULL;
+	bundle_raw *serialized_arg = NULL;
+	unsigned int serialized_arg_length = 0;
+
 
 	if (!data) {
 		ERR("data is NULL");
@@ -82,18 +99,184 @@ static void _running_req_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, &provider_app_id,
+				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;
+	}
+
+	event_arg_bundle = bundle_decode(serialized_arg, serialized_arg_length);
+
+	if (event_arg_bundle == NULL) {
+		ERR("fail to deserialize arguments");
+		return;
+	}
+
+	if (pd->event_callback)
+		pd->event_callback(event, event_arg_bundle);
+}
+
+
+
+static char *_minictrl_create_name(const char *name)
+{
+	char *buf;
+	int size = 0;
+
+	if (!name) {
+		ERR("name is NULL, invaild parameter");
+		set_last_result(MINICONTROL_ERROR_INVALID_PARAMETER);
+		return NULL;
+	}
+
+	size = snprintf(NULL, 0, "[%s]", name) + 1;
+	buf = (char *)malloc(sizeof(char) * size);
+	if (!buf) {
+		ERR("fail to alloc buf");
+		set_last_result(MINICONTROL_ERROR_OUT_OF_MEMORY);
+		return NULL;
+	}
+
+	snprintf(buf, size, "[%s]", name);
+
+	return buf;
+}
+
+static void _access_changed_cb(void *data, Evas_Object *obj, void *event_info)
+{
+	Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(obj));
+	if (ee != NULL) {
+		if (elm_config_access_get()) {
+			/* TODO : Check this API is supported
+			ecore_evas_extn_socket_events_block_set(ee, EINA_TRUE);
+			 */
+		}
+		else {
+			/* TODO : Check this API is supported
+			ecore_evas_extn_socket_events_block_set(ee, EINA_FALSE);
+			 */
+		}
+	}
+}
+
+
+EXPORT_API Evas_Object* minicontrol_create_window(const char *name, minicontrol_target_viewer_e target_viewer, minicontrol_event_cb event_callback)
+{
+	Evas_Object *win = NULL;
+	char *name_inter = NULL;
+	struct _minicontrol_provider *pd;
+
+	if (!name) {
+		ERR("invalid parameter");
+		set_last_result(MINICONTROL_ERROR_INVALID_PARAMETER);
+		return NULL;
+	}
+
+	win = elm_win_add(NULL, "minicontrol", ELM_WIN_SOCKET_IMAGE);
+	if (!win) {
+		ERR("elm_win_add failed");
+		set_last_result(MINICONTROL_ERROR_ELM_FAILURE);
+		return NULL;
+	}
+
+	if (elm_config_access_get()) {
+		Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(win));
+
+		if (ee != NULL) {
+			/* TODO : Check this API is supported
+			ecore_evas_extn_socket_events_block_set(ee, EINA_TRUE);
+			 */
+		}
+
+	}
+	evas_object_smart_callback_add(win, "access,changed", _access_changed_cb, NULL);
+
+	name_inter = _minictrl_create_name(name);
+	if (!name_inter) {
+		ERR("Fail to create name_inter for : %s", name);
+		evas_object_del(win);
+		return NULL;
+	}
+
+	if (!elm_win_socket_listen(win, name_inter, 0, EINA_TRUE)) {
+		ERR("Fail to elm win socket listen");
+		set_last_result(MINICONTROL_ERROR_ELM_FAILURE);
+		evas_object_del(win);
+		free(name_inter);
+		return NULL;
+	}
+
+	pd = malloc(sizeof(struct _minicontrol_provider));
+	if (!pd) {
+		ERR("Fail to alloc memory");
+		set_last_result(MINICONTROL_ERROR_OUT_OF_MEMORY);
+		evas_object_del(win);
+		free(name_inter);
+		return NULL;
+
+	}
+	memset(pd, 0x00, sizeof(struct _minicontrol_provider));
+	pd->name = name_inter;
+	pd->state = MINICTRL_STATE_READY;
+	pd->obj = win;
+
+	evas_object_data_set(win ,MINICTRL_DATA_KEY,pd);
+
+	elm_win_autodel_set(win, EINA_TRUE);
+
+	evas_object_event_callback_add(win, EVAS_CALLBACK_DEL, _minictrl_win_del_cb, pd);
+	evas_object_event_callback_add(win, EVAS_CALLBACK_SHOW, _minictrl_win_show_cb, pd);
+	evas_object_event_callback_add(win, EVAS_CALLBACK_HIDE,	_minictrl_win_hide_cb, pd);
+	evas_object_event_callback_add(win, EVAS_CALLBACK_RESIZE, _minictrl_win_resize_cb, pd);
+
+	pd->running_sh = _minictrl_dbus_sig_handle_attach(MINICTRL_DBUS_SIG_RUNNING_REQ, _running_req_cb, pd);
+	pd->event_sh   = _minictrl_dbus_sig_handle_attach(MINICTRL_DBUS_SIG_TO_PROVIDER, _sig_to_provider_handler_cb, pd);
+	pd->event_callback = event_callback;
+
+	INFO("new minicontrol created - %s", pd->name);
+	return win;
+}
+
+EXPORT_API int minicontrol_send_event(Evas_Object *mincontrol, minicontrol_provider_event_e event, bundle *event_arg)
+{
+	struct _minicontrol_provider *pd;
+	int ret = MINICONTROL_ERROR_NONE;
+
+	if (!mincontrol) {
+		ERR("mincontrol is NULL, invaild parameter");
+		return MINICONTROL_ERROR_INVALID_PARAMETER;
+	}
+
+	pd = evas_object_data_get(mincontrol, MINICTRL_DATA_KEY);
+	if (!pd) {
+		ERR("pd is NULL, invaild parameter");
+		return MINICONTROL_ERROR_INVALID_PARAMETER;
+	}
+
+	if (!pd->name) {
+		ERR("pd name is NULL, invaild parameter");
+		return MINICONTROL_ERROR_INVALID_PARAMETER;
+	}
+
 	if (pd->state == MINICTRL_STATE_RUNNING) {
-		Evas_Coord w = 0;
-		Evas_Coord h = 0;
-		evas_object_geometry_get(pd->obj, NULL, NULL, &w, &h);
-		_minictrl_provider_message_send(MINICTRL_DBUS_SIG_START,
-					pd->name, w, h, pd->priority);
+		ret = _minictrl_send_event(MINICTRL_DBUS_SIG_TO_VIEWER, pd->name, event, event_arg);
 	}
+
+	return ret;
 }
 
 static int minicontrol_win_start(Evas_Object *mincontrol)
 {
-	struct _provider_data *pd;
+	struct _minicontrol_provider *pd;
 	int ret = MINICONTROL_ERROR_NONE;
 
 	if (!mincontrol) {
@@ -118,8 +301,8 @@ static int minicontrol_win_start(Evas_Object *mincontrol)
 		pd->state = MINICTRL_STATE_RUNNING;
 
 		evas_object_geometry_get(mincontrol, NULL, NULL, &w, &h);
-		ret = _minictrl_provider_message_send(MINICTRL_DBUS_SIG_START,
-					pd->name, w, h, pd->priority);
+		_minictrl_provider_proc_send(MINICONTROL_DBUS_PROC_EXCLUDE);
+		ret = _minictrl_provider_message_send(MINICONTROL_EVENT_START, pd->name, w, h, 0);
 	}
 
 	return ret;
@@ -127,7 +310,7 @@ static int minicontrol_win_start(Evas_Object *mincontrol)
 
 static int minicontrol_win_stop(Evas_Object *mincontrol)
 {
-	struct _provider_data *pd;
+	struct _minicontrol_provider *pd;
 	int ret = MINICONTROL_ERROR_NONE;
 
 	if (!mincontrol) {
@@ -147,42 +330,41 @@ static int minicontrol_win_stop(Evas_Object *mincontrol)
 	}
 	if (pd->state != MINICTRL_STATE_READY) {
 		pd->state = MINICTRL_STATE_READY;
-		ret = _minictrl_provider_message_send(MINICTRL_DBUS_SIG_STOP,
-					pd->name, 0, 0, pd->priority);
+		_minictrl_provider_proc_send(MINICONTROL_DBUS_PROC_INCLUDE);
+		ret = _minictrl_provider_message_send(MINICONTROL_EVENT_STOP, pd->name, 0, 0, 0);
 	}
 
 	return ret;
 }
 
-static void _minictrl_win_del(void *data, Evas *e,
-			Evas_Object *obj, void *event_info)
+static void _minictrl_win_del_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
 {
-	struct _provider_data *pd = NULL;
+	struct _minicontrol_provider *pd = NULL;
 
 	minicontrol_win_stop(obj);
 
 	pd = evas_object_data_get(obj, MINICTRL_DATA_KEY);
-	__provider_data_free(pd);
+	__minicontrol_provider_free(pd);
 
 	evas_object_data_set(obj, MINICTRL_DATA_KEY, NULL);
 }
 
-static void _minictrl_win_hide(void *data, Evas *e,
-			Evas_Object *obj, void *event_info)
+static void _minictrl_win_hide_cb(void *data, Evas *e,
+		Evas_Object *obj, void *event_info)
 {
 	minicontrol_win_stop(obj);
 }
 
-static void _minictrl_win_show(void *data, Evas *e,
-			Evas_Object *obj, void *event_info)
+static void _minictrl_win_show_cb(void *data, Evas *e,
+		Evas_Object *obj, void *event_info)
 {
 	minicontrol_win_start(obj);
 }
 
-static void _minictrl_win_resize(void *data, Evas *e,
-			Evas_Object *obj, void *event_info)
+static void _minictrl_win_resize_cb(void *data, Evas *e,
+		Evas_Object *obj, void *event_info)
 {
-	struct _provider_data *pd;
+	struct _minicontrol_provider *pd;
 
 	if (!data) {
 		ERR("data is NULL, invaild parameter");
@@ -195,64 +377,40 @@ static void _minictrl_win_resize(void *data, Evas *e,
 		Evas_Coord h = 0;
 
 		evas_object_geometry_get(obj, NULL, NULL, &w, &h);
-		_minictrl_provider_message_send(MINICTRL_DBUS_SIG_RESIZE,
-					pd->name, w, h, pd->priority);
+		_minictrl_provider_message_send(MINICONTROL_EVENT_RESIZE, pd->name, w, h, 0);
 	}
 }
 
-static char *_minictrl_create_name(const char *name)
+EXPORT_API Evas_Object *minicontrol_win_add(const char *name)
 {
-	time_t now;
-	struct tm *now_tm;
-	char time_buf[20]; /* 18 chars to represent time */
-	char *buf;
-	int size = 0;
+	Evas_Object *win = NULL;
+	char *name_inter = NULL;
+	struct _minicontrol_provider *pd;
+
+	INFO("minicontrol_win_add [%s]", name);
 
 	if (!name) {
-		ERR("name is NULL, invaild parameter");
+		ERR("name is null");
 		return NULL;
 	}
 
-	now = time(NULL);
-	now_tm = localtime(&now);
-	strftime(time_buf, sizeof(time_buf), "%y-%m-%d-%H:%M:%S", now_tm);
-
-	size = snprintf(NULL, 0, "[%s]-[%s]", name, time_buf) + 1;
-	buf = (char *)malloc(sizeof(char) * size);
-	if (!buf) {
-	       ERR("fail to alloc buf");
-	       return NULL;
+	win = elm_win_add(NULL, "minicontrol", ELM_WIN_SOCKET_IMAGE);
+	if (!win) {
+		ERR("elm_win_add returns null for [%s]", name);
+		return NULL;
 	}
 
-	snprintf(buf, size, "[%s]-[%s]", name, time_buf);
+	if (elm_config_access_get()) {
+		Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(win));
 
-	return buf;
-}
-
-static minicontrol_priority_e _minictrl_get_priroty_by_name(const char *name)
-{
-	minicontrol_priority_e priority = MINICONTROL_PRIORITY_MIDDLE;
+		if (ee != NULL) {
+			/* TODO : Check this API is supported
+			ecore_evas_extn_socket_events_block_set(ee, EINA_TRUE);
+			 */
+		}
 
-	if (!__str_has_suffix(name, MINICTRL_PRIORITY_SUFFIX_TOP))
-		priority = MINICONTROL_PRIORITY_TOP;
-	else if (!__str_has_suffix(name, MINICTRL_PRIORITY_SUFFIX_LOW))
-		priority = MINICONTROL_PRIORITY_LOW;
-
-	return priority;
-}
-
-EXPORT_API Evas_Object *minicontrol_win_add(const char *name)
-{
-	Evas_Object *win = NULL;
-	char *name_inter = NULL;
-	struct _provider_data *pd;
-
-	if (!name)
-		return NULL;
-
-	win = elm_win_add(NULL, "minicontrol", ELM_WIN_SOCKET_IMAGE);
-	if (!win)
-		return NULL;
+	}
+	evas_object_smart_callback_add(win, "access,changed", _access_changed_cb, NULL);
 
 	name_inter = _minictrl_create_name(name);
 	if (!name_inter) {
@@ -260,17 +418,16 @@ EXPORT_API Evas_Object *minicontrol_win_add(const char *name)
 		ERR("Fail to create name_inter for : %s", name);
 		evas_object_del(win);
 		return NULL;
-
 	}
 
-	if (!elm_win_socket_listen(win, name_inter, 0, EINA_FALSE)) {
+	if (!elm_win_socket_listen(win, name_inter, 0, EINA_TRUE)) {
 		ERR("Fail to elm win socket listen");
 		evas_object_del(win);
 		free(name_inter);
 		return NULL;
 	}
 
-	pd = malloc(sizeof(struct _provider_data));
+	pd = malloc(sizeof(struct _minicontrol_provider));
 	if (!pd) {
 		ERR("Fail to alloc memory");
 		evas_object_del(win);
@@ -278,41 +435,31 @@ EXPORT_API Evas_Object *minicontrol_win_add(const char *name)
 		return NULL;
 
 	}
-	memset(pd, 0x00, sizeof(struct _provider_data));
+	memset(pd, 0x00, sizeof(struct _minicontrol_provider));
 	pd->name = name_inter;
 	pd->state = MINICTRL_STATE_READY;
 	pd->obj = win;
-	pd->priority = _minictrl_get_priroty_by_name(name);
 
 	evas_object_data_set(win ,MINICTRL_DATA_KEY,pd);
 
 	elm_win_autodel_set(win, EINA_TRUE);
 
-	evas_object_event_callback_add(win, EVAS_CALLBACK_DEL,
-					_minictrl_win_del, pd);
-
-	evas_object_event_callback_add(win, EVAS_CALLBACK_SHOW,
-					_minictrl_win_show, pd);
+	evas_object_event_callback_add(win, EVAS_CALLBACK_DEL, _minictrl_win_del_cb, pd);
+	evas_object_event_callback_add(win, EVAS_CALLBACK_SHOW, _minictrl_win_show_cb, pd);
+	evas_object_event_callback_add(win, EVAS_CALLBACK_HIDE,	_minictrl_win_hide_cb, pd);
+	evas_object_event_callback_add(win, EVAS_CALLBACK_RESIZE, _minictrl_win_resize_cb, pd);
 
-	evas_object_event_callback_add(win, EVAS_CALLBACK_HIDE,
-					_minictrl_win_hide, pd);
-
-	evas_object_event_callback_add(win, EVAS_CALLBACK_RESIZE,
-					_minictrl_win_resize, pd);
-
-	pd->sh = _minictrl_dbus_sig_handle_attach(MINICTRL_DBUS_SIG_RUNNING_REQ,
-					_running_req_cb, pd);
-
-	INFO("new minicontrol win[%p] created - %s, priority[%d]",
-				win, pd->name, pd->priority);
+	pd->running_sh = _minictrl_dbus_sig_handle_attach(MINICTRL_DBUS_SIG_RUNNING_REQ, _running_req_cb, pd);
 
+	INFO("new minicontrol created - %s", pd->name);
 	return win;
 }
 
-EXPORT_API minicontrol_error_e minicontrol_request(Evas_Object *mincontrol, minicontrol_request_e request)
+EXPORT_API int minicontrol_request(Evas_Object *mincontrol, minicontrol_request_e request)
 {
-	struct _provider_data *pd;
+	struct _minicontrol_provider *pd;
 	int ret = MINICONTROL_ERROR_NONE;
+	minicontrol_event_e event;
 
 	if (!mincontrol) {
 		ERR("mincontrol is NULL, invaild parameter");
@@ -331,9 +478,32 @@ EXPORT_API minicontrol_error_e minicontrol_request(Evas_Object *mincontrol, mini
 	}
 
 	if (pd->state == MINICTRL_STATE_RUNNING) {
-		ret = _minictrl_provider_message_send(MINICTRL_DBUS_SIG_REQUEST,
-					pd->name, request, request, pd->priority);
+		switch(request) {
+		case MINICONTROL_REQ_HIDE_VIEWER :
+			event = MINICONTROL_EVENT_REQUEST_HIDE;
+			break;
+
+		case MINICONTROL_REQ_REPORT_VIEWER_ANGLE :
+			event = MINICONTROL_EVENT_REQUEST_ANGLE;
+			break;
+
+		case MINICONTROL_REQ_FREEZE_SCROLL_VIEWER :
+		case MINICONTROL_REQ_UNFREEZE_SCROLL_VIEWER :
+		case MINICONTROL_REQ_ROTATE_PROVIDER :
+			WARN("Could be not supported [%d]", request);
+			event = request;
+			break;
+
+		case MINICONTROL_REQ_NONE :
+		default :
+			ERR("Not supported request[%d]", request);
+			ret = MINICONTROL_ERROR_NOT_SUPPORTED;
+			goto out;
+		}
+
+		_minictrl_send_event(MINICTRL_DBUS_SIG_TO_VIEWER, pd->name, event, NULL);
 	}
-
+out:
 	return ret;
 }
+
diff --git a/src/minicontrol-viewer.c b/src/minicontrol-viewer.c
index 87e4dd8..8205108 100755
--- a/src/minicontrol-viewer.c
+++ b/src/minicontrol-viewer.c
@@ -1,14 +1,14 @@
 /*
- * Copyright 2012  Samsung Electronics Co., Ltd
+ * Copyright (c)  2013-2015 Samsung Electronics Co., Ltd All Rights Reserved
  *
- * Licensed under the Flora License, Version 1.1 (the "License");
+ * 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://floralicense.org/license/
+ * 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,
+ * 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.
@@ -20,66 +20,183 @@
 #include "minicontrol-internal.h"
 #include "minicontrol-type.h"
 #include "minicontrol-viewer.h"
+#include "minicontrol-viewer-internal.h"
 #include "minicontrol-log.h"
 
 #define MINICTRL_PLUG_DATA_KEY "__minictrl_plug_name"
 
+struct _minicontrol_viewer {
+	minictrl_sig_handle *event_sh;
+	minicontrol_viewer_event_cb callback;
+	void *user_data;
+};
+
+static struct _minicontrol_viewer *g_minicontrol_viewer_h = NULL;
+
+EXPORT_API int minicontrol_viewer_send_event(const char *provider_app_id, minicontrol_viewer_event_e event, bundle *event_arg)
+{
+	int ret = MINICONTROL_ERROR_NONE;
+
+	if (provider_app_id == NULL) {
+		ERR("appid is NULL, invaild parameter");
+		return MINICONTROL_ERROR_INVALID_PARAMETER;
+	}
+
+	ret = _minictrl_send_event(MINICTRL_DBUS_SIG_TO_PROVIDER, provider_app_id, event, event_arg);
+
+	return ret;
+}
+
+
+static void _sig_to_viewer_handler_cb(void *data, DBusMessage *msg)
+{
+	DBusError err;
+	char *provider_app_id = 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, &provider_app_id,
+				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;
+	}
+
+	if (serialized_arg_length != 0) {
+		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, provider_app_id, event_arg_bundle, g_minicontrol_viewer_h->user_data);
+
+	bundle_free(event_arg_bundle);
+	dbus_error_free(&err);
+}
+
+
+EXPORT_API int minicontrol_viewer_set_event_cb(minicontrol_viewer_event_cb callback, void *data)
+{
+	if (!callback) {
+		ERR("MINICONTROL_ERROR_INVALID_PARAMETER");
+		return MINICONTROL_ERROR_INVALID_PARAMETER;
+	}
+
+	INFO("g_minicontrol_viewer_h [%p]", g_minicontrol_viewer_h);
+
+	if (g_minicontrol_viewer_h == NULL) {
+		minictrl_sig_handle *event_sh;
+		struct _minicontrol_viewer *minicontrol_viewer_h;
+
+		event_sh = _minictrl_dbus_sig_handle_attach(MINICTRL_DBUS_SIG_TO_VIEWER, _sig_to_viewer_handler_cb, NULL);
+		if (!event_sh) {
+			ERR("fail to _minictrl_dbus_sig_handle_attach - %s", MINICTRL_DBUS_SIG_TO_VIEWER);
+			return MINICONTROL_ERROR_IPC_FAILURE;
+		}
+
+		minicontrol_viewer_h = malloc(sizeof(struct _minicontrol_viewer));
+		if (!minicontrol_viewer_h) {
+			ERR("fail to alloc minicontrol_viewer_h");
+			_minictrl_dbus_sig_handle_dettach(event_sh);
+			return MINICONTROL_ERROR_OUT_OF_MEMORY;
+		}
+
+		minicontrol_viewer_h->event_sh = event_sh;
+		g_minicontrol_viewer_h = minicontrol_viewer_h;
+	}
+
+	g_minicontrol_viewer_h->callback = callback;
+	g_minicontrol_viewer_h->user_data = data;
+	INFO("callback[%p], data[%p]", callback, data);
+
+	return _minictrl_viewer_req_message_send();
+}
+
+EXPORT_API int minicontrol_viewer_unset_event_cb(void)
+{
+	if (!g_minicontrol_viewer_h)
+		return MINICONTROL_ERROR_NONE;
+
+	if (g_minicontrol_viewer_h->event_sh)
+		_minictrl_dbus_sig_handle_dettach(g_minicontrol_viewer_h->event_sh);
+
+	free(g_minicontrol_viewer_h);
+	g_minicontrol_viewer_h = NULL;
+
+	return MINICONTROL_ERROR_NONE;
+}
+
 static void _minictrl_plug_server_del(Ecore_Evas *ee)
 {
-	char *svr_name = NULL;
+	char *minicontrol_name = NULL;
 
-	svr_name = ecore_evas_data_get(ee, MINICTRL_PLUG_DATA_KEY);
-	if (!svr_name) {
-		ERR("fail to get svr_name");
+	minicontrol_name = ecore_evas_data_get(ee, MINICTRL_PLUG_DATA_KEY);
+	if (!minicontrol_name) {
+		ERR("fail to get minicontrol_name");
 		return;
 	}
 
-	INFO("server - %s is deleted", svr_name);
+	INFO("server - %s is deleted", minicontrol_name);
 
 	/* send message to remve plug */
-	_minictrl_provider_message_send(MINICTRL_DBUS_SIG_STOP,
-					svr_name, 0, 0,
-					MINICONTROL_PRIORITY_LOW);
+	_minictrl_provider_message_send(MINICONTROL_EVENT_STOP, minicontrol_name, 0, 0, MINICONTROL_PRIORITY_LOW);
+	_minictrl_provider_proc_send(MINICONTROL_DBUS_PROC_INCLUDE);
 }
 
-static void _minictrl_plug_del(void *data, Evas *e,
-			Evas_Object *obj, void *event_info)
+static void _minictrl_plug_del(void *data, Evas *e, Evas_Object *obj, void *event_info)
 {
 	Ecore_Evas *ee = NULL;
-	char *svr_name = NULL;
+	char *minicontrol_name = NULL;
 
 	ee = ecore_evas_ecore_evas_get(evas_object_evas_get(obj));
 	if (!ee)
 		return;
 
-	svr_name = ecore_evas_data_get(ee, MINICTRL_PLUG_DATA_KEY);
-	if (svr_name)
-		free(svr_name);
+	minicontrol_name = ecore_evas_data_get(ee, MINICTRL_PLUG_DATA_KEY);
+	if (minicontrol_name)
+		free(minicontrol_name);
 
 	ecore_evas_data_set(ee, MINICTRL_PLUG_DATA_KEY, NULL);
 }
 
-EXPORT_API
-Evas_Object *minicontrol_viewer_image_object_get(const Evas_Object *obj)
-{
-	return elm_plug_image_object_get(obj);
-}
-
-EXPORT_API Evas_Object *minicontrol_viewer_add(Evas_Object *parent,
-						const char *svr_name)
+EXPORT_API Evas_Object *minicontrol_viewer_add(Evas_Object *parent, const char *minicontrol_name)
 {
 	Evas_Object *plug = NULL;
 	Evas_Object *plug_img = NULL;
 	Ecore_Evas *ee = NULL;
 
+	if (parent == NULL || minicontrol_name == NULL) {
+		ERR("invalid parameter");
+		set_last_result(MINICONTROL_ERROR_INVALID_PARAMETER);
+		return NULL;
+	}
+
 	plug = elm_plug_add(parent);
+
 	if (!plug) {
 		ERR("fail to create plug");
+		set_last_result(MINICONTROL_ERROR_ELM_FAILURE);
 		return NULL;
 	}
 
-	if (!elm_plug_connect(plug, svr_name, 0, EINA_FALSE)) {
-		ERR("Cannot connect plug[%s]", svr_name);
+	if (!elm_plug_connect(plug, minicontrol_name, 0, EINA_TRUE)) {
+		ERR("Cannot connect plug[%s]", minicontrol_name);
+		set_last_result(MINICONTROL_ERROR_ELM_FAILURE);
 		evas_object_del(plug);
 		return NULL;
 	}
@@ -87,12 +204,63 @@ EXPORT_API Evas_Object *minicontrol_viewer_add(Evas_Object *parent,
 	plug_img = elm_plug_image_object_get(plug);
 
 	ee = ecore_evas_object_ecore_evas_get(plug_img);
-	ecore_evas_data_set(ee, MINICTRL_PLUG_DATA_KEY, strdup(svr_name));
+	ecore_evas_data_set(ee, MINICTRL_PLUG_DATA_KEY, strdup(minicontrol_name));
 	ecore_evas_callback_delete_request_set(ee, _minictrl_plug_server_del);
 
-	evas_object_event_callback_add(plug, EVAS_CALLBACK_DEL,
-					_minictrl_plug_del, plug);
+	evas_object_event_callback_add(plug, EVAS_CALLBACK_DEL,	_minictrl_plug_del, plug);
 
 	return plug;
 }
 
+EXPORT_API Evas_Object *minicontrol_viewer_image_object_get(const Evas_Object *obj)
+{
+	return elm_plug_image_object_get(obj);
+}
+
+EXPORT_API int minicontrol_viewer_request(const char *appid, minicontrol_request_e request, int value)
+{
+	int ret = MINICONTROL_ERROR_NONE;
+	minicontrol_viewer_event_e event  = 0;
+	bundle *event_arg_bundle = NULL;
+	char bundle_value_buffer[BUNDLE_BUFFER_LENGTH] = { 0, };
+
+	if (appid == NULL) {
+		ERR("appid is NULL, invaild parameter");
+		return MINICONTROL_ERROR_INVALID_PARAMETER;
+	}
+
+	switch(request) {
+	case MINICONTROL_REQ_ROTATE_PROVIDER: {
+		event = MINICONTROL_EVENT_REPORT_ANGLE;
+		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;
+		}
+
+		snprintf(bundle_value_buffer, BUNDLE_BUFFER_LENGTH, "%d", value);
+
+		bundle_add_str(event_arg_bundle, "angle", bundle_value_buffer);
+		break;
+	}
+	case MINICONTROL_REQ_NONE:
+	case MINICONTROL_REQ_HIDE_VIEWER:
+	case MINICONTROL_REQ_FREEZE_SCROLL_VIEWER:
+	case MINICONTROL_REQ_UNFREEZE_SCROLL_VIEWER:
+	case MINICONTROL_REQ_REPORT_VIEWER_ANGLE:
+	default :
+		ret = MINICONTROL_ERROR_INVALID_PARAMETER;
+		goto out;
+	}
+
+	_minictrl_send_event(MINICTRL_DBUS_SIG_TO_PROVIDER, appid, event, event_arg_bundle);
+
+out:
+	if (event_arg_bundle)
+		bundle_free(event_arg_bundle);
+
+	return ret;
+}
+