e_keyrouter: remove grab_key mutex

Change-Id: I3fb360fe5d7ac34ccb7c51e58274cacd2be1074e
Signed-off-by: Jihoon Kim <jihoon48.kim@samsung.com>

diff --git a/src/bin/e_input_intern.h b/src/bin/e_input_intern.h
index 5aa3e3e..8b8039b 100644 (file)
--- a/src/bin/e_input_intern.h
+++ b/src/bin/e_input_intern.h
@@ -31,6 +31,15 @@ typedef struct {
     unsigned int data_length;
 } E_Input_Thread_Request_Data;
 
+typedef struct
+{
+  struct wl_client *client;
+  struct wl_resource *resource;
+  struct wl_resource *surface;
+  uint32_t key;
+  uint32_t mode;
+} E_Input_Thread_Request_Keygrab_Data;
+
 struct _E_Input_Seat
 {
    const char *name;

diff --git a/src/bin/e_keyrouter.c b/src/bin/e_keyrouter.c
index ad530e0..b81cb59 100644 (file)
--- a/src/bin/e_keyrouter.c
+++ b/src/bin/e_keyrouter.c
@@ -156,8 +156,9 @@ _e_keyrouter_info_print(void *data, const char *log_path)
 }
 
 static void
-_e_keyrouter_keygrab_print(void *data, const char *log_path)
+_e_keyrouter_input_thread_keygrab_print(void *data)
 {
+   char *log_path = (char *)data;
    Eina_List *l;
    E_Keyrouter_Key_List_NodePtr kdata;
    E_Client *ec_focus;
@@ -167,8 +168,6 @@ _e_keyrouter_keygrab_print(void *data, const char *log_path)
    char *cmd_focus, *cmd, *keyname;
    FILE *log_fl;
 
-   (void) data;
-
    log_fl = fopen(log_path, "a");
    if (!log_fl)
      {
@@ -210,7 +209,6 @@ _e_keyrouter_keygrab_print(void *data, const char *log_path)
    fprintf(log_fl, "    ----- End -----\n\n");
 
    fprintf(log_fl, "    ----- Grabbed keys Info -----\n\n");
-   g_rec_mutex_lock(&krt->grab_key_mutex);
    for (i = 8; i <= krt->max_tizen_hwkeys; i++)
      {
         if (!krt->HardKeys[i].keycode) continue;
@@ -271,14 +269,18 @@ _e_keyrouter_keygrab_print(void *data, const char *log_path)
         fprintf(log_fl, "\n");
      }
 
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
-
    fprintf(log_fl, "    ----- End -----\n\n");
 
    fclose(log_fl);
    log_fl = NULL;
 }
 
+static void
+_e_keyrouter_keygrab_print(void *data EINA_UNUSED, const char *log_path)
+{
+   e_input_thread_safe_call(_e_keyrouter_input_thread_keygrab_print, (void *)log_path, strlen(log_path)+1);
+}
+
 static Eina_Bool
 _e_keyrouter_cb_key_down(void *data, int type, void *event)
 {
@@ -413,8 +415,6 @@ e_keyrouter_query_tizen_key_table(void)
    krt->HardKeys = E_NEW(E_Keyrouter_Grabbed_Key, kconf->max_keycode + 1);
    EINA_SAFETY_ON_NULL_RETURN_VAL(krt->HardKeys, EINA_FALSE);
 
-   g_rec_mutex_lock(&krt->grab_key_mutex);
-
    krt->numTizenHWKeys = kconf->num_keycode;
    krt->max_tizen_hwkeys = kconf->max_keycode;
 
@@ -448,8 +448,6 @@ e_keyrouter_query_tizen_key_table(void)
           }
      }
 
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
-
    if (e_comp_wl_input_keymap_cache_file_use_get() == EINA_FALSE)
      {
         KLINF("Server create a new cache file: %s", e_comp_wl_input_keymap_path_get(names));
@@ -658,8 +656,6 @@ e_keyrouter_init(void)
    krt = E_NEW(E_Keyrouter, 1);
    EINA_SAFETY_ON_NULL_GOTO(krt, err);
 
-   g_rec_mutex_init(&krt->grab_key_mutex);
-
    kconfig = E_NEW(E_Keyrouter_Config_Data, 1);
    EINA_SAFETY_ON_NULL_GOTO(kconfig, err);
 
@@ -726,7 +722,6 @@ e_keyrouter_shutdown(void)
 
    _e_keyrouter_deinit_handlers();
 
-   g_rec_mutex_lock(&krt->grab_key_mutex);
    for (i = 0; i <= krt->max_tizen_hwkeys; i++)
      {
         if (krt->HardKeys[i].keyname)
@@ -735,7 +730,6 @@ e_keyrouter_shutdown(void)
           E_FREE(keycode_data);
      }
    E_FREE(krt->HardKeys);
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
 
    EINA_LIST_FREE(krt->ignore_list, keycode_data)
      E_FREE(keycode_data);
@@ -759,8 +753,6 @@ e_keyrouter_shutdown(void)
         krt->longkey.timer = 0;
      }
 
