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 80eb6337236242565a075547201397870205ac4e..32b27a0f662f254d3c441e6607e055074e90e27e 100644 (file)
--- 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 02ba8e88b56b12eea4af5f41efcec603aeb20f1b..de5b96646d1e25338b55dbeab29c05d545ad2515 100644 (file)
--- 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