e_keyrouter: process keygrab_list_set/unset in input thread

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

diff --git a/src/bin/inputmgr/e_input_thread_client_intern.h b/src/bin/inputmgr/e_input_thread_client_intern.h
index e7b81632c8560126a3b568362af89f7a85defb9f..ff74b075a4f8b580eb6f9a4b6de5bfe597792aa8 100644 (file)
--- a/src/bin/inputmgr/e_input_thread_client_intern.h
+++ b/src/bin/inputmgr/e_input_thread_client_intern.h
@@ -33,6 +33,7 @@ typedef struct
   struct wl_resource *surface;
   uint32_t key;
   uint32_t mode;
+  Eina_Bool priv_result;
 } E_Input_Thread_Request_Keygrab_Data;
 
 typedef struct

diff --git a/src/bin/inputmgr/e_keyrouter_intern.h b/src/bin/inputmgr/e_keyrouter_intern.h
index 8a7c69c34ee1ca40f8a77a7ca93f66834af0d3a2..25b8954a58fa6aa5c09944942117e4c4c7eafe22 100644 (file)
--- a/src/bin/inputmgr/e_keyrouter_intern.h
+++ b/src/bin/inputmgr/e_keyrouter_intern.h
@@ -178,7 +178,7 @@ EINTERN void e_keyrouter_conf_deinit(E_Keyrouter_Config_Data *kconfig);
 EINTERN int e_keyrouter_cb_picture_off(const int option, void *data);
 
 EINTERN int e_keyrouter_keygrab_set(struct wl_client *client, struct wl_resource *surface, int key, int mode);
-EINTERN int e_keyrouter_keygrab_unset(struct wl_client *client, struct wl_resource *surface, int key);
+EINTERN int e_keyrouter_keygrab_unset(struct wl_client *client, struct wl_resource *surface, int key, Eina_Bool privilege_result);
 
 EINTERN Eina_Bool e_keyrouter_event_process(void *event, E_Device *dev, int type);
 

