mmifw-ipc : following TIDL update, changes TIDL API(ver. 1.4->1.8)

Change-Id: Ied3d0b0a6d85c3caffbcbdc4ba0cdb96e631d2fa

diff --git a/src/mmifw-ipc.c b/src/mmifw-ipc.c
index 175d09654f4e2b5986bf6b0b723147600c49865c..c4902e9abac9e358acb61f23a7f1087a49a6ae77 100644 (file)
--- a/src/mmifw-ipc.c
+++ b/src/mmifw-ipc.c
@@ -37,14 +37,14 @@ static uid_t _uid = -1;
 static int _connected = 0;
 static mmi_state _state = MMI_STATE_NONE;
 
-rpc_port_mmifw_focus_event_cb_h focus_cb_h;
-rpc_port_mmifw_state_change_event_cb_h state_change_cb_h;
-rpc_port_mmifw_wakeup_event_cb_h wakeup_cb_h;
-rpc_port_mmifw_key_event_cb_h key_cb_h;
-rpc_port_mmifw_gesture_event_cb_h gesture_cb_h;
-rpc_port_mmifw_voice_event_cb_h voice_cb_h;
-rpc_port_mmifw_action_event_cb_h action_cb_h;
-rpc_port_mmifw_feedback_event_cb_h feedback_cb_h;
+rpc_port_proxy_mmifw_focus_event_cb_h focus_cb_h;
+rpc_port_proxy_mmifw_state_change_event_cb_h state_change_cb_h;
+rpc_port_proxy_mmifw_wakeup_event_cb_h wakeup_cb_h;
+rpc_port_proxy_mmifw_key_event_cb_h key_cb_h;
+rpc_port_proxy_mmifw_gesture_event_cb_h gesture_cb_h;
+rpc_port_proxy_mmifw_voice_event_cb_h voice_cb_h;
+rpc_port_proxy_mmifw_action_event_cb_h action_cb_h;
+rpc_port_proxy_mmifw_feedback_event_cb_h feedback_cb_h;
 
 rpc_port_proxy_mmifw_h
 mmi_ipc_get_rpc_h(void)
@@ -82,7 +82,7 @@ mmi_ipc_get_stub_appid(void)
        return _stub_appid;
 }
 
-static void _focus_event_cb(void *user_data, rpc_port_focus_event_h args)
+static void _focus_event_cb(void *user_data, rpc_port_proxy_focus_event_h args)
 {
        int r;
        mmifw_event_focus *ev = NULL;
@@ -95,21 +95,21 @@ static void _focus_event_cb(void *user_data, rpc_port_focus_event_h args)
                return;
        }
 
-       r = rpc_port_focus_event_get_type(args, &ev->type);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_focus_event_get_focus_in(args, &ev->focus_in);
        if (r)
        {
                LOGE("Failed to get focus_in (error:%d)\n", r);
@@ -123,7 +123,7 @@ err:
                free(ev);
 }
 