-   g_rec_mutex_clear(&krt->grab_key_mutex);
-
    e_keyrouter_wl_shutdown();
 
    E_FREE(krt);
@@ -773,10 +765,8 @@ e_keyrouter_shutdown(void)
 
 void e_keyrouter_keygrab_list_lock()
 {
-   g_rec_mutex_lock(&krt->grab_key_mutex);
 }
 
 void e_keyrouter_keygrab_list_unlock()
 {
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
 }

diff --git a/src/bin/e_keyrouter_events.c b/src/bin/e_keyrouter_events.c
index 0e2a6d8..b5eac53 100644 (file)
--- a/src/bin/e_keyrouter_events.c
+++ b/src/bin/e_keyrouter_events.c
@@ -21,11 +21,8 @@ static Eina_Bool _e_keyrouter_check_top_visible_window(E_Client *ec_focus, int a
 static Eina_Bool
 _e_keyrouter_is_key_grabbed(int key)
 {
-   g_rec_mutex_lock(&krt->grab_key_mutex);
-
    if (!krt->HardKeys[key].keycode)
      {
-        g_rec_mutex_unlock(&krt->grab_key_mutex);
         return EINA_FALSE;
      }
    if (krt->HardKeys[key].excl_ptr ||
@@ -33,12 +30,9 @@ _e_keyrouter_is_key_grabbed(int key)
         krt->HardKeys[key].top_ptr ||
         krt->HardKeys[key].shared_ptr)
      {
-        g_rec_mutex_unlock(&krt->grab_key_mutex);
         return EINA_TRUE;
      }
 
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
-
    return EINA_FALSE;
 }
 
@@ -78,16 +72,11 @@ _e_keyrouter_event_routed_key_check(Ecore_Event_Key *ev, int type)
         return EINA_FALSE;
      }
 
-   g_rec_mutex_lock(&krt->grab_key_mutex);
-
    if (!krt->HardKeys[ev->keycode].keycode)
      {
-        g_rec_mutex_unlock(&krt->grab_key_mutex);
         return EINA_FALSE;
      }
 
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
-
    return EINA_TRUE;
 }
 
@@ -191,7 +180,6 @@ _e_keyrouter_key_cancel(int keycode)
    E_FREE(keyname);
    EINA_SAFETY_ON_NULL_GOTO(key_release, failed);
 
-   g_rec_mutex_lock(&krt->grab_key_mutex);
    press_ptr_list = krt->HardKeys[keycode].press_ptr;
    EINA_LIST_FREE(press_ptr_list, key_node_data)
      {
@@ -211,7 +199,6 @@ _e_keyrouter_key_cancel(int keycode)
      }
 
    krt->HardKeys[keycode].press_ptr = NULL;
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
 
    _e_keyrouter_key_free(key_cancel);
    _e_keyrouter_key_free(key_release);
@@ -527,7 +514,6 @@ _e_keyrouter_send_key_events(int type, Ecore_Event_Key *ev, E_Device *dev)
 
    if (krt->isPictureOffEnabled == 1)
      {
-        g_rec_mutex_lock(&krt->grab_key_mutex);
         Eina_List *pic_off_ptr_list = krt->HardKeys[keycode].pic_off_ptr;
         EINA_LIST_FOREACH(pic_off_ptr_list, l, key_node_data)
           {
@@ -545,7 +531,6 @@ _e_keyrouter_send_key_events(int type, Ecore_Event_Key *ev, E_Device *dev)
                   if(cmd) E_FREE(cmd);
                }
           }
