From: Sung-Jin Park <sj76.park@samsung.com>
Date: Mon, 12 Jul 2021 17:25:17 +0000 (+0900)
Subject: mmifw-ipc: implement callbacks to add/free mmifw events
X-Git-Tag: submit/tizen/20210914.042010~19
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=a1918d405fff721ecbaf46847246fc20257dba48;p=platform%2Fcore%2Fuifw%2Fmmi-framework.git

mmifw-ipc: implement callbacks to add/free mmifw events

Change-Id: I0fc0107954bf37d1069cb1be5bcaeadcf31e497b
Signed-off-by: Sung-Jin Park <sj76.park@samsung.com>
---

diff --git a/src/mmifw-ipc.c b/src/mmifw-ipc.c
index 80eb633..32b27a0 100644
--- a/src/mmifw-ipc.c
+++ b/src/mmifw-ipc.c
@@ -81,45 +81,468 @@ mmi_ipc_get_stub_appid(void)
 	return _stub_appid;
 }
 
-/* event callbacks */
 static void _focus_event_cb(void *user_data, rpc_port_focus_event_h args)
 {
-	//TODO : create event
+	int r;
+	mmifw_event_focus *ev = NULL;
+
+	ev = (mmifw_event_focus *)calloc(1, sizeof(mmifw_event_focus));
+
+	if (!ev)
+	{
+		LOGE("Failed to allocate memory focus event !\n");
+		return;
+	}
+
+	r = rpc_port_focus_event_get_type(args, &ev->type);
+	if (r)
+	{
+		LOGE("Failed to get type (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_focus_event_get_timestamp(args, &ev->timestamp);
+	if (r)
+	{
+		LOGE("Failed to get timestamp (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_focus_event_get_focus_in(args, &ev->focus_in);
+	if (r)
+	{
+		LOGE("Failed to get focus_in (error:%d)\n", r);
+		goto err;
+	}
+
+	ecore_event_add(MMI_EVENT_FOCUS, ev, NULL, user_data);
+	return;
+err:
+	if (ev)
+		free(ev);
 }
 
 static void _state_change_event_cb(void *user_data, rpc_port_state_change_event_h args)
 {
-	//TODO : create event
+	int r;
+	mmifw_event_state_change *ev = NULL;
+
+	ev = (mmifw_event_state_change *)calloc(1, sizeof(mmifw_event_state_change));
+
+	if (!ev)
+	{
+		LOGE("Failed to allocate memory state_change event !\n");
+		return;
+	}
+
+	r = rpc_port_state_change_event_get_type(args, &ev->type);
+	if (r)
+	{
+		LOGE("Failed to get type (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_state_change_event_get_timestamp(args, &ev->timestamp);
+	if (r)
+	{
+		LOGE("Failed to get timestamp (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_state_change_event_get_state(args, &ev->state);
+	if (r)
+	{
+		LOGE("Failed to get state (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_state_change_event_get_old_state(args, &ev->old_state);
+	if (r)
+	{
+		LOGE("Failed to get old_state (error:%d)\n", r);
+		goto err;
+	}
+
+	ecore_event_add(MMI_EVENT_STATE_CHANGE, ev, NULL, user_data);
+	return;
+err:
+	if (ev)
+		free(ev);
+}
+
+static void
+_wakeup_event_free(void *data, void *ev)
+{
+	mmifw_event_wakeup *e = (mmifw_event_wakeup *)ev;
+
+	if (e->source)
+		free(e->source);
+	free(e);
 }
 
 static void _wakeup_event_cb(void *user_data, rpc_port_wakeup_event_h args)
 {
-	//TODO : create event
+	int r;
+	mmifw_event_wakeup *ev = NULL;
+
+	ev = (mmifw_event_wakeup *)calloc(1, sizeof(mmifw_event_wakeup));
+
+	if (!ev)
+	{
+		LOGE("Failed to allocate memory wakeup event !\n");
+		return;
+	}
+
+	r = rpc_port_wakeup_event_get_type(args, &ev->type);
+	if (r)
+	{
+		LOGE("Failed to get type (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_wakeup_event_get_timestamp(args, &ev->timestamp);
+	if (r)
+	{
+		LOGE("Failed to get timestamp (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_wakeup_event_get_source(args, &ev->source);
+	if (r)
+	{
+		LOGE("Failed to get source (error:%d)\n", r);
+		goto err;
+	}
+
+	ecore_event_add(MMI_EVENT_WAKE_UP, ev, _wakeup_event_free, user_data);
+	return;
+err:
+	if (ev)
+		_wakeup_event_free(NULL, ev);
+}
+
+static void
+_key_event_free(void *data, void *ev)
+{
+	mmifw_event_key *e = (mmifw_event_key *)ev;
+
+	if (e->keyname)
+		free(e->keyname);
+	if (e->source)
+		free(e->source);
+	free(e);
 }
 
 static void _key_event_cb(void *user_data, rpc_port_key_event_h args)
 {
-	//TODO : create event
+	int r;
+	mmifw_event_key *ev = NULL;
+
+	ev = (mmifw_event_key *)calloc(1, sizeof(mmifw_event_key));
+
+	if (!ev)
+	{
+		LOGE("Failed to allocate memory key event !\n");
+		return;
+	}
+
+	r = rpc_port_key_event_get_type(args, &ev->type);
+	if (r)
+	{
+		LOGE("Failed to get type (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_key_event_get_timestamp(args, &ev->timestamp);
+	if (r)
+	{
+		LOGE("Failed to get timestamp (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_key_event_get_keycode(args, &ev->keycode);
+	if (r)
+	{
+		LOGE("Failed to get keycode (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_key_event_get_key_down(args, &ev->key_down);
+	if (r)
+	{
+		LOGE("Failed to get key_down (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_key_event_get_keyname(args, &ev->keyname);
+	if (r)
+	{
+		LOGE("Failed to get keyname (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_key_event_get_source(args, &ev->source);
+	if (r)
+	{
+		LOGE("Failed to get source (error:%d)\n", r);
+		goto err;
+	}
+
+	ecore_event_add(MMI_EVENT_KEY, ev, _key_event_free, user_data);
+	return;
+err:
+	if (ev)
+		_key_event_free(NULL, ev);
+}
+
+static void
+_gesture_event_free(void *data, void *ev)
+{
+        mmifw_event_gesture *e = (mmifw_event_gesture *)ev;
+
+        if (e->source)
+                free(e->source);
+        free(e);
 }
 
 static void _gesture_event_cb(void *user_data, rpc_port_gesture_event_h args)
 {
-	//TODO : create event
+	int r;
+	mmifw_event_gesture *ev = NULL;
+
+	ev = (mmifw_event_gesture *)calloc(1, sizeof(mmifw_event_gesture));
+
+	if (!ev)
+	{
+		LOGE("Failed to allocate memory gesture event !\n");
+		return;
+	}
+
+	r = rpc_port_gesture_event_get_type(args, &ev->type);
+	if (r)
+	{
+		LOGE("Failed to get type (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_gesture_event_get_timestamp(args, &ev->timestamp);
+	if (r)
+	{
+		LOGE("Failed to get timestamp (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_gesture_event_get_source(args, &ev->source);
+	if (r)
+	{
+		LOGE("Failed to get source (error:%d)\n", r);
+		goto err;
+	}
+
+	ecore_event_add(MMI_EVENT_GESTURE, ev, _gesture_event_free, user_data);
+	return;
+err:
+	if (ev)
+		_gesture_event_free(NULL, ev);
+}
+
+static void
+_voice_event_free(void *data, void *ev)
+{
+        mmifw_event_voice *e = (mmifw_event_voice *)ev;
+
+        if (e->source)
+                free(e->source);
+        free(e);
 }
 
 static void _voice_event_cb(void *user_data, rpc_port_voice_event_h args)
 {
-	//TODO : create event
+	int r;
+	mmifw_event_voice *ev = NULL;
+
+	ev = (mmifw_event_voice *)calloc(1, sizeof(mmifw_event_voice));
+
+	if (!ev)
+	{
+		LOGE("Failed to allocate memory voice event !\n");
+		return;
+	}
+
+	r = rpc_port_voice_event_get_type(args, &ev->type);
+	if (r)
+	{
+		LOGE("Failed to get type (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_voice_event_get_timestamp(args, &ev->timestamp);
+	if (r)
+	{
+		LOGE("Failed to get timestamp (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_voice_event_get_source(args, &ev->source);
+	if (r)
+	{
+		LOGE("Failed to get source (error:%d)\n", r);
+		goto err;
+	}
+
+	ecore_event_add(MMI_EVENT_VOICE, ev, _voice_event_free, user_data);
+	return;
+err:
+	if (ev)
+		_voice_event_free(NULL, ev);
 }
 
-static void _action_event_cb(void *user_data, rpc_port_action_event_h args)
+static void
+_action_event_free(void *data, void *ev)
 {
-	//TODO : create event
+	mmifw_event_action *e = (mmifw_event_action *)ev;
+
+	if (e->cmd)
+		free(e->cmd);
+	if (e->source)
+		free(e->source);
+	if (e->args)
+	{
+		for(int n = 0; n < e->nargs; ++n)
+			if (e->args[n])
+				free(e->args[n]);
+
+	}
+	free(e);
+}
+
+static void _action_event_cb(void *user_data, rpc_port_action_event_h ev_args)
+{
+	int r;
+	int args_size;
+	mmifw_event_action *ev = NULL;
+
+	ev = (mmifw_event_action *)calloc(1, sizeof(mmifw_event_action));
+
+	if (!ev)
+	{
+		LOGE("Failed to allocate memory action event !\n");
+		return;
+	}
+
+	r = rpc_port_action_event_get_type(ev_args, &ev->type);
+	if (r)
+	{
+		LOGE("Failed to get type (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_action_event_get_timestamp(ev_args, &ev->timestamp);
+	if (r)
+	{
+		LOGE("Failed to get timestamp (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_action_event_get_cmd(ev_args, &ev->cmd);
+	if (r)
+	{
+		LOGE("Failed to get cmd (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_action_event_get_nargs(ev_args, &ev->nargs);
+	if (r)
+	{
+		LOGE("Failed to get nargs (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_action_event_get_args(ev_args, &ev->args, &args_size);
+	if (r)
+	{
+		LOGE("Failed to get cmd (error:%d)\n", r);
+		goto err;
+	}
+
+	if (args_size != ev->nargs)
+	{
+		LOGE("Invalid args_size in event (args_size=%d, nargs=%d) !\n", args_size, ev->nargs);
+		goto err;
+	}
+
+	r = rpc_port_action_event_get_source(ev_args, &ev->source);
+	if (r)
+	{
+		LOGE("Failed to get source (error:%d)\n", r);
+		goto err;
+	}
+
+	ecore_event_add(MMI_EVENT_ACTION, ev, _action_event_free, user_data);
+	return;
+err:
+	if (ev)
+		_action_event_free(NULL, ev);
+}
+
+static void
+_feedback_event_free(void *data, void *ev)
+{
+	mmifw_event_feedback *e = (mmifw_event_feedback *)ev;
+
+	if (e->feedback)
+		free(e->feedback);
+	if (e->comment)
+		free(e->comment);
+	free(e);
 }
 
 static void _feedback_event_cb(void *user_data, rpc_port_feedback_event_h args)
 {
-	//TODO : create event
+	int r;
+	mmifw_event_feedback *ev = NULL;
+
+	ev = (mmifw_event_feedback *)calloc(1, sizeof(mmifw_event_feedback));
+
+	if (!ev)
+	{
+		LOGE("Failed to allocate memory feedback event !\n");
+		return;
+	}
+
+	r = rpc_port_feedback_event_get_type(args, &ev->type);
+	if (r)
+	{
+		LOGE("Failed to get type (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_feedback_event_get_timestamp(args, &ev->timestamp);
+	if (r)
+	{
+		LOGE("Failed to get timestamp (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_feedback_event_get_feedback(args, &ev->feedback);
+	if (r)
+	{
+		LOGE("Failed to get feedback (error:%d)\n", r);
+		goto err;
+	}
+
+	r = rpc_port_feedback_event_get_comment(args, &ev->comment);
+	if (r)
+	{
+		LOGE("Failed to get comment (error:%d)\n", r);
+		goto err;
+	}
+
+	ecore_event_add(MMI_EVENT_FEEDBACK, ev, _feedback_event_free, user_data);
+	return;
+err:
+	if (ev)
+		_feedback_event_free(NULL, ev);
 }
 
 static void _on_connected(rpc_port_proxy_mmifw_h h, void *user_data)
diff --git a/src/mmifw-ipc.h b/src/mmifw-ipc.h
index 02ba8e8..de5b966 100644
--- a/src/mmifw-ipc.h
+++ b/src/mmifw-ipc.h
@@ -24,7 +24,6 @@
 #ifndef __MMIFW_IPC_H__
 #define __MMIFW_IPC_H__
 
-#include  <rpc-port.h>
 #include "interface/mmifw_proxy.h"
 
 #ifdef __cplusplus