-static void _state_change_event_cb(void *user_data, rpc_port_state_change_event_h args)
+static void _state_change_event_cb(void *user_data, rpc_port_proxy_state_change_event_h args)
 {
        int r;
        mmifw_event_state_change *ev = NULL;
@@ -136,28 +136,28 @@ static void _state_change_event_cb(void *user_data, rpc_port_state_change_event_
                return;
        }
 
-       r = rpc_port_state_change_event_get_type(args, &ev->type);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_state_change_event_get_old_state(args, &ev->old_state);
        if (r)
        {
                LOGE("Failed to get old_state (error:%d)\n", r);
@@ -182,7 +182,7 @@ _wakeup_event_free(void *data, void *ev)
        free(e);
 }
 
-static void _wakeup_event_cb(void *user_data, rpc_port_wakeup_event_h args)
+static void _wakeup_event_cb(void *user_data, rpc_port_proxy_wakeup_event_h args)
 {
        int r;
        mmifw_event_wakeup *ev = NULL;
@@ -195,21 +195,21 @@ static void _wakeup_event_cb(void *user_data, rpc_port_wakeup_event_h args)
                return;
        }
 
-       r = rpc_port_wakeup_event_get_type(args, &ev->type);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_wakeup_event_get_source(args, &ev->source);
        if (r)
        {
                LOGE("Failed to get source (error:%d)\n", r);
@@ -235,7 +235,7 @@ _key_event_free(void *data, void *ev)
        free(e);
 }
 
-static void _key_event_cb(void *user_data, rpc_port_key_event_h args)
+static void _key_event_cb(void *user_data, rpc_port_proxy_key_event_h args)
 {
        int r;
        mmifw_event_key *ev = NULL;
@@ -248,42 +248,42 @@ static void _key_event_cb(void *user_data, rpc_port_key_event_h args)
                return;
        }
 
-       r = rpc_port_key_event_get_type(args, &ev->type);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_key_event_get_source(args, &ev->source);
        if (r)
        {
                LOGE("Failed to get source (error:%d)\n", r);
@@ -307,7 +307,7 @@ _gesture_event_free(void *data, void *ev)
         free(e);
 }
 
-static void _gesture_event_cb(void *user_data, rpc_port_gesture_event_h args)
+static void _gesture_event_cb(void *user_data, rpc_port_proxy_gesture_event_h args)
 {
        int r;
        mmifw_event_gesture *ev = NULL;
@@ -320,21 +320,21 @@ static void _gesture_event_cb(void *user_data, rpc_port_gesture_event_h args)
                return;
        }
 
-       r = rpc_port_gesture_event_get_type(args, &ev->type);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_gesture_event_get_source(args, &ev->source);
        if (r)
        {
                LOGE("Failed to get source (error:%d)\n", r);
@@ -358,7 +358,7 @@ _voice_event_free(void *data, void *ev)
         free(e);
 }
 
-static void _voice_event_cb(void *user_data, rpc_port_voice_event_h args)
+static void _voice_event_cb(void *user_data, rpc_port_proxy_voice_event_h args)
 {
        int r;
        mmifw_event_voice *ev = NULL;
@@ -371,21 +371,21 @@ static void _voice_event_cb(void *user_data, rpc_port_voice_event_h args)
                return;
        }
 
-       r = rpc_port_voice_event_get_type(args, &ev->type);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_voice_event_get_source(args, &ev->source);
        if (r)
        {
                LOGE("Failed to get source (error:%d)\n", r);
@@ -418,11 +418,12 @@ _action_event_free(void *data, void *ev)
        free(e);
 }
 
-static void _action_event_cb(void *user_data, rpc_port_action_event_h ev_args)
+static void _action_event_cb(void *user_data, rpc_port_proxy_action_event_h ev_args)
 {
        int r;
        int args_size;
        mmifw_event_action *ev = NULL;
+       rpc_port_proxy_array_string_h array_string_h;
 
        ev = (mmifw_event_action *)calloc(1, sizeof(mmifw_event_action));
 
@@ -432,38 +433,45 @@ static void _action_event_cb(void *user_data, rpc_port_action_event_h ev_args)
                return;
        }
 
-       r = rpc_port_action_event_get_type(ev_args, &ev->type);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_action_event_get_args(ev_args, &array_string_h);
        if (r)
        {
-               LOGE("Failed to get cmd (error:%d)\n", r);
+               LOGE("Failed to get array_string_h ! (error:%d)\n", r);
+               goto err;
+       }
+
+       r = rpc_port_proxy_array_string_get(array_string_h, &ev->args, &args_size);
+       if (r)
+       {
+               LOGE("Failed to get array string (error:%d)\n", r);
                goto err;
        }
 
@@ -473,7 +481,7 @@ static void _action_event_cb(void *user_data, rpc_port_action_event_h ev_args)
                goto err;
        }
 
