key grab variables such as HardKeys[key].excl_ptr, or_excl_ptr, top_ptr can be updated
wherever _e_keyrouter_send_key_events_press() is executed in input thread.
Change-Id: I725acedbda32d6cc16d84dd86ccd228ff44daf8b
Signed-off-by: Jihoon Kim <jihoon48.kim@samsung.com>
fprintf(log_fl, "\n===== Keyrouter Information =====\n");
fprintf(log_fl, " ----- Grabbable Keys -----\n");
+
+ g_mutex_lock(&krt->grab_key_mutex);
for (i = 8; i <= krt->max_tizen_hwkeys; i++)
{
if (!krt->HardKeys[i].keycode) continue;
free(keyname);
keyname = NULL;
}
+ g_mutex_unlock(&krt->grab_key_mutex);
fprintf(log_fl, " ----- End -----\n\n");
fclose(log_fl);
fprintf(log_fl, " ----- End -----\n\n");
fprintf(log_fl, " ----- Grabbed keys Info -----\n\n");
+
+ g_mutex_lock(&krt->grab_key_mutex);
for (i = 8; i <= krt->max_tizen_hwkeys; i++)
{
if (!krt->HardKeys[i].keycode) continue;
fprintf(log_fl, "\n");
}
+ g_mutex_unlock(&krt->grab_key_mutex);
fprintf(log_fl, " ----- End -----\n\n");
krt->HardKeys = E_NEW(E_Keyrouter_Grabbed_Key, kconf->max_keycode + 1);
EINA_SAFETY_ON_NULL_RETURN_VAL(krt->HardKeys, EINA_FALSE);
+ g_mutex_lock(&krt->grab_key_mutex);
+
krt->numTizenHWKeys = kconf->num_keycode;
krt->max_tizen_hwkeys = kconf->max_keycode;
}
}
+ g_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));
EINA_SAFETY_ON_NULL_RETURN_VAL(krt, EINA_FALSE);
EINA_SAFETY_ON_FALSE_RETURN_VAL(keycode <= krt->max_tizen_hwkeys, EINA_FALSE);
+ g_mutex_lock(&krt->grab_key_mutex);
if (krt->HardKeys[keycode].longkey.enabled == EINA_TRUE)
{
KLWRN("The %d keycode'long press is already enabled by time: %lf\n", keycode, krt->HardKeys[keycode].longkey.time);
+ g_mutex_unlock(&krt->grab_key_mutex);
return EINA_FALSE;
}
krt->HardKeys[keycode].longkey.enabled = EINA_TRUE;
krt->HardKeys[keycode].longkey.time = time;
+ g_mutex_unlock(&krt->grab_key_mutex);
+
KLINF("To enable %d key's longkey function. (time: %lf)\n", keycode, time);
return EINA_TRUE;
How control this behavior?
Cancel current long press or not
*/
-
+ g_mutex_lock(&krt->grab_key_mutex);
krt->HardKeys[keycode].longkey.enabled = EINA_FALSE;
krt->HardKeys[keycode].longkey.time = 0.0;
+ g_mutex_unlock(&krt->grab_key_mutex);
KLINF("To disable %d key's longkey function.\n", keycode);
}
KLWRN("Currently only two key composition is allowed. (%d)\n", count);
return EINA_FALSE;
}
-
+ g_mutex_lock(&krt->grab_key_mutex);
EINA_LIST_FOREACH(krt->HardKeys[keys[0]].composition_key_list, l, data)
{
if (*data == keys[1])
{
KLWRN("%d and %d key's key composition is already requested.\n", keys[0], keys[1]);
+ g_mutex_unlock(&krt->grab_key_mutex);
return EINA_FALSE;
}
}
if (*data == keys[0])
{
KLERR("%d and %d key's key composition is already requested. (list currupted)\n", keys[0], keys[1]);
+ g_mutex_unlock(&krt->grab_key_mutex);
return EINA_FALSE;
}
}
+ g_mutex_unlock(&krt->grab_key_mutex);
data = E_NEW(int, 1);
EINA_SAFETY_ON_NULL_RETURN_VAL(data, EINA_FALSE);
*data = keys[0];
*data2 = keys[1];
+ g_mutex_lock(&krt->grab_key_mutex);
krt->HardKeys[keys[0]].composition_key_list = eina_list_append(krt->HardKeys[keys[0]].composition_key_list, data2);
krt->HardKeys[keys[1]].composition_key_list = eina_list_append(krt->HardKeys[keys[1]].composition_key_list, data);
+ g_mutex_unlock(&krt->grab_key_mutex);
KLINF("Add %d and %d key composition.\n", keys[0], keys[1]);
return;
}
+ g_mutex_lock(&krt->grab_key_mutex);
EINA_LIST_FOREACH_SAFE(krt->HardKeys[keys[0]].composition_key_list, l, l_next, data)
{
if (*data == keys[1])
break;
}
}
+ g_mutex_unlock(&krt->grab_key_mutex);
KLINF("Delete %d and %d key composition.\n", keys[0], keys[1]);
}
if (e_input_thread_mode_get())
g_mutex_init(&krt->event_handler_mutex);
+ g_mutex_init(&krt->grab_key_mutex);
+
kconfig = E_NEW(E_Keyrouter_Config_Data, 1);
EINA_SAFETY_ON_NULL_GOTO(kconfig, err);
_e_keyrouter_deinit_handlers();
+ g_mutex_lock(&krt->grab_key_mutex);
for (i = 0; i <= krt->max_tizen_hwkeys; i++)
{
if (krt->HardKeys[i].keyname)
E_FREE(keycode_data);
}
E_FREE(krt->HardKeys);
+ g_mutex_unlock(&krt->grab_key_mutex);
EINA_LIST_FREE(krt->ignore_list, keycode_data)
E_FREE(keycode_data);
static Eina_Bool
_e_keyrouter_is_key_grabbed(int key)
{
+ g_mutex_lock(&krt->grab_key_mutex);
+
if (!krt->HardKeys[key].keycode)
{
+ g_mutex_unlock(&krt->grab_key_mutex);
return EINA_FALSE;
}
if (krt->HardKeys[key].excl_ptr ||
krt->HardKeys[key].top_ptr ||
krt->HardKeys[key].shared_ptr)
{
+ g_mutex_unlock(&krt->grab_key_mutex);
return EINA_TRUE;
}
+ g_mutex_unlock(&krt->grab_key_mutex);
+
return EINA_FALSE;
}
}
}
+
if (krt->max_tizen_hwkeys < ev->keycode)
{
KLWRN("The key(%d) is too larger to process keyrouting: Invalid keycode", ev->keycode);
return EINA_FALSE;
}
- if (!krt->HardKeys[ev->keycode].keycode) return EINA_FALSE;
+ g_mutex_lock(&krt->grab_key_mutex);
+
+ if (!krt->HardKeys[ev->keycode].keycode)
+ {
+ g_mutex_unlock(&krt->grab_key_mutex);
+ return EINA_FALSE;
+ }
+
+ g_mutex_unlock(&krt->grab_key_mutex);
return EINA_TRUE;
}
E_FREE(keyname);
EINA_SAFETY_ON_NULL_GOTO(key_release, failed);
+ g_mutex_lock(&krt->grab_key_mutex);
+
EINA_LIST_FREE(krt->HardKeys[keycode].press_ptr, key_node_data)
{
_e_keyrouter_key_send(ECORE_EVENT_KEY_DOWN, key_cancel, NULL, key_node_data);
}
krt->HardKeys[keycode].press_ptr = NULL;
+ g_mutex_unlock(&krt->grab_key_mutex);
+
_e_keyrouter_key_free(key_cancel);
_e_keyrouter_key_free(key_release);
E_Keyrouter_Event_Data *key_data = NULL;
/* Deliver release clean up pressed key list */
+ g_mutex_lock(&krt->grab_key_mutex);
EINA_LIST_FREE(krt->HardKeys[ev->keycode].press_ptr, key_node_data)
{
if (key_node_data->focused == EINA_TRUE)
E_FREE(key_node_data);
}
krt->HardKeys[ev->keycode].press_ptr = NULL;
+ g_mutex_unlock(&krt->grab_key_mutex);
}
static void
return;
}
+ g_mutex_lock(&krt->grab_key_mutex);
EINA_LIST_FOREACH(krt->HardKeys[keycode].excl_ptr, l, key_node_data)
{
if (key_node_data)
key_node_data->surface, key_node_data->wc, pid, pname ?: "Unknown");
if(pname) E_FREE(pname);
if(cmd) E_FREE(cmd);
+ g_mutex_unlock(&krt->grab_key_mutex);
return;
}
}
key_node_data->surface, key_node_data->wc, pid, pname ?: "Unknown");
if(pname) E_FREE(pname);
if(cmd) E_FREE(cmd);
-
+ g_mutex_unlock(&krt->grab_key_mutex);
return;
}
}
+ g_mutex_unlock(&krt->grab_key_mutex);
// Top position grab must need a focus surface.
+ g_mutex_lock(&krt->grab_key_mutex);
if (surface_focus)
{
EINA_LIST_FOREACH(krt->HardKeys[keycode].top_ptr, l, key_node_data)
if(pname) E_FREE(pname);
if(cmd) E_FREE(cmd);
+ g_mutex_unlock(&krt->grab_key_mutex);
return;
}
krt->isWindowStackChanged = EINA_FALSE;
if(pname) E_FREE(pname);
if(cmd) E_FREE(cmd);
+ g_mutex_unlock(&krt->grab_key_mutex);
return;
}
break;
}
}
}
+
+ g_mutex_unlock(&krt->grab_key_mutex);
}
static Eina_Bool
}
/* TODO: Check this client is located inside a display boundary */
-
+ g_mutex_lock(&krt->grab_key_mutex);
EINA_LIST_FOREACH_SAFE(krt->HardKeys[arr_idx].top_ptr, l, l_next, key_node_data)
{
if (key_node_data)
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_mutex_unlock(&krt->grab_key_mutex);
return EINA_TRUE;
}
}
}
+ g_mutex_unlock(&krt->grab_key_mutex);
if (ec_top == ec_focus)
{
if (mode == TIZEN_KEYROUTER_MODE_EXCLUSIVE)
{
+ bool check_grabbed = false;
+ g_mutex_lock(&krt->grab_key_mutex);
+ check_grabbed = (krt->HardKeys[key].excl_ptr != NULL);
+ g_mutex_unlock(&krt->grab_key_mutex);
EINA_SAFETY_ON_TRUE_RETURN_VAL
- ((krt->HardKeys[key].excl_ptr != NULL),
+ (check_grabbed,
TIZEN_KEYROUTER_ERROR_GRABBED_ALREADY);
}
Eina_List *keylist_ptr = NULL, *l = NULL;
E_Keyrouter_Key_List_NodePtr key_node_data = NULL;
+ g_mutex_lock(&krt->grab_key_mutex);
switch(mode)
{
case TIZEN_KEYROUTER_MODE_EXCLUSIVE:
+ g_mutex_unlock(&krt->grab_key_mutex);
return TIZEN_KEYROUTER_ERROR_NONE;
case TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE:
break;
default:
KLWRN("Unknown key(%d) and grab mode(%d)", key, mode);
+ g_mutex_unlock(&krt->grab_key_mutex);
return TIZEN_KEYROUTER_ERROR_INVALID_MODE;
}
+ g_mutex_unlock(&krt->grab_key_mutex);
EINA_LIST_FOREACH(keylist_ptr, l, key_node_data)
{
new_keyptr->focused = focused;
new_keyptr->status = E_KRT_CSTAT_ALIVE;
+ g_mutex_lock(&krt->grab_key_mutex);
+
switch(mode)
{
case TIZEN_KEYROUTER_MODE_EXCLUSIVE:
default:
KLWRN("Unknown key(%d) and grab mode(%d)", key, mode);
E_FREE(new_keyptr);
+ g_mutex_unlock(&krt->grab_key_mutex);
return TIZEN_KEYROUTER_ERROR_INVALID_MODE;
}
+ g_mutex_unlock(&krt->grab_key_mutex);
if (TIZEN_KEYROUTER_MODE_PRESSED != mode)
{
if (surface)
{
e_keyrouter_wl_add_surface_destroy_listener(surface);
- /* TODO: if failed add surface_destory_listener, remove keygrabs */
+ /* TODO: if failed add surface_destroy_listener, remove keygrabs */
}
else if (wc)
{
e_keyrouter_wl_add_client_destroy_listener(wc);
- /* TODO: if failed add client_destory_listener, remove keygrabs */
+ /* TODO: if failed add client_destroy_listener, remove keygrabs */
}
}
EINA_SAFETY_ON_TRUE_RETURN(((!surface) && (!wc)));
+ g_mutex_lock(&krt->grab_key_mutex);
+
for (i = 0; i <= krt->max_tizen_hwkeys; i++)
{
if (0 == krt->HardKeys[i].keycode) continue;
}
}
}
+
+ g_mutex_unlock(&krt->grab_key_mutex);
}
int
{
Eina_List **list = NULL;
+ g_mutex_lock(&krt->grab_key_mutex);
+
switch (mode)
{
case TIZEN_KEYROUTER_MODE_EXCLUSIVE: list = &krt->HardKeys[key].excl_ptr; break;
default: break;
}
+ g_mutex_unlock(&krt->grab_key_mutex);
+
return list;
}
return TIZEN_KEYROUTER_ERROR_INVALID_KEY;
}
+ g_mutex_lock(&krt->grab_key_mutex);
/* Check whether the key can be grabbed or not !
* Only key listed in Tizen key layout file can be grabbed. */
if (0 == krt->HardKeys[key].keycode)
{
KLWRN("Invalid key ! Disabled to set keygrab ! (keycode:%d)", key);
+ g_mutex_unlock(&krt->grab_key_mutex);
return TIZEN_KEYROUTER_ERROR_INVALID_KEY;
}
+ g_mutex_unlock(&krt->grab_key_mutex);
/* Check whether the request key can be grabbed or not */
res = e_keyrouter_set_keygrab_in_list(surface, client, key, mode);
int
e_keyrouter_keygrab_unset(struct wl_client *client, struct wl_resource *surface, int key)
{
+ g_mutex_lock(&krt->grab_key_mutex);
/* Check the given key range */
if (krt->max_tizen_hwkeys < key)
{
KLWRN("Invalid range of key ! (keycode:%d) maximum value(%d)", key, krt->max_tizen_hwkeys);
+ g_mutex_unlock(&krt->grab_key_mutex);
return TIZEN_KEYROUTER_ERROR_INVALID_KEY;
}
if (0 == krt->HardKeys[key].keycode)
{
KLWRN("Invalid key ! Disabled to unset keygrab! (keycode:%d)", key);
+ g_mutex_unlock(&krt->grab_key_mutex);
return TIZEN_KEYROUTER_ERROR_INVALID_KEY;
}
+ g_mutex_unlock(&krt->grab_key_mutex);
+
/* Ungrab top position grabs first. This grab mode do not need privilege */
if (!surface)
e_keyrouter_find_and_remove_client_from_list(NULL, client, key, TIZEN_KEYROUTER_MODE_TOPMOST);
E_Input_Event_Handler *_key_down_handler;
E_Input_Event_Handler *_key_up_handler;
GMutex event_handler_mutex;
+ GMutex grab_key_mutex;
};
struct _E_Keyrouter_Grab_Request {
EINA_SAFETY_ON_NULL_RETURN(wc);
+ g_mutex_lock(&krt->grab_key_mutex);
EINA_LIST_FOREACH(krt->HardKeys[key].press_ptr, l, data)
{
if (surface)
}
}
}
+ g_mutex_unlock(&krt->grab_key_mutex);
}
static int
if (mode == TIZEN_KEYROUTER_MODE_TOPMOST)
return EINA_TRUE;
+ g_mutex_lock(&krt->grab_key_mutex);
if (krt->HardKeys[keycode].no_privcheck == EINA_TRUE &&
mode == TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE)
- return EINA_TRUE;
+ {
+ g_mutex_unlock(&krt->grab_key_mutex);
+ return EINA_TRUE;
+ }
+
+ g_mutex_unlock(&krt->grab_key_mutex);
if (!client) return EINA_FALSE;
- /* If initialize cynara is failed, allow keygrabs regardless of the previlege permition. */
+ /* If initialize cynara is failed, allow keygrabs regardless of the privilege permission. */
if (krt->p_cynara == NULL)
{
if (retried == EINA_FALSE)