-        g_rec_mutex_unlock(&krt->grab_key_mutex);
         return;
      }
 
@@ -582,7 +567,6 @@ _e_keyrouter_send_key_events_release(int type, Ecore_Event_Key *ev, E_Device *de
    E_Keyrouter_Event_Data *key_data = NULL;
 
    /* Deliver release  clean up pressed key list */
-   g_rec_mutex_lock(&krt->grab_key_mutex);
    Eina_List *press_ptr_list = krt->HardKeys[ev->keycode].press_ptr;
    EINA_LIST_FREE(press_ptr_list, key_node_data)
      {
@@ -648,7 +632,6 @@ _e_keyrouter_send_key_events_release(int type, Ecore_Event_Key *ev, E_Device *de
         E_FREE(key_node_data);
      }
    krt->HardKeys[ev->keycode].press_ptr = NULL;
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
 }
 
 static void
@@ -676,7 +659,6 @@ _e_keyrouter_send_key_events_press(int type, Ecore_Event_Key *ev, E_Device *dev)
         return;
      }
 
-   g_rec_mutex_lock(&krt->grab_key_mutex);
    Eina_List *excl_ptr_list = krt->HardKeys[keycode].excl_ptr;
    EINA_LIST_FOREACH(excl_ptr_list, l, key_node_data)
      {
@@ -693,13 +675,10 @@ _e_keyrouter_send_key_events_press(int type, Ecore_Event_Key *ev, E_Device *dev)
                       key_node_data->surface, key_node_data->wc, pid, pname ?: "Unknown");
              if(pname) E_FREE(pname);
              if(cmd) E_FREE(cmd);
-             g_rec_mutex_unlock(&krt->grab_key_mutex);
              return;
           }
      }
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
 
-   g_rec_mutex_lock(&krt->grab_key_mutex);
    Eina_List *or_excl_ptr = krt->HardKeys[keycode].or_excl_ptr;
    EINA_LIST_FOREACH(or_excl_ptr, l, key_node_data)
      {
@@ -716,16 +695,13 @@ _e_keyrouter_send_key_events_press(int type, Ecore_Event_Key *ev, E_Device *dev)
                      key_node_data->surface, key_node_data->wc, pid, pname ?: "Unknown");
              if(pname) E_FREE(pname);
              if(cmd) E_FREE(cmd);
-             g_rec_mutex_unlock(&krt->grab_key_mutex);
              return;
           }
      }
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
 
    // Top position grab must need a focus surface.
    if (surface_focus)
      {
-        g_rec_mutex_lock(&krt->grab_key_mutex);
         Eina_List *top_ptr_list = krt->HardKeys[keycode].top_ptr;
         EINA_LIST_FOREACH(top_ptr_list, l, key_node_data)
           {
@@ -745,7 +721,6 @@ _e_keyrouter_send_key_events_press(int type, Ecore_Event_Key *ev, E_Device *dev)
 
                        if(pname) E_FREE(pname);
                        if(cmd) E_FREE(cmd);
-                       g_rec_mutex_unlock(&krt->grab_key_mutex);
                        return;
                     }
                   krt->isWindowStackChanged = EINA_FALSE;
@@ -765,20 +740,15 @@ _e_keyrouter_send_key_events_press(int type, Ecore_Event_Key *ev, E_Device *dev)
 
                        if(pname) E_FREE(pname);
                        if(cmd) E_FREE(cmd);
-                       g_rec_mutex_unlock(&krt->grab_key_mutex);
                        return;
                     }
                   break;
                }
           }
-        g_rec_mutex_unlock(&krt->grab_key_mutex);
        goto need_shared;
      }
 
-   g_rec_mutex_lock(&krt->grab_key_mutex);
    shared_ptr_list = krt->HardKeys[keycode].shared_ptr;
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
-
    if (shared_ptr_list)
      {
 need_shared:
@@ -793,7 +763,6 @@ need_shared:
           }
         if (res)
           {
-             g_rec_mutex_lock(&krt->grab_key_mutex);
              shared_ptr_list = krt->HardKeys[keycode].shared_ptr;
              EINA_LIST_FOREACH(shared_ptr_list, l, key_node_data)
                {
@@ -818,7 +787,6 @@ need_shared:
                          }
                     }
                }