-       r = rpc_port_action_event_get_source(ev_args, &ev->source);
+       r = rpc_port_proxy_action_event_get_source(ev_args, &ev->source);
        if (r)
        {
                LOGE("Failed to get source (error:%d)\n", r);
@@ -485,6 +493,8 @@ static void _action_event_cb(void *user_data, rpc_port_action_event_h ev_args)
 err:
        if (ev)
                _action_event_free(NULL, ev);
+       if (array_string_h)
+               rpc_port_proxy_array_string_destroy(array_string_h);
 }
 
 static void
@@ -499,7 +509,7 @@ _feedback_event_free(void *data, void *ev)
        free(e);
 }
 
-static void _feedback_event_cb(void *user_data, rpc_port_feedback_event_h args)
+static void _feedback_event_cb(void *user_data, rpc_port_proxy_feedback_event_h args)
 {
        int r;
        mmifw_event_feedback *ev = NULL;
@@ -512,28 +522,28 @@ static void _feedback_event_cb(void *user_data, rpc_port_feedback_event_h args)
                return;
        }
 
-       r = rpc_port_feedback_event_get_type(args, &ev->type);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_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);
+       r = rpc_port_proxy_feedback_event_get_comment(args, &ev->comment);
        if (r)
        {
                LOGE("Failed to get comment (error:%d)\n", r);
@@ -560,14 +570,77 @@ static void _on_connected(rpc_port_proxy_mmifw_h h, void *user_data)
                return;
        }
 