diff --git a/src/bin/inputmgr/e_keyrouter_list.c b/src/bin/inputmgr/e_keyrouter_list.c
index 699d726355dfd2681f693e331ab1cf7957995020..3044006d246dff83fb5a88c040edaba8912b1da6 100644 (file)
--- a/src/bin/inputmgr/e_keyrouter_list.c
+++ b/src/bin/inputmgr/e_keyrouter_list.c
@@ -497,14 +497,6 @@ e_keyrouter_keygrab_set(struct wl_client *client, struct wl_resource *surface, i
 {
    int res=0;
 
-#ifdef HAVE_CYNARA
-   if (EINA_FALSE == e_keyrouter_wl_util_do_privilege_check(client, mode, key))
-     {
-        KLINF("No permission for %d grab mode ! (key=%d)", mode, key);
-        return TIZEN_KEYROUTER_ERROR_NO_PERMISSION;
-     }
-#endif
-
    if (!surface)
      {
         /* Regarding topmost mode, a client must request to grab a key with a valid surface. */
@@ -538,9 +530,8 @@ e_keyrouter_keygrab_set(struct wl_client *client, struct wl_resource *surface, i
 }
 
 int
-e_keyrouter_keygrab_unset(struct wl_client *client, struct wl_resource *surface, int key)
+e_keyrouter_keygrab_unset(struct wl_client *client, struct wl_resource *surface, int key, Eina_Bool privilege_result)
 {
-
    /* Check the given key range */
    if (krt->max_tizen_hwkeys < key)
      {
@@ -563,7 +554,7 @@ e_keyrouter_keygrab_unset(struct wl_client *client, struct wl_resource *surface,
      e_keyrouter_find_and_remove_client_from_list(surface, client, key, TIZEN_KEYROUTER_MODE_TOPMOST);
 
 #ifdef HAVE_CYNARA
-   if (EINA_FALSE == e_keyrouter_wl_util_do_privilege_check(client, TIZEN_KEYROUTER_MODE_NONE, key))
+   if (EINA_FALSE == privilege_result)
      {
         goto finish;
      }

diff --git a/src/bin/server/e_keyrouter_wl.c b/src/bin/server/e_keyrouter_wl.c
index 42ff97fb7469252856c9c2588a67a3af5859d4f7..5c3efc95f931f564e10ffe2c5cd0e2faa19d40e0 100644 (file)
--- a/src/bin/server/e_keyrouter_wl.c
+++ b/src/bin/server/e_keyrouter_wl.c
@@ -264,6 +264,15 @@ _e_keyrouter_cb_keygrab_set(struct wl_client *client, struct wl_resource *resour
 {
    TRACE_INPUT_BEGIN(_e_keyrouter_cb_keygrab_set);
 
+#ifdef HAVE_CYNARA
+   if (EINA_FALSE == e_keyrouter_wl_util_do_privilege_check(client, mode, key))
+     {
+        KLINF("No permission for %d grab mode ! (key=%d)", mode, key);
+        tizen_keyrouter_send_keygrab_notify(resource, surface, key, mode, TIZEN_KEYROUTER_ERROR_NO_PERMISSION);
+        return;
+     }
+#endif
+
    E_Input_Thread_Request_Keygrab_Data keygrab_data;
 
    keygrab_data.resource = resource;
@@ -283,7 +292,7 @@ _e_keyrouter_input_thread_keygrab_unset(void *data)
    E_Input_Thread_Request_Keygrab_Data *keygrab_data = data;
    EINA_SAFETY_ON_NULL_RETURN(keygrab_data);
 
-   res = e_keyrouter_keygrab_unset(keygrab_data->client, keygrab_data->surface, keygrab_data->key);
+   res = e_keyrouter_keygrab_unset(keygrab_data->client, keygrab_data->surface, keygrab_data->key, keygrab_data->priv_result);
 
    TRACE_INPUT_END();
 
@@ -312,6 +321,7 @@ _e_keyrouter_cb_keygrab_unset(struct wl_client *client, struct wl_resource *reso
    keygrab_data.client = client;
    keygrab_data.key = key;
    keygrab_data.mode = TIZEN_KEYROUTER_MODE_NONE; /* UNUSED */
+   keygrab_data.priv_result = e_keyrouter_wl_util_do_privilege_check(client, TIZEN_KEYROUTER_MODE_NONE, key);
 
    INF("client: %p, surface: %p, key: %d\n", keygrab_data.client, keygrab_data.surface, keygrab_data.key);
    e_input_backend_thread_safe_call(_e_keyrouter_input_thread_keygrab_unset, &keygrab_data, sizeof(E_Input_Thread_Request_Keygrab_Data));
@@ -334,12 +344,71 @@ _e_keyrouter_cb_get_keygrab_status(struct wl_client *client, struct wl_resource
    tizen_keyrouter_send_keygrab_notify(resource, surface, key, mode, TIZEN_KEYROUTER_ERROR_NONE);
 }
 
+static void
+_e_keyrouter_input_thread_keygrab_set_list(void *data)
+{
+   unsigned int len = 0;
+   unsigned int pos = 0;
+   E_Keyrouter_Grab_Request grab_request;
+   struct wl_array grab_list;
+   int *grab_data = NULL;
+   int res;
+   E_Input_Thread_Request_Keygrab_Data keygrab_data;
+
+   memcpy(&keygrab_data, data, sizeof(E_Input_Thread_Request_Keygrab_Data));
+   pos += sizeof(E_Input_Thread_Request_Keygrab_Data);
+
+   memcpy(&len, data+pos, sizeof(unsigned int));
+   pos += sizeof(unsigned int);
+
+   INF("client(%p), resource(%p), surface(%p), len(%d)", keygrab_data.client, keygrab_data.resource, keygrab_data.surface, len);
+
+   wl_array_init(&grab_list);
+
+   for (unsigned int i = 0; i < len; i++)
+     {
+        memcpy(&grab_request, data+pos, sizeof(E_Keyrouter_Grab_Request));
+        pos += sizeof(E_Keyrouter_Grab_Request);
+
+        INF("[%s] mode: %d, key : %d, err: %d", __func__, grab_request.mode, grab_request.key, grab_request.err);
+
+        if (grab_request.err == TIZEN_KEYROUTER_ERROR_NONE)
+          {
+             res = e_keyrouter_keygrab_set(keygrab_data.client, keygrab_data.surface, grab_request.key, grab_request.mode);
+             grab_request.err = res;
+
+             if (res == TIZEN_KEYROUTER_ERROR_NONE)
+               KLDBG("Success to %d key %s grab using list(wl_client: %p, wl_surface: %p, pid: %d)",
+                     grab_request.key, e_keyrouter_mode_to_string(grab_request.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 using list(wl_client: %p, wl_surface: %p, pid: %d): res: %d",
+                     grab_request.key, e_keyrouter_mode_to_string(grab_request.mode),
+                     keygrab_data.client, keygrab_data.surface, e_keyrouter_util_get_pid(keygrab_data.client, keygrab_data.surface), grab_request.err);
+          }
+
+        grab_data = wl_array_add(&grab_list, sizeof(int));
+        *grab_data = grab_request.key;
+        grab_data = wl_array_add(&grab_list, sizeof(int));
+        *grab_data = grab_request.mode;
+        grab_data = wl_array_add(&grab_list, sizeof(int));
+        *grab_data = grab_request.err;
+     }
+
+   tizen_keyrouter_send_keygrab_notify_list(keygrab_data.resource, keygrab_data.surface, &grab_list);
+
+   e_input_wl_events_flush();
+
+   wl_array_release(&grab_list);
+}
+
 static void
 _e_keyrouter_cb_keygrab_set_list(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surface, struct wl_array *grab_list)
 {
    E_Keyrouter_Grab_Request *grab_request = NULL;
-   int res = TIZEN_KEYROUTER_ERROR_NONE;
+   E_Input_Thread_Request_Keygrab_Data keygrab_data;
    int array_len = 0;
+   unsigned pos = 0;
 
    TRACE_INPUT_BEGIN(_e_keyrouter_cb_keygrab_set_list);
 
@@ -354,30 +423,109 @@ _e_keyrouter_cb_keygrab_set_list(struct wl_client *client, struct wl_resource *r
         return;
      }
 
+   unsigned int list_count = array_len / 3;
+   unsigned int data_size = sizeof(E_Input_Thread_Request_Keygrab_Data)+sizeof(unsigned int)+sizeof(E_Keyrouter_Grab_Request)*list_count;
+   void *data = calloc(1, data_size);
+   if (!data)
+     {
+        KLWRN("Failed to allocate memory");
+        TRACE_INPUT_END();
+        return;
+     }
+
+   memset(&keygrab_data, 0, sizeof(E_Input_Thread_Request_Keygrab_Data));
+   keygrab_data.client = client;
+   keygrab_data.resource = resource;
+   keygrab_data.surface = surface;
+
+   memcpy(data, &keygrab_data, sizeof(E_Input_Thread_Request_Keygrab_Data));
+   pos += sizeof(E_Input_Thread_Request_Keygrab_Data);
+
+   memcpy(data+pos, &list_count, sizeof(unsigned int));
+   pos += sizeof(unsigned int);
+
+   INF("[%s] client(%p), resource(%p), surface(%p), len(%u), data_size(%u)", __func__, client, resource, surface, list_count, data_size);
+
    wl_array_for_each(grab_request, grab_list)
      {
-        res = e_keyrouter_keygrab_set(client, surface, grab_request->key, grab_request->mode);
-        grab_request->err = res;
+#ifdef HAVE_CYNARA
+        if (EINA_FALSE == e_keyrouter_wl_util_do_privilege_check(client, grab_request->mode, grab_request->key))
+          {
+             KLINF("No permission for %d grab mode ! (key=%d)", grab_request->mode, grab_request->key);
+             grab_request->err = TIZEN_KEYROUTER_ERROR_NO_PERMISSION;
+          }
+#endif
+        INF("[%s] mode: %d, key : %d, err: %d", __func__, grab_request->mode, grab_request->key, grab_request->err);
+        memcpy(data+pos, grab_request, sizeof(E_Keyrouter_Grab_Request));
+        pos += sizeof(E_Keyrouter_Grab_Request);
+     }
+
+   e_input_backend_thread_safe_call(_e_keyrouter_input_thread_keygrab_set_list, data, data_size);
+
+   free(data);
+
+   TRACE_INPUT_END();
+}
+
+static void
+_e_keyrouter_input_thread_keygrab_unset_list(void *data)
+{
+   unsigned int len = 0;
+   unsigned int pos = 0;
+   struct wl_array ungrab_list;
+   int *ungrab_data = NULL;
+   int res = TIZEN_KEYROUTER_ERROR_NONE;
+
+   E_Input_Thread_Request_Keygrab_Data keygrab_data;
+   E_Keyrouter_Ungrab_Request ungrab_request;
+
+   memcpy(&keygrab_data, data, sizeof(E_Input_Thread_Request_Keygrab_Data));
+   pos += sizeof(E_Input_Thread_Request_Keygrab_Data);
+
+   memcpy(&len, data+pos, sizeof(unsigned int));
+   pos += sizeof(unsigned int);
+
+   INF("client(%p), resource(%p), surface(%p), len(%d)", keygrab_data.client, keygrab_data.resource, keygrab_data.surface, len);
+
+   wl_array_init(&ungrab_list);
+
+   for (unsigned int i = 0; i < len; i++)
+     {
+        memcpy(&ungrab_request, data+pos, sizeof(E_Keyrouter_Ungrab_Request));
+        pos += sizeof(E_Keyrouter_Ungrab_Request);
+
+        INF("key : %d, err: %d", ungrab_request.key, ungrab_request.err);
+
+        res = e_keyrouter_keygrab_unset(keygrab_data.client, keygrab_data.surface, ungrab_request.key, ungrab_request.err == TIZEN_KEYROUTER_ERROR_NO_PERMISSION ? EINA_FALSE : EINA_TRUE);
+        ungrab_request.err = res;
         if (res == TIZEN_KEYROUTER_ERROR_NONE)
-          KLDBG("Success to %d key %s grab using list(wl_client: %p, wl_surface: %p, pid: %d)",
-                grab_request->key, e_keyrouter_mode_to_string(grab_request->mode),
-                client, surface, e_keyrouter_util_get_pid(client, surface));
+          KLDBG("Success to ungrab using list: %d key (wl_client: %p, wl_surface: %p, pid: %d)",
+                ungrab_request.key, 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 using list(wl_client: %p, wl_surface: %p, pid: %d): res: %d",
-                grab_request->key, e_keyrouter_mode_to_string(grab_request->mode),
-                client, surface, e_keyrouter_util_get_pid(client, surface), grab_request->err);
+          KLINF("Failed to ungrab using list: %d key (wl_client: %p, wl_surface: %p, pid: %d): res: %d",
+                ungrab_request.key, keygrab_data.client, keygrab_data.surface, e_keyrouter_util_get_pid(keygrab_data.client, keygrab_data.surface), ungrab_request.err);
+
+        ungrab_data = wl_array_add(&ungrab_list, sizeof(int));
+        *ungrab_data = ungrab_request.key;
+        ungrab_data = wl_array_add(&ungrab_list, sizeof(int));
+        *ungrab_data = ungrab_request.err;
      }
 
-   TRACE_INPUT_END();
-   tizen_keyrouter_send_keygrab_notify_list(resource, surface, grab_list);
+   tizen_keyrouter_send_keygrab_notify_list(keygrab_data.resource, keygrab_data.surface, &ungrab_list);
+
+   e_input_wl_events_flush();
+
+   wl_array_release(&ungrab_list);
 }
 
 static void
 _e_keyrouter_cb_keygrab_unset_list(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surface, struct wl_array *ungrab_list)
 {
    E_Keyrouter_Ungrab_Request *ungrab_request = NULL;
-   int res = TIZEN_KEYROUTER_ERROR_NONE;
+   E_Input_Thread_Request_Keygrab_Data keygrab_data;
+
    int array_len = 0;
+   unsigned int pos = 0;
 
    TRACE_INPUT_BEGIN(_e_keyrouter_cb_keygrab_unset_list);
 
@@ -392,20 +540,49 @@ _e_keyrouter_cb_keygrab_unset_list(struct wl_client *client, struct wl_resource
         return;
      }
 
+   unsigned int list_count = array_len / 2;
+   unsigned int data_size = sizeof(E_Input_Thread_Request_Keygrab_Data)+sizeof(unsigned int)+sizeof(E_Keyrouter_Ungrab_Request)*list_count;
+   void *data = calloc(1, data_size);
+   if (!data)
+     {
+        KLWRN("Failed to allocate memory");
+        TRACE_INPUT_END();
+        return;
+     }
+
+   memset(&keygrab_data, 0, sizeof(E_Input_Thread_Request_Keygrab_Data));
+   keygrab_data.client = client;
+   keygrab_data.resource = resource;
+   keygrab_data.surface = surface;
+
+   memcpy(data, &keygrab_data, sizeof(E_Input_Thread_Request_Keygrab_Data));
+   pos += sizeof(E_Input_Thread_Request_Keygrab_Data);
+
+   memcpy(data+pos, &list_count, sizeof(unsigned int));
+   pos += sizeof(unsigned int);
+
+   INF("[%s] client(%p), resource(%p), surface(%p), len(%u), data_size(%u)", __func__, client, resource, surface, list_count, data_size);
+
    wl_array_for_each(ungrab_request, ungrab_list)
      {
-        res = e_keyrouter_keygrab_unset(client, surface, ungrab_request->key);
-        ungrab_request->err = res;
-        if (res == TIZEN_KEYROUTER_ERROR_NONE)
-          KLDBG("Success to ungrab using list: %d key (wl_client: %p, wl_surface: %p, pid: %d)",
-                ungrab_request->key, client, surface, e_keyrouter_util_get_pid(client, surface));
-        else
-          KLINF("Failed to ungrab using list: %d key (wl_client: %p, wl_surface: %p, pid: %d): res: %d",
-                ungrab_request->key, client, surface, e_keyrouter_util_get_pid(client, surface), ungrab_request->err);
+#ifdef HAVE_CYNARA
+       if (EINA_FALSE == e_keyrouter_wl_util_do_privilege_check(client, TIZEN_KEYROUTER_MODE_NONE, ungrab_request->key))
+          {
+             KLINF("No permission for %d grab mode ! (key=%d)", TIZEN_KEYROUTER_MODE_NONE, ungrab_request->key);
+             ungrab_request->err = TIZEN_KEYROUTER_ERROR_NO_PERMISSION;
+          }
+#endif
+
+        INF("key : %d, err: %d", ungrab_request->key, ungrab_request->err);
+        memcpy(data+pos, ungrab_request, sizeof(E_Keyrouter_Ungrab_Request));
+        pos += sizeof(E_Keyrouter_Ungrab_Request);
      }
 
+   e_input_backend_thread_safe_call(_e_keyrouter_input_thread_keygrab_unset_list, data, data_size);
+
+   free(data);
+
    TRACE_INPUT_END();
-   tizen_keyrouter_send_keygrab_notify_list(resource, surface, ungrab_list);
 }
 
 static void