-             g_rec_mutex_unlock(&krt->grab_key_mutex);
           }
      }
 }
@@ -901,7 +869,6 @@ _e_keyrouter_check_top_visible_window(E_Client *ec_focus, int arr_idx)
           }
 
         /* TODO: Check this client is located inside a display boundary */
-        g_rec_mutex_lock(&krt->grab_key_mutex);
         Eina_List *top_ptr_list = krt->HardKeys[arr_idx].top_ptr;
         EINA_LIST_FOREACH_SAFE(top_ptr_list, l, l_next, key_node_data)
           {
@@ -912,14 +879,11 @@ _e_keyrouter_check_top_visible_window(E_Client *ec_focus, int arr_idx)
                        krt->HardKeys[arr_idx].top_ptr = eina_list_promote_list(krt->HardKeys[arr_idx].top_ptr, l);
                        KLDBG("Move a client(e_client: %p, wl_surface: %p) to first index of list(key: %d)",
                                 ec_top, key_node_data->surface, arr_idx);
-                       g_rec_mutex_unlock(&krt->grab_key_mutex);
                        return EINA_TRUE;
                     }
                }
           }
 
-        g_rec_mutex_unlock(&krt->grab_key_mutex);
-
         if (ec_top == ec_focus)
           {
              KLDBG("The e_client(%p) is a focus client", ec_top);

diff --git a/src/bin/e_keyrouter_list.c b/src/bin/e_keyrouter_list.c
index cf928f4..09a3889 100644 (file)
--- a/src/bin/e_keyrouter_list.c
+++ b/src/bin/e_keyrouter_list.c
@@ -21,13 +21,10 @@ e_keyrouter_set_keygrab_in_list(struct wl_resource *surface, struct wl_client *c
 
    if (mode == TIZEN_KEYROUTER_MODE_EXCLUSIVE)
      {
-        g_rec_mutex_lock(&krt->grab_key_mutex);
         if (krt->HardKeys[key].excl_ptr != NULL)
           {
-             g_rec_mutex_unlock(&krt->grab_key_mutex);
              return TIZEN_KEYROUTER_ERROR_GRABBED_ALREADY;
           }
-        g_rec_mutex_unlock(&krt->grab_key_mutex);
      }
 
    if (mode == TIZEN_KEYROUTER_MODE_TOPMOST)
@@ -54,11 +51,9 @@ _e_keyrouter_find_duplicated_client(struct wl_resource *surface, struct wl_clien
    Eina_List *keylist_ptr = NULL, *l = NULL;
    E_Keyrouter_Key_List_NodePtr key_node_data = NULL;
 
-   g_rec_mutex_lock(&krt->grab_key_mutex);
    switch(mode)
      {
       case TIZEN_KEYROUTER_MODE_EXCLUSIVE:
-         g_rec_mutex_unlock(&krt->grab_key_mutex);
          return TIZEN_KEYROUTER_ERROR_NONE;
 
       case TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE:
@@ -82,7 +77,6 @@ _e_keyrouter_find_duplicated_client(struct wl_resource *surface, struct wl_clien
          break;
       default:
          KLWRN("Unknown key(%d) and grab mode(%d)", key, mode);
-         g_rec_mutex_unlock(&krt->grab_key_mutex);
          return TIZEN_KEYROUTER_ERROR_INVALID_MODE;
      }
 
@@ -96,7 +90,6 @@ _e_keyrouter_find_duplicated_client(struct wl_resource *surface, struct wl_clien
                {
                   KLDBG("The key(%d) is already grabbed same mode(%s) on the same wl_surface %p",
                         key, e_keyrouter_mode_to_string(mode), surface);
-                  g_rec_mutex_unlock(&krt->grab_key_mutex);
                   return TIZEN_KEYROUTER_ERROR_GRABBED_ALREADY;
                }
           }
@@ -106,12 +99,10 @@ _e_keyrouter_find_duplicated_client(struct wl_resource *surface, struct wl_clien
                {
                   KLDBG("The key(%d) is already grabbed same mode(%s) on the same wl_client %p",
                         key, e_keyrouter_mode_to_string(mode), wc);
-                  g_rec_mutex_unlock(&krt->grab_key_mutex);
                   return TIZEN_KEYROUTER_ERROR_GRABBED_ALREADY;
                }
           }
      }
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
 
    return TIZEN_KEYROUTER_ERROR_NONE;
 }
@@ -126,7 +117,6 @@ _e_keyrouter_find_key_in_list(struct wl_resource *surface, struct wl_client *wc,
 
    EINA_SAFETY_ON_TRUE_RETURN_VAL(((!surface) && (!wc)), EINA_FALSE);
 
-   g_rec_mutex_lock(&krt->grab_key_mutex);
    list = _e_keyrouter_get_list(mode, key);
    if (!list)
      {
@@ -151,7 +141,6 @@ _e_keyrouter_find_key_in_list(struct wl_resource *surface, struct wl_client *wc,
      }
 
 end:
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
 
    return ret;
 }
@@ -179,8 +168,6 @@ e_keyrouter_prepend_to_keylist(struct wl_resource *surface, struct wl_client *wc
    new_keyptr->focused = focused;
    new_keyptr->status = E_KRT_CSTAT_ALIVE;
 
-   g_rec_mutex_lock(&krt->grab_key_mutex);
-
    switch(mode)
      {
       case TIZEN_KEYROUTER_MODE_EXCLUSIVE:
@@ -210,10 +197,8 @@ e_keyrouter_prepend_to_keylist(struct wl_resource *surface, struct wl_client *wc
       default:
          KLWRN("Unknown key(%d) and grab mode(%d)", key, mode);
          E_FREE(new_keyptr);
-         g_rec_mutex_unlock(&krt->grab_key_mutex);
          return TIZEN_KEYROUTER_ERROR_INVALID_MODE;
      }
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
 
    if (TIZEN_KEYROUTER_MODE_PRESSED != mode)
      {
@@ -240,11 +225,9 @@ e_keyrouter_find_and_remove_client_from_list(struct wl_resource *surface, struct
    Eina_List *l = NULL, *l_next = NULL;
    E_Keyrouter_Key_List_NodePtr key_node_data = NULL;
 
-   g_rec_mutex_lock(&krt->grab_key_mutex);
    list = _e_keyrouter_get_list(mode, key);
    if (!list)
      {
-        g_rec_mutex_unlock(&krt->grab_key_mutex);
         return;
      }
 
@@ -282,8 +265,6 @@ e_keyrouter_find_and_remove_client_from_list(struct wl_resource *surface, struct
              KLDBG("Remove a %s Mode Grabbed key(%d) by wc(%p)", e_keyrouter_mode_to_string(mode), key, wc);
           }
      }
-
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
 }
 
 void
@@ -295,8 +276,6 @@ e_keyrouter_remove_client_from_list(struct wl_resource *surface, struct wl_clien
 
    EINA_SAFETY_ON_TRUE_RETURN(((!surface) && (!wc)));
 
-   g_rec_mutex_lock(&krt->grab_key_mutex);
-
    for (i = 0; i <= krt->max_tizen_hwkeys; i++)
      {
         if (0 == krt->HardKeys[i].keycode) continue;
@@ -418,8 +397,6 @@ e_keyrouter_remove_client_from_list(struct wl_resource *surface, struct wl_clien
                }
           }
      }
-
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
 }
 
 int

diff --git a/src/bin/e_keyrouter_wl.c b/src/bin/e_keyrouter_wl.c
index e0cd239..0045bef 100644 (file)
--- a/src/bin/e_keyrouter_wl.c
+++ b/src/bin/e_keyrouter_wl.c
@@ -184,7 +184,6 @@ e_keyrouter_keycancel_send(struct wl_client *client, struct wl_resource *surface
 
    EINA_SAFETY_ON_NULL_RETURN(wc);
 
-   g_rec_mutex_lock(&krt->grab_key_mutex);
    press_ptr_list = krt->HardKeys[key].press_ptr;
    EINA_LIST_FOREACH(press_ptr_list, l, data)
      {
@@ -210,7 +209,6 @@ e_keyrouter_keycancel_send(struct wl_client *client, struct wl_resource *surface
                }
           }
      }
-   g_rec_mutex_unlock(&krt->grab_key_mutex);
 }
 
 static int
@@ -227,56 +225,94 @@ _e_keyrouter_wl_array_length(const struct wl_array *array)
    return count;
 }
 
-/* tizen_keyrouter_set_keygrab request handler */
 static void
-_e_keyrouter_cb_keygrab_set(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surface, uint32_t key, uint32_t mode)
+_e_keyrouter_input_thread_keygrab_set(void *data)
 {
    int res = 0;
 
+   E_Input_Thread_Request_Keygrab_Data keygrab_data;
+   memcpy(&keygrab_data, data, sizeof(E_Input_Thread_Request_Keygrab_Data));
+
    TRACE_INPUT_BEGIN(_e_keyrouter_cb_keygrab_set);
 
-   res = e_keyrouter_keygrab_set(client, surface, key, mode);
+   res = e_keyrouter_keygrab_set(keygrab_data.client, keygrab_data.surface, keygrab_data.key, keygrab_data.mode);
 
    TRACE_INPUT_END();
 
    if (res == TIZEN_KEYROUTER_ERROR_NONE)
      {
-        if (mode == TIZEN_KEYROUTER_MODE_EXCLUSIVE)
+        if (keygrab_data.mode == TIZEN_KEYROUTER_MODE_EXCLUSIVE)
           {
-             KLINF("Success to %d key %s grab request (wl_client: %p, wl_surface: %p, pid: %d)", key, e_keyrouter_mode_to_string(mode),
-                client, surface, e_keyrouter_util_get_pid(client, surface));
+             KLINF("Success to %d key %s grab request (wl_client: %p, wl_surface: %p, pid: %d)", keygrab_data.key, e_keyrouter_mode_to_string(keygrab_data.mode),
+                keygrab_data.client, keygrab_data.surface, e_keyrouter_util_get_pid(keygrab_data.client, keygrab_data.surface));
           }
         else
           {
-             KLDBG("Success to %d key %s grab request (wl_client: %p, wl_surface: %p, pid: %d)", key, e_keyrouter_mode_to_string(mode),
-                client, surface, e_keyrouter_util_get_pid(client, surface));
+             KLDBG("Success to %d key %s grab request (wl_client: %p, wl_surface: %p, pid: %d)", keygrab_data.key, e_keyrouter_mode_to_string(keygrab_data.mode),
+                keygrab_data.client, keygrab_data.surface, e_keyrouter_util_get_pid(keygrab_data.client, keygrab_data.surface));
           }
      }
    else
-     KLINF("Failed to %d key %s grab request (wl_client: %p, wl_surface: %p, pid: %d): res: %d", key, e_keyrouter_mode_to_string(mode),
-        client, surface, e_keyrouter_util_get_pid(client, surface), res);
-   tizen_keyrouter_send_keygrab_notify(resource, surface, key, mode, res);
+     KLINF("Failed to %d key %s grab request (wl_client: %p, wl_surface: %p, pid: %d): res: %d", keygrab_data.key, e_keyrouter_mode_to_string(keygrab_data.mode),
+        keygrab_data.client, keygrab_data.surface, e_keyrouter_util_get_pid(keygrab_data.client, keygrab_data.surface), res);
+
+   tizen_keyrouter_send_keygrab_notify(keygrab_data.resource, keygrab_data.surface, keygrab_data.key, keygrab_data.mode, res);
 }
 
-/* tizen_keyrouter unset_keygrab request handler */
+/* tizen_keyrouter_set_keygrab request handler */
 static void
-_e_keyrouter_cb_keygrab_unset(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surface, uint32_t key)
+_e_keyrouter_cb_keygrab_set(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surface, uint32_t key, uint32_t mode)
 {
-   int res = 0;
+   TRACE_INPUT_BEGIN(_e_keyrouter_cb_keygrab_set);
 
-   TRACE_INPUT_BEGIN(_e_keyrouter_cb_keygrab_unset);
+   E_Input_Thread_Request_Keygrab_Data keygrab_data;
+
+   keygrab_data.resource = resource;
+   keygrab_data.surface = surface;
+   keygrab_data.client = client;
+   keygrab_data.key = key;
+   keygrab_data.mode = mode;
+
+   INF("client: %p, surface: %p, key: %d, mode: %d\n", keygrab_data.client, keygrab_data.surface, keygrab_data.key, keygrab_data.mode);
+   e_input_thread_safe_call(_e_keyrouter_input_thread_keygrab_set, &keygrab_data, sizeof(E_Input_Thread_Request_Keygrab_Data));
+}
 
-   res = e_keyrouter_keygrab_unset(client, surface, key);
+static void
+_e_keyrouter_input_thread_keygrab_unset(void *data)
+{
+   int res = 0;
+   E_Input_Thread_Request_Keygrab_Data keygrab_data;
+   memcpy(&keygrab_data, data, sizeof(E_Input_Thread_Request_Keygrab_Data));
+
+   res = e_keyrouter_keygrab_unset(keygrab_data.client, keygrab_data.surface, keygrab_data.key);
 
    TRACE_INPUT_END();
 
    if (res == TIZEN_KEYROUTER_ERROR_NONE)
-     KLDBG("Success to %d key ungrab request (wl_client: %p, wl_surface: %p, pid: %d)", key, client, surface,
-           e_keyrouter_util_get_pid(client, surface));
+     KLDBG("Success to %d key ungrab request (wl_client: %p, wl_surface: %p, pid: %d)", keygrab_data.key, keygrab_data.client, keygrab_data.surface,
+           e_keyrouter_util_get_pid(keygrab_data.client, keygrab_data.surface));
    else
-     KLINF("Failed to %d key ungrab request (wl_client: %p, wl_surface: %p, pid: %d): res: %d", key, client, surface,
-           e_keyrouter_util_get_pid(client, surface), res);
-   tizen_keyrouter_send_keygrab_notify(resource, surface, key, TIZEN_KEYROUTER_MODE_NONE, res);
+     KLINF("Failed to %d key ungrab request (wl_client: %p, wl_surface: %p, pid: %d): res: %d", keygrab_data.key, keygrab_data.client, keygrab_data.surface,
+           e_keyrouter_util_get_pid(keygrab_data.client, keygrab_data.surface), res);
+
+   tizen_keyrouter_send_keygrab_notify(keygrab_data.resource, keygrab_data.surface, keygrab_data.key, TIZEN_KEYROUTER_MODE_NONE, res);
+}
+
+/* tizen_keyrouter unset_keygrab request handler */
+static void
+_e_keyrouter_cb_keygrab_unset(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surface, uint32_t key)
+{
+   TRACE_INPUT_BEGIN(_e_keyrouter_cb_keygrab_unset);
+
+   E_Input_Thread_Request_Keygrab_Data keygrab_data;
+
+   keygrab_data.resource = resource;
+   keygrab_data.surface = surface;
+   keygrab_data.client = client;
+   keygrab_data.key = key;
+
+   INF("client: %p, surface: %p, key: %d, mode: %d\n", keygrab_data.client, keygrab_data.surface, keygrab_data.key, keygrab_data.mode);
+   e_input_thread_safe_call(_e_keyrouter_input_thread_keygrab_unset, &keygrab_data, sizeof(E_Input_Thread_Request_Keygrab_Data));
 }
 
 /* tizen_keyrouter get_keygrab_status request handler */
@@ -330,7 +366,6 @@ _e_keyrouter_cb_keygrab_set_list(struct wl_client *client, struct wl_resource *r
                 client, surface, e_keyrouter_util_get_pid(client, surface), grab_request->err);
      }
 
-
    TRACE_INPUT_END();
    tizen_keyrouter_send_keygrab_notify_list(resource, surface, grab_list);
 }

diff --git a/src/include/e_keyrouter.h b/src/include/e_keyrouter.h
index b62a762..03e4700 100644 (file)
--- a/src/include/e_keyrouter.h
+++ b/src/include/e_keyrouter.h
@@ -107,7 +107,7 @@ struct _E_Keyrouter
    E_Input_Event_Handler *_key_down_handler;
    E_Input_Event_Handler *_key_up_handler;
    EINA_DEPRECATED GMutex event_handler_mutex;
-   GRecMutex grab_key_mutex;
+   EINA_DEPRECATED GRecMutex grab_key_mutex;
 };
 
 struct _E_Keyrouter_Grab_Request {