-       focus_cb_h = rpc_port_mmifw_focus_event_cb_create(_focus_event_cb, false, NULL);
-       state_change_cb_h = rpc_port_mmifw_state_change_event_cb_create(_state_change_event_cb, false, NULL);
-       wakeup_cb_h = rpc_port_mmifw_wakeup_event_cb_create(_wakeup_event_cb, false, NULL);
-       key_cb_h = rpc_port_mmifw_key_event_cb_create(_key_event_cb, false, NULL);
-       gesture_cb_h = rpc_port_mmifw_gesture_event_cb_create(_gesture_event_cb, false, NULL);
-       voice_cb_h = rpc_port_mmifw_voice_event_cb_create(_voice_event_cb, false, NULL);
-       action_cb_h = rpc_port_mmifw_action_event_cb_create(_action_event_cb, false, NULL);
-       feedback_cb_h = rpc_port_mmifw_feedback_event_cb_create(_feedback_event_cb, false, NULL);
+       r = rpc_port_proxy_mmifw_focus_event_cb_create(&focus_cb_h);
+       if (r)
+       {
+               LOGE("Failed to create focus callback handle (error:%d)\n", r);
+               goto err;
+       }
+       rpc_port_proxy_mmifw_focus_event_cb_set_callback(focus_cb_h, _focus_event_cb, NULL);
+       rpc_port_proxy_mmifw_focus_event_cb_set_once(focus_cb_h, false);
+
+       r = rpc_port_proxy_mmifw_state_change_event_cb_create(&state_change_cb_h);
+       if (r)
+       {
+               LOGE("Failed to create state callback handle (error:%d)\n", r);
+               goto err;
+       }
+       rpc_port_proxy_mmifw_state_change_event_cb_set_callback(state_change_cb_h, _state_change_event_cb, NULL);
+       rpc_port_proxy_mmifw_state_change_event_cb_set_once(state_change_cb_h, false);
+
+       r = rpc_port_proxy_mmifw_wakeup_event_cb_create(&wakeup_cb_h);
+       if (r)
+       {
+               LOGE("Failed to create callback handle (error:%d)\n", r);
+               goto err;
+       }
+       rpc_port_proxy_mmifw_wakeup_event_cb_set_callback(wakeup_cb_h, _wakeup_event_cb, NULL);
+       rpc_port_proxy_mmifw_wakeup_event_cb_set_once(wakeup_cb_h, false);
+
+       r = rpc_port_proxy_mmifw_key_event_cb_create(&key_cb_h);
+       if (r)
+       {
+               LOGE("Failed to create callback handle (error:%d)\n", r);
+               goto err;
+       }
+       rpc_port_proxy_mmifw_key_event_cb_set_callback(key_cb_h, _key_event_cb, NULL);
+       rpc_port_proxy_mmifw_key_event_cb_set_once(key_cb_h, false);
+
+       r = rpc_port_proxy_mmifw_gesture_event_cb_create(&gesture_cb_h);
+       if (r)
+       {
+               LOGE("Failed to create callback handle (error:%d)\n", r);
+               goto err;
+       }
+       rpc_port_proxy_mmifw_gesture_event_cb_set_callback(gesture_cb_h, _gesture_event_cb, NULL);
+       rpc_port_proxy_mmifw_gesture_event_cb_set_once(gesture_cb_h, false);
+
+       r = rpc_port_proxy_mmifw_voice_event_cb_create(&voice_cb_h);
+       if (r)
+       {
+               LOGE("Failed to create callback handle (error:%d)\n", r);
+               goto err;
+       }
+       rpc_port_proxy_mmifw_voice_event_cb_set_callback(voice_cb_h, _voice_event_cb, NULL);
+       rpc_port_proxy_mmifw_voice_event_cb_set_once(voice_cb_h, false);
+
+       r = rpc_port_proxy_mmifw_action_event_cb_create(&action_cb_h);
+       if (r)
+       {
+               LOGE("Failed to create callback handle (error:%d)\n", r);
+               goto err;
+       }
+       rpc_port_proxy_mmifw_action_event_cb_set_callback(action_cb_h, _action_event_cb, NULL);
+       rpc_port_proxy_mmifw_action_event_cb_set_once(action_cb_h, false);
+
+       r = rpc_port_proxy_mmifw_feedback_event_cb_create(&feedback_cb_h);
+       if (r)
+       {
+               LOGE("Failed to create callback handle (error:%d)\n", r);
+               goto err;
+       }
+       rpc_port_proxy_mmifw_feedback_event_cb_set_callback(feedback_cb_h, _feedback_event_cb, NULL);
+       rpc_port_proxy_mmifw_feedback_event_cb_set_once(feedback_cb_h, false);
 
        if (!focus_cb_h || !state_change_cb_h || !wakeup_cb_h || !key_cb_h
                || !gesture_cb_h || !voice_cb_h || !action_cb_h || !feedback_cb_h)
@@ -595,6 +668,22 @@ static void _on_connected(rpc_port_proxy_mmifw_h h, void *user_data)
 err:
        if (ev)
                free(ev);
+       if (focus_cb_h)
+               rpc_port_proxy_mmifw_focus_event_cb_destroy(focus_cb_h);
+       if (state_change_cb_h)
+               rpc_port_proxy_mmifw_state_change_event_cb_destroy(state_change_cb_h);
+       if (wakeup_cb_h)
+               rpc_port_proxy_mmifw_wakeup_event_cb_destroy(wakeup_cb_h);
+       if (key_cb_h)
+               rpc_port_proxy_mmifw_key_event_cb_destroy(key_cb_h);
+       if (gesture_cb_h)
+               rpc_port_proxy_mmifw_gesture_event_cb_destroy(gesture_cb_h);
+       if (voice_cb_h)
+               rpc_port_proxy_mmifw_voice_event_cb_destroy(voice_cb_h);
+       if (action_cb_h)
+               rpc_port_proxy_mmifw_action_event_cb_destroy(action_cb_h);
+       if (feedback_cb_h)
+               rpc_port_proxy_mmifw_feedback_event_cb_destroy(feedback_cb_h);
 }
 
 static void _on_disconnected(rpc_port_proxy_mmifw_h h, void *user_data)