src/bin/inputmgr/e_keyrouter_events.c

   1 #include "e_keyrouter_intern.h"
   2 #include "e_input_intern.h"
   3 #include "e_comp_wl_input_intern.h"
   4 #include "e_comp_wl_intern.h"
   5 #include "e_utils_intern.h"
   6 #include "e_screensaver_intern.h"
   7 #include "e_config_intern.h"
   8 #include "e_client_intern.h"
   9 #include "e_keyrouter_wl_intern.h"
  10
  11 #include <tizen-extension-server-protocol.h>
  12
  13 static void _e_keyrouter_send_key_events(int type, Ecore_Event_Key *ev, E_Device *dev);
  14 static void _e_keyrouter_send_key_events_press(int type, Ecore_Event_Key *ev, E_Device *dev);
  15 static void _e_keyrouter_send_key_events_release(int type, Ecore_Event_Key *ev, E_Device *dev);
  16 static void _e_keyrouter_send_key_event(int type, struct wl_resource *surface, struct wl_client *wc, Ecore_Event_Key *ev, E_Device *dev, Eina_Bool focused, unsigned int mode);
  17
  18 static Eina_Bool _e_keyrouter_send_key_events_focus(int type, struct wl_resource *surface, Ecore_Event_Key *ev, E_Device *dev, struct wl_resource **delivered_surface);
  19
  20 static Eina_Bool _e_keyrouter_is_key_grabbed(int key);
  21 static Eina_Bool _e_keyrouter_check_top_visible_window(E_Client *ec_focus, int arr_idx);
  22
  23 static Eina_Bool
  24 _e_keyrouter_is_key_grabbed(int key)
  25 {
  26    g_rec_mutex_lock(&krt->grab_key_mutex);
  27
  28    if (!krt->HardKeys[key].keycode)
  29      {
  30         g_rec_mutex_unlock(&krt->grab_key_mutex);
  31         return EINA_FALSE;
  32      }
  33    if (krt->HardKeys[key].excl_ptr ||
  34         krt->HardKeys[key].or_excl_ptr ||
  35         krt->HardKeys[key].top_ptr ||
  36         krt->HardKeys[key].shared_ptr)
  37      {
  38         g_rec_mutex_unlock(&krt->grab_key_mutex);
  39         return EINA_TRUE;
  40      }
  41
  42    g_rec_mutex_unlock(&krt->grab_key_mutex);
  43
  44    return EINA_FALSE;
  45 }
  46
  47 static Eina_Bool
  48 _e_keyrouter_event_routed_key_check(Ecore_Event_Key *ev, int type)
  49 {
  50    Eina_List *l, *l_next;
  51    int *keycode_data;
  52
  53    if ((ev->modifiers != 0) && (type == ECORE_EVENT_KEY_DOWN))
  54      {
  55         KLDBG("Modifier key delivered to Focus window : Key %s(%d)", ((ECORE_EVENT_KEY_DOWN == type) ? "Down" : "Up"), ev->keycode);
  56         keycode_data = E_NEW(int, 1);
  57         if (keycode_data)
  58           {
  59              *keycode_data = ev->keycode;
  60              krt->ignore_list = eina_list_append(krt->ignore_list, keycode_data);
  61           }
  62         return EINA_FALSE;
  63      }
  64
  65    EINA_LIST_FOREACH_SAFE(krt->ignore_list, l, l_next, keycode_data)
  66      {
  67         if (*keycode_data == ev->keycode)
  68           {
  69              KLDBG("Find ignore key, propagate event (%d)\n", ev->keycode);
  70              E_FREE(keycode_data);
  71              krt->ignore_list = eina_list_remove_list(krt->ignore_list, l);
  72
  73              return EINA_FALSE;
  74           }
  75      }
  76
  77    if (krt->max_tizen_hwkeys < ev->keycode)
  78      {
  79         KLWRN("The key(%d) is too larger to process keyrouting: Invalid keycode", ev->keycode);
  80         return EINA_FALSE;
  81      }
  82
  83    g_rec_mutex_lock(&krt->grab_key_mutex);
  84
  85    if (!krt->HardKeys[ev->keycode].keycode)
  86      {
  87         g_rec_mutex_unlock(&krt->grab_key_mutex);
  88         return EINA_FALSE;
  89      }
  90
  91    g_rec_mutex_unlock(&krt->grab_key_mutex);
  92
  93    return EINA_TRUE;
  94 }
  95
  96 static void
  97 _e_keyrouter_key_free(Ecore_Event_Key *ev)
  98 {
  99    if (!ev) return;
 100
 101    eina_stringshare_del(ev->keyname);
 102    eina_stringshare_del(ev->key);
 103    eina_stringshare_del(ev->string);
 104    eina_stringshare_del(ev->compose);
 105
 106    if (e_input_thread_mode_get())
 107      {
 108         if (ev->dev) g_object_unref(ev->dev);
 109      }
 110    else
 111      {
 112         if (ev->dev) ecore_device_unref(ev->dev);
 113      }
 114    if (ev->data) E_FREE(ev->data);
 115
 116    E_FREE(ev);
 117 }
 118
 119 static Ecore_Event_Key *
 120 _e_keyrouter_key_create(char *keyname)
 121 {
 122    Ecore_Event_Key *ev_key;
 123    E_Keyrouter_Event_Data *key_data;
 124    int keycode;
 125
 126    EINA_SAFETY_ON_NULL_RETURN_VAL(keyname, NULL);
 127
 128    ev_key = E_NEW(Ecore_Event_Key, 1);
 129    EINA_SAFETY_ON_NULL_RETURN_VAL(ev_key, NULL);
 130
 131    key_data = E_NEW(E_Keyrouter_Event_Data, 1);
 132    EINA_SAFETY_ON_NULL_GOTO(key_data, failed);
 133
 134    keycode = e_comp_wl_input_keymap_keyname_to_keycode(keyname);
 135    EINA_SAFETY_ON_FALSE_GOTO((0 < keycode && keycode <= krt->max_tizen_hwkeys), failed);
 136
 137    ev_key->key = (char *)eina_stringshare_add(keyname);
 138    ev_key->keyname = (char *)eina_stringshare_add(ev_key->key);
 139    ev_key->compose = (char *)eina_stringshare_add(ev_key->key);
 140    ev_key->timestamp = e_util_timestamp_get();
 141    ev_key->same_screen = 1;
 142
 143    ev_key->window = e_comp->ee_win;
 144    ev_key->event_window = e_comp->ee_win;
 145    ev_key->root_window = e_comp->ee_win;
 146    ev_key->keycode = keycode;
 147    ev_key->data = key_data;
 148
 149    return ev_key;
 150
 151 failed:
 152    if (ev_key) E_FREE(ev_key);
 153    if (key_data) E_FREE(key_data);
 154    return NULL;
 155 }
 156
 157 static void
 158 _e_keyrouter_key_send(int type, Ecore_Event_Key *ev, E_Device *dev, E_Keyrouter_Key_List_NodePtr key_node)
 159 {
 160    Eina_Bool res_hook = EINA_TRUE;
 161    E_Keyrouter_Event_Data *key_data = NULL;
 162
 163    if (key_node->focused)
 164      {
 165         res_hook = e_keyrouter_intercept_hook_call(E_KEYROUTER_INTERCEPT_HOOK_DELIVER_FOCUS, type, ev);
 166         key_data = (E_Keyrouter_Event_Data *)ev->data;
 167
 168         if (!res_hook || key_data->ignored)
 169           {
 170              KLINF("This hook is called to notify a current key is cancel. Please check why hook returns FALSE or ignored.\n");
 171           }
 172      }
 173    e_keyrouter_wl_key_send(ev, dev, (type == ECORE_EVENT_KEY_DOWN)?EINA_TRUE:EINA_FALSE,
 174                            key_node->wc, key_node->surface, key_node->focused);
 175 }
 176
 177 static void
 178 _e_keyrouter_key_cancel(int keycode)
 179 {
 180    Ecore_Event_Key *key_cancel, *key_release;
 181    char *keyname;
 182    E_Keyrouter_Key_List_NodePtr key_node_data;
 183    int pid = 0;
 184    char *pname = NULL, *cmd = NULL;
 185    Eina_List *press_ptr_list = NULL;
 186
 187    key_cancel = _e_keyrouter_key_create("Cancel");
 188    EINA_SAFETY_ON_NULL_RETURN(key_cancel);
 189
 190    keyname = e_comp_wl_input_keymap_keycode_to_keyname(keycode);
 191    EINA_SAFETY_ON_NULL_GOTO(keyname, failed);
 192    key_release = _e_keyrouter_key_create(keyname);
 193    E_FREE(keyname);
 194    EINA_SAFETY_ON_NULL_GOTO(key_release, failed);
 195
 196    g_rec_mutex_lock(&krt->grab_key_mutex);
 197    press_ptr_list = krt->HardKeys[keycode].press_ptr;
 198    EINA_LIST_FREE(press_ptr_list, key_node_data)
 199      {
 200         _e_keyrouter_key_send(ECORE_EVENT_KEY_DOWN, key_cancel, NULL, key_node_data);
 201         _e_keyrouter_key_send(ECORE_EVENT_KEY_UP, key_release, NULL, key_node_data);
 202         _e_keyrouter_key_send(ECORE_EVENT_KEY_UP, key_cancel, NULL, key_node_data);
 203
 204         pid = e_keyrouter_util_get_pid(key_node_data->wc, key_node_data->surface);
 205         cmd = e_keyrouter_util_cmd_get_from_pid(pid);
 206         pname = e_keyrouter_util_process_name_get_from_cmd(cmd);
 207         KLINF("CANCEL : => wl_surface (%p) wl_client (%p) (pid: %d) (pname: %s)",
 208               key_node_data->surface, key_node_data->wc, pid, pname ?: "Unknown");
 209         if(pname) E_FREE(pname);
 210         if(cmd) E_FREE(cmd);
 211
 212         E_FREE(key_node_data);
 213      }
 214
 215    krt->HardKeys[keycode].press_ptr = NULL;
 216    g_rec_mutex_unlock(&krt->grab_key_mutex);
 217
 218    _e_keyrouter_key_free(key_cancel);
 219    _e_keyrouter_key_free(key_release);
 220
 221    return;
 222
 223 failed:
 224    if (key_cancel) _e_keyrouter_key_free(key_cancel);
 225 }
 226
 227
 228 static gboolean
 229 _e_keyrouter_long_timer(void *data)
 230 {
 231    E_Keyrouter_Event_Key_Long *ev;
 232
 233    ev = E_NEW(E_Keyrouter_Event_Key_Long, 1);
 234    if (!ev)
 235      {
 236         krt->longkey.timer = 0;
 237         krt->longkey.key = 0;
 238
 239         return G_SOURCE_REMOVE;
 240      }
 241
 242    ev->keycode = krt->longkey.key;
 243
 244    _e_keyrouter_key_cancel(krt->longkey.key);
 245    ecore_event_add(E_KEYROUTER_EVENT_KEY_LONG, ev, NULL, NULL);
 246
 247    KLINF("LONGKEY : %s(%d) long press event is generated.\n",
 248          krt->HardKeys[krt->longkey.key].keyname, krt->longkey.key);
 249
 250    krt->longkey.timer = 0;
 251
 252    /* Cancel a longkey to prevent irregal operation */
 253    if (krt->composition_key.waiting_timer > 0)
 254      {
 255         g_source_remove(krt->composition_key.waiting_timer);
 256         krt->composition_key.waiting_timer = 0;
 257         krt->composition_key.key[0] = 0;
 258         krt->composition_key.key[1] = 0;
 259      }
 260
 261    return G_SOURCE_REMOVE;
 262 }
 263
 264 static Eina_Bool
 265 _e_keyrouter_long_check(int type, Ecore_Event_Key *ev)
 266 {
 267    if (type == ECORE_EVENT_KEY_DOWN)
 268      {
 269         if (krt->longkey.timer || krt->longkey.key)
 270           {
 271              KLDBG("Already long pressed key(%d) is exist\n", krt->longkey.key);
 272           }
 273         else if (krt->HardKeys[ev->keycode].longkey.enabled)
 274           {
 275              krt->longkey.timer = g_timeout_add(krt->HardKeys[ev->keycode].longkey.time*1000, _e_keyrouter_long_timer, NULL);
 276
 277              krt->longkey.key = ev->keycode;
 278           }
 279      }
 280    else
 281      {
 282         if (krt->longkey.timer == 0)
 283           {
 284              /* Already process a long press key. So ignore a long pressed key's release event */
 285              if (krt->longkey.key && krt->longkey.key == ev->keycode)
 286                {
 287                   krt->longkey.key = 0;
 288                   return ECORE_CALLBACK_DONE;
 289                }
 290              /* just a short press key event */
 291              return ECORE_CALLBACK_PASS_ON;
 292           }
 293
 294         /* Current key event is a short press, so cancel a long press timer. */
 295         if (krt->longkey.key == ev->keycode)
 296           {
 297              g_source_remove(krt->longkey.timer);
 298              krt->longkey.timer = 0;
 299              krt->longkey.key = 0;
 300           }
 301      }
 302
 303    return ECORE_CALLBACK_PASS_ON;
 304 }
 305
 306 static void
 307 _e_keyrouter_composition_key_event(Eina_Bool pressed)
 308 {
 309    E_Keyrouter_Event_Key_Composition *ev = NULL;
 310
 311    ev = E_NEW(E_Keyrouter_Event_Key_Composition, 1);
 312    EINA_SAFETY_ON_NULL_RETURN(ev);
 313
 314    ev->keys[0] = krt->composition_key.key[0];
 315    ev->keys[1] = krt->composition_key.key[1];
 316
 317    ev->timestamp = e_util_timestamp_get();
 318
 319    KLINF("COMPOSITION_KEY : %s(%d) and %s(%d) composition key %s event is generated (time: %d).\n",
 320          krt->HardKeys[ev->keys[0]].keyname, ev->keys[0],
 321          krt->HardKeys[ev->keys[1]].keyname, ev->keys[1],
 322          pressed?"press":"release", ev->timestamp);
 323
 324    if (pressed)
 325      ecore_event_add(E_KEYROUTER_EVENT_KEY_COMPOSITION_PRESS, ev, NULL, NULL);
 326    else
 327      ecore_event_add(E_KEYROUTER_EVENT_KEY_COMPOSITION_RELEASE, ev, NULL, NULL);
 328 }
 329
 330 static gboolean
 331 _e_keyrouter_composition_key_timer(void *data)
 332 {
 333    krt->composition_key.key[0] = 0;
 334    krt->composition_key.key[1] = 0;
 335
 336    krt->composition_key.waiting_timer = 0;
 337
 338    return G_SOURCE_REMOVE;
 339 }
 340
 341 static Eina_Bool
 342 _e_keyrouter_composition_key_check(int type, Ecore_Event_Key *ev)
 343 {
 344    Eina_List *l;
 345    int *wait_key_data;
 346
 347    if (type == ECORE_EVENT_KEY_DOWN)
 348      {
 349         if (krt->composition_key.waiting_timer)
 350           {
 351              /* Find modkey */
 352              EINA_LIST_FOREACH(krt->HardKeys[krt->composition_key.key[0]].composition_key_list, l, wait_key_data)
 353                {
 354                   if (*wait_key_data == ev->keycode)
 355                     {
 356                        krt->composition_key.key[1] = ev->keycode;
 357
 358                        g_source_remove(krt->composition_key.waiting_timer);
 359                        krt->composition_key.waiting_timer = 0;
 360
 361                        /* Cancel a longkey to prevent irregal operation */
 362                        if (krt->longkey.timer)
 363                          {
 364                             g_source_remove(krt->longkey.timer);
 365                             krt->longkey.timer = 0;
 366                             krt->longkey.key = 0;
 367                          }
 368
 369                        _e_keyrouter_key_cancel(krt->composition_key.key[0]);
 370                        _e_keyrouter_composition_key_event(EINA_TRUE);
 371
 372                        return ECORE_CALLBACK_DONE;
 373                     }
 374                }
 375
 376              /* Not modkey is pressed, cancel current modkey process */
 377              if (krt->composition_key.waiting_timer > 0)
 378                {
 379                   g_source_remove(krt->composition_key.waiting_timer);
 380                   krt->composition_key.waiting_timer = 0;
 381                   krt->composition_key.key[0] = 0;
 382                   krt->composition_key.key[1] = 0;
 383                }
 384           }
 385         else if (!krt->composition_key.key[0] && !krt->composition_key.key[1])
 386           {
 387              if (eina_list_count(krt->HardKeys[ev->keycode].composition_key_list) > 0)
 388                {
 389                   krt->composition_key.key[0] = ev->keycode;
 390                   krt->composition_key.waiting_timer = g_timeout_add(krt->composition_key.waiting_time*1000, _e_keyrouter_composition_key_timer, NULL);
 391                }
 392           }
 393      }
 394    else
 395      {
 396         if (!krt->composition_key.waiting_timer)
 397           {
 398              /* Already send modkey press and modkey release event is came. */
 399              if ((krt->composition_key.key[0] == ev->keycode) ||
 400                  (krt->composition_key.key[1] == ev->keycode))
 401                {
 402                   /* send modkey release event */
 403                   if (krt->composition_key.key[0] && krt->composition_key.key[1])
 404                     {
 405                        _e_keyrouter_composition_key_event(EINA_FALSE);
 406                     }
 407
 408                   if (krt->composition_key.key[0] == ev->keycode)
 409                     {
 410                        krt->composition_key.key[0] = 0;
 411                     }
 412                   else
 413                     {
 414                        krt->composition_key.key[1] = 0;
 415                     }
 416                   return ECORE_CALLBACK_DONE;
 417                }
 418              /* Modkey is not yet pressed */
 419              return ECORE_CALLBACK_PASS_ON;
 420           }
 421
 422         /* Not modkey, just key short press */
 423         if (krt->composition_key.key[0] == ev->keycode)
 424           {
 425              g_source_remove(krt->composition_key.waiting_timer);
 426              krt->composition_key.waiting_timer = 0;
 427              krt->composition_key.key[0] = 0;
 428
 429              return ECORE_CALLBACK_PASS_ON;
 430           }
 431      }
 432
 433    return ECORE_CALLBACK_PASS_ON;
 434 }
 435
 436
 437 /* Function for checking the existing grab for a key and sending key event(s) */
 438 Eina_Bool
 439 e_keyrouter_event_process(void *event, E_Device *dev, int type)
 440 {
 441    Eina_Bool res = EINA_FALSE;
 442    Ecore_Event_Key *ev = event;
 443    E_Keyrouter_Event_Data *key_data;
 444
 445    KLDBG("[%s] keyname: %s, key: %s, keycode: %d", (type == ECORE_EVENT_KEY_DOWN) ? "KEY_PRESS" : "KEY_RELEASE", ev->keyname, ev->key, ev->keycode);
 446
 447    e_screensaver_notidle();
 448
 449    key_data = (E_Keyrouter_Event_Data *)ev->data;
 450    if (!key_data)
 451      {
 452         KLWRN("%s key (%d) %s is not handled by keyrouter\n", ev->keyname, ev->keycode, (type == ECORE_EVENT_KEY_DOWN) ? "press" : "release");
 453         goto focus_deliver;
 454      }
 455
 456    if (key_data->client || key_data->surface)
 457      {
 458         e_keyrouter_wl_key_send(ev, dev, (type==ECORE_EVENT_KEY_DOWN)?EINA_TRUE:EINA_FALSE, key_data->client, key_data->surface, EINA_FALSE);
 459         return EINA_TRUE;
 460      }
 461
 462    if (!_e_keyrouter_event_routed_key_check(event, type))
 463      {
 464         goto focus_deliver;
 465      }
 466
 467    res = e_keyrouter_intercept_hook_call(E_KEYROUTER_INTERCEPT_HOOK_BEFORE_KEYROUTING, type, ev);
 468    if (!res) goto finish;
 469    if (key_data->ignored) goto finish;
 470
 471    if (key_data->client || key_data->surface)
 472       {
 473          e_keyrouter_wl_key_send(ev, dev,
 474             (type == ECORE_EVENT_KEY_DOWN) ? EINA_TRUE : EINA_FALSE,
 475             key_data->client, key_data->surface, EINA_FALSE);
 476          goto finish;
 477       }
 478
 479    //KLDBG("The key(%d) is going to be sent to the proper wl client(s) !", ev->keycode);
 480    KLDBG("[%s] keyname: %s, key: %s, keycode: %d", (type == ECORE_EVENT_KEY_DOWN) ? "KEY_PRESS" : "KEY_RELEASE", ev->keyname, ev->key, ev->keycode);
 481    if (e_config->key_input_ttrace_enable)
 482      {
 483         TRACE_INPUT_BEGIN(_e_keyrouter_send_key_events);
 484         ELOGF("INPUT", "_e_keyrouter_send_key_events|B|", NULL);
 485      }
 486
 487    _e_keyrouter_send_key_events(type, ev, dev);
 488
 489    if (e_config->key_input_ttrace_enable)
 490      {
 491         TRACE_INPUT_END();
 492         ELOGF("INPUT", "_e_keyrouter_send_key_events|E|", NULL);
 493      }
 494
 495    return EINA_FALSE;
 496
 497 focus_deliver:
 498    if (e_config->key_input_ttrace_enable)
 499      {
 500         TRACE_INPUT_BEGIN(e_comp_wl_key_process);
 501         ELOGF("INPUT", "e_comp_wl_key_process|B|", NULL);
 502      }
 503
 504    res = e_comp_wl_key_process(event, dev, type);
 505
 506    if (e_config->key_input_ttrace_enable)
 507      {
 508         TRACE_INPUT_END();
 509         ELOGF("INPUT", "e_comp_wl_key_process|E|", NULL);
 510      }
 511 finish:
 512    return res;
 513 }
 514
 515 /* Function for sending key events to wl_client(s) */
 516 static void
 517 _e_keyrouter_send_key_events(int type, Ecore_Event_Key *ev, E_Device *dev)
 518 {
 519    int pid = 0, keycode = 0;
 520    char *pname = NULL, *cmd = NULL;
 521    E_Keyrouter_Key_List_NodePtr key_node_data;
 522    Eina_List *l = NULL;
 523
 524    keycode = ev->keycode;
 525
 526    if (krt->isPictureOffEnabled == 1)
 527      {
 528         g_rec_mutex_lock(&krt->grab_key_mutex);
 529         Eina_List *pic_off_ptr_list = krt->HardKeys[keycode].pic_off_ptr;
 530         EINA_LIST_FOREACH(pic_off_ptr_list, l, key_node_data)
 531           {
 532              if (key_node_data)
 533                {
 534                   _e_keyrouter_send_key_event(type, key_node_data->surface, key_node_data->wc, ev, dev, key_node_data->focused, TIZEN_KEYROUTER_MODE_SHARED);
 535
 536                   pid = e_keyrouter_util_get_pid(key_node_data->wc, key_node_data->surface);
 537                   cmd = e_keyrouter_util_cmd_get_from_pid(pid);
 538                   pname = e_keyrouter_util_process_name_get_from_cmd(cmd);
 539                   KLINF("PICTURE OFF : %s(%d) => wl_surface (%p) wl_client (%p) (pid: %d) (pname: %s)",
 540                         ((ECORE_EVENT_KEY_DOWN == type) ? "Down" : "Up"), ev->keycode, key_node_data->surface, key_node_data->wc, pid, pname ?: "Unknown");
 541
 542                   if(pname) E_FREE(pname);
 543                   if(cmd) E_FREE(cmd);
 544                }
 545           }
 546         g_rec_mutex_unlock(&krt->grab_key_mutex);
 547         return;
 548      }
 549
 550    if (!_e_keyrouter_composition_key_check(type, ev))
 551      {
 552         KLINF("Ignore %s(%d) key %s. This key is already processed for composition key.\n", ev->keyname, ev->keycode, ((ECORE_EVENT_KEY_DOWN == type) ? "down" : "up"));
 553         return;
 554      }
 555
 556    if (!_e_keyrouter_long_check(type, ev))
 557      {
 558         if (type == ECORE_EVENT_KEY_UP)
 559           KLINF("Ignore %s(%d) key up. This key is already processed for long press.\n", ev->keyname, ev->keycode);
 560         return;
 561      }
 562
 563    if (ECORE_EVENT_KEY_DOWN == type)
 564      {
 565         _e_keyrouter_send_key_events_press(type, ev, dev);
 566      }
 567    else
 568      {
 569         _e_keyrouter_send_key_events_release(type, ev, dev);
 570      }
 571 }
 572
 573 static void
 574 _e_keyrouter_send_key_events_release(int type, Ecore_Event_Key *ev, E_Device *dev)
 575 {
 576    int pid = 0;
 577    char *pname = NULL, *cmd = NULL;
 578    E_Keyrouter_Key_List_NodePtr key_node_data;
 579    Eina_Bool res_hook = EINA_TRUE;
 580    E_Keyrouter_Event_Data *key_data = NULL;
 581
 582    /* Deliver release  clean up pressed key list */
 583    g_rec_mutex_lock(&krt->grab_key_mutex);
 584    Eina_List *press_ptr_list = krt->HardKeys[ev->keycode].press_ptr;
 585    EINA_LIST_FREE(press_ptr_list, key_node_data)
 586      {
 587         if (key_node_data->focused == EINA_TRUE)
 588           {
 589              res_hook = e_keyrouter_intercept_hook_call(E_KEYROUTER_INTERCEPT_HOOK_DELIVER_FOCUS, type, ev);
 590              key_data = (E_Keyrouter_Event_Data *)ev->data;
 591
 592              if (res_hook)
 593                {
 594                   if (key_data->ignored)
 595                     {
 596                        E_FREE(key_node_data);
 597                        continue;
 598                     }
 599                   if (key_data->surface || key_data->client)
 600                     {
 601                        _e_keyrouter_send_key_event(type, key_data->surface, key_data->client, ev, dev,
 602                                                    EINA_FALSE, TIZEN_KEYROUTER_MODE_PRESSED);
 603
 604                        pid = e_keyrouter_util_get_pid(key_data->client, key_data->surface);
 605                        cmd = e_keyrouter_util_cmd_get_from_pid(pid);
 606                        pname = e_keyrouter_util_process_name_get_from_cmd(cmd);
 607                        KLINF("Release Hook : %s(%s:%d)(Focus: %d)(Status: %d) => wl_surface (%p) wl_client (%p) (pid: %d) (pname: %s)",
 608                              ((ECORE_EVENT_KEY_DOWN == type) ? "Down" : "Up"), ev->keyname, ev->keycode, key_node_data->focused,
 609                              key_node_data->status, key_data->surface, key_data->client, pid, pname ?: "Unknown");
 610                        if(pname) E_FREE(pname);
 611                        if(cmd) E_FREE(cmd);
 612
 613                        E_FREE(key_node_data);
 614                        continue;
 615                     }
 616                }
 617           }
 618
 619         if (!res_hook)
 620           {
 621              E_FREE(key_node_data);
 622              continue;
 623           }
 624
 625         if (key_node_data->status == E_KRT_CSTAT_ALIVE)
 626           {
 627              _e_keyrouter_send_key_event(type, key_node_data->surface, key_node_data->wc, ev, dev,
 628                                          key_node_data->focused, TIZEN_KEYROUTER_MODE_PRESSED);
 629
 630              pid = e_keyrouter_util_get_pid(key_node_data->wc, key_node_data->surface);
 631              cmd = e_keyrouter_util_cmd_get_from_pid(pid);
 632              pname = e_keyrouter_util_process_name_get_from_cmd(cmd);
 633              KLINF("Release Pair : %s(%s:%d)(Focus: %d)(Status: %d) => wl_surface (%p) wl_client (%p) (pid: %d) (pname: %s)",
 634                       ((ECORE_EVENT_KEY_DOWN == type) ? "Down" : "Up"), ev->keyname, ev->keycode, key_node_data->focused,
 635                       key_node_data->status, key_node_data->surface, key_node_data->wc, pid, pname ?: "Unknown");
 636              if(pname) E_FREE(pname);
 637              if(cmd) E_FREE(cmd);
 638           }
 639         else
 640           {
 641              KLINF("Release Skip : %s(%s:%d)(Focus: %d)(Status: %d) => wl_surface (%p) wl_client (%p) process is ungrabbed / dead",
 642                       ((ECORE_EVENT_KEY_DOWN == type) ? "Down" : "Up"), ev->keyname, ev->keycode, key_node_data->focused,
 643                       key_node_data->status, key_node_data->surface, key_node_data->wc);
 644           }
 645
 646         E_FREE(key_node_data);
 647      }
 648    krt->HardKeys[ev->keycode].press_ptr = NULL;
 649    g_rec_mutex_unlock(&krt->grab_key_mutex);
 650 }
 651
 652 static void
 653 _e_keyrouter_send_key_events_press(int type, Ecore_Event_Key *ev, E_Device *dev)
 654 {
 655    unsigned int keycode = ev->keycode;
 656    struct wl_resource *surface_focus = NULL;
 657    E_Client *ec_focus = NULL;
 658    struct wl_resource *delivered_surface = NULL;
 659    Eina_Bool res;
 660    int ret = 0;
 661    int pid = 0;
 662    char *pname = NULL, *cmd = NULL;
 663
 664    E_Keyrouter_Key_List_NodePtr key_node_data;
 665    Eina_List *l = NULL;
 666    Eina_List *shared_ptr_list = NULL;
 667
 668    ec_focus = e_client_focused_get();
 669    surface_focus = e_keyrouter_util_get_surface_from_eclient(ec_focus);
 670
 671    if (!_e_keyrouter_is_key_grabbed(ev->keycode))
 672      {
 673         _e_keyrouter_send_key_events_focus(type, surface_focus, ev, dev, &delivered_surface);
 674         return;
 675      }
 676
 677    g_rec_mutex_lock(&krt->grab_key_mutex);
 678    Eina_List *excl_ptr_list = krt->HardKeys[keycode].excl_ptr;
 679    EINA_LIST_FOREACH(excl_ptr_list, l, key_node_data)
 680      {
 681         if (key_node_data)
 682           {
 683              _e_keyrouter_send_key_event(type, key_node_data->surface, key_node_data->wc, ev, dev,
 684                                         key_node_data->focused, TIZEN_KEYROUTER_MODE_EXCLUSIVE);
 685
 686              pid = e_keyrouter_util_get_pid(key_node_data->wc, key_node_data->surface);
 687              cmd = e_keyrouter_util_cmd_get_from_pid(pid);
 688              pname = e_keyrouter_util_process_name_get_from_cmd(cmd);
 689              KLINF("EXCLUSIVE : %s(%s:%d) => wl_surface (%p) wl_client (%p) (pid: %d) (pname: %s)",
 690                       ((ECORE_EVENT_KEY_DOWN == type) ? "Down" : "Up"), ev->keyname, ev->keycode,
 691                       key_node_data->surface, key_node_data->wc, pid, pname ?: "Unknown");
 692              if(pname) E_FREE(pname);
 693              if(cmd) E_FREE(cmd);
 694              g_rec_mutex_unlock(&krt->grab_key_mutex);
 695              return;
 696           }
 697      }
 698    g_rec_mutex_unlock(&krt->grab_key_mutex);
 699
 700    g_rec_mutex_lock(&krt->grab_key_mutex);
 701    Eina_List *or_excl_ptr = krt->HardKeys[keycode].or_excl_ptr;
 702    EINA_LIST_FOREACH(or_excl_ptr, l, key_node_data)
 703      {
 704         if (key_node_data)
 705           {
 706              _e_keyrouter_send_key_event(type, key_node_data->surface, key_node_data->wc, ev, dev,
 707                                          key_node_data->focused, TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE);
 708
 709              pid = e_keyrouter_util_get_pid(key_node_data->wc, key_node_data->surface);
 710              cmd = e_keyrouter_util_cmd_get_from_pid(pid);
 711              pname = e_keyrouter_util_process_name_get_from_cmd(cmd);
 712              KLINF("OVERRIDABLE_EXCLUSIVE : %s(%s:%d) => wl_surface (%p) wl_client (%p) (pid: %d) (pname: %s)",
 713                      ((ECORE_EVENT_KEY_DOWN == type) ? "Down" : "Up"), ev->keyname, ev->keycode,
 714                      key_node_data->surface, key_node_data->wc, pid, pname ?: "Unknown");
 715              if(pname) E_FREE(pname);
 716              if(cmd) E_FREE(cmd);
 717              g_rec_mutex_unlock(&krt->grab_key_mutex);
 718              return;
 719           }
 720      }
 721    g_rec_mutex_unlock(&krt->grab_key_mutex);
 722
 723    // Top position grab must need a focus surface.
 724    if (surface_focus)
 725      {
 726         g_rec_mutex_lock(&krt->grab_key_mutex);
 727         Eina_List *top_ptr_list = krt->HardKeys[keycode].top_ptr;
 728         EINA_LIST_FOREACH(top_ptr_list, l, key_node_data)
 729           {
 730              if (key_node_data)
 731                {
 732                   if ((EINA_FALSE == krt->isWindowStackChanged) && (surface_focus == key_node_data->surface))
 733                     {
 734                        pid = e_keyrouter_util_get_pid(key_node_data->wc, key_node_data->surface);
 735                        cmd = e_keyrouter_util_cmd_get_from_pid(pid);
 736                        pname = e_keyrouter_util_process_name_get_from_cmd(cmd);
 737
 738                        _e_keyrouter_send_key_event(type, key_node_data->surface, NULL, ev, dev, key_node_data->focused,
 739                                                    TIZEN_KEYROUTER_MODE_TOPMOST);
 740                        KLINF("TOPMOST (TOP_POSITION) : %s (%s:%d) => wl_surface (%p) (pid: %d) (pname: %s)",
 741                                 ((ECORE_EVENT_KEY_DOWN == type) ? "Down" : "Up"), ev->keyname, ev->keycode,
 742                                 key_node_data->surface, pid, pname ?: "Unknown");
 743
 744                        if(pname) E_FREE(pname);
 745                        if(cmd) E_FREE(cmd);
 746                        g_rec_mutex_unlock(&krt->grab_key_mutex);
 747                        return;
 748                     }
 749                   krt->isWindowStackChanged = EINA_FALSE;
 750
 751                   if (_e_keyrouter_check_top_visible_window(ec_focus, keycode))
 752                     {
 753                        E_Keyrouter_Key_List_NodePtr top_key_node_data = eina_list_data_get(krt->HardKeys[keycode].top_ptr);
 754                        pid = e_keyrouter_util_get_pid(top_key_node_data->wc, top_key_node_data->surface);
 755                        cmd = e_keyrouter_util_cmd_get_from_pid(pid);
 756                        pname = e_keyrouter_util_process_name_get_from_cmd(cmd);
 757
 758                        _e_keyrouter_send_key_event(type, top_key_node_data->surface, NULL, ev, dev, top_key_node_data->focused,
 759                                                    TIZEN_KEYROUTER_MODE_TOPMOST);
 760                        KLINF("TOPMOST (TOP_POSITION) : %s (%s:%d) => wl_surface (%p) (pid: %d) (pname: %s)",
 761                              ((ECORE_EVENT_KEY_DOWN == type) ? "Down" : "Up"), ev->keyname, ev->keycode,
 762                              top_key_node_data->surface, pid, pname ?: "Unknown");
 763
 764                        if(pname) E_FREE(pname);
 765                        if(cmd) E_FREE(cmd);
 766                        g_rec_mutex_unlock(&krt->grab_key_mutex);
 767                        return;
 768                     }
 769                   break;
 770                }
 771           }
 772         g_rec_mutex_unlock(&krt->grab_key_mutex);
 773        goto need_shared;
 774      }
 775
 776    g_rec_mutex_lock(&krt->grab_key_mutex);
 777    shared_ptr_list = krt->HardKeys[keycode].shared_ptr;
 778    g_rec_mutex_unlock(&krt->grab_key_mutex);
 779
 780    if (shared_ptr_list)
 781      {
 782 need_shared:
 783         res = _e_keyrouter_send_key_events_focus(type, surface_focus, ev, dev, &delivered_surface);
 784         if (delivered_surface)
 785           {
 786              ret = e_keyrouter_wl_add_surface_destroy_listener(delivered_surface);
 787              if (ret != TIZEN_KEYROUTER_ERROR_NONE)
 788                {
 789                   KLWRN("Failed to add wl_surface to destroy listener (res: %d)", res);
 790                }
 791           }
 792         if (res)
 793           {
 794              g_rec_mutex_lock(&krt->grab_key_mutex);
 795              shared_ptr_list = krt->HardKeys[keycode].shared_ptr;
 796              EINA_LIST_FOREACH(shared_ptr_list, l, key_node_data)
 797                {
 798                   if (key_node_data)
 799                     {
 800                        if (delivered_surface && key_node_data->surface == delivered_surface)
 801                          {
 802                             // Check for already delivered surface
 803                             // do not deliver double events in this case.
 804                             continue;
 805                          }
 806                        else
 807                          {
 808                             _e_keyrouter_send_key_event(type, key_node_data->surface, key_node_data->wc, ev, dev, key_node_data->focused, TIZEN_KEYROUTER_MODE_SHARED);
 809                             pid = e_keyrouter_util_get_pid(key_node_data->wc, key_node_data->surface);
 810                             cmd = e_keyrouter_util_cmd_get_from_pid(pid);
 811                             pname = e_keyrouter_util_process_name_get_from_cmd(cmd);
 812                             KLINF("SHARED : %s(%s:%d) => wl_surface (%p) wl_client (%p) (pid: %d) (pname: %s)",
 813                                   ((ECORE_EVENT_KEY_DOWN == type) ? "Down" : "Up"), ev->keyname, ev->keycode, key_node_data->surface, key_node_data->wc, pid, pname ?: "Unknown");
 814                             if(pname) E_FREE(pname);
 815                             if(cmd) E_FREE(cmd);
 816                          }
 817                     }
 818                }
 819              g_rec_mutex_unlock(&krt->grab_key_mutex);
 820           }
 821      }
 822 }
 823
 824 static Eina_Bool
 825 _e_keyrouter_send_key_events_focus(int type, struct wl_resource *surface_focus,  Ecore_Event_Key *ev, E_Device *dev, struct wl_resource **delivered_surface)
 826 {
 827    Eina_Bool res = EINA_TRUE;
 828    int pid = 0;
 829    char *pname = NULL, *cmd = NULL;
 830    E_Keyrouter_Event_Data *key_data;
 831
 832    res = e_keyrouter_intercept_hook_call(E_KEYROUTER_INTERCEPT_HOOK_DELIVER_FOCUS, type, ev);
 833    key_data = (E_Keyrouter_Event_Data *)ev->data;
 834    if (res)
 835      {
 836         if (key_data->ignored)
 837           {
 838              e_keyrouter_prepend_to_keylist(NULL, NULL, ev->keycode, TIZEN_KEYROUTER_MODE_PRESSED, EINA_TRUE);
 839              return EINA_TRUE;
 840           }
 841         else if (key_data->surface)
 842           {
 843              *delivered_surface = key_data->surface;
 844              e_keyrouter_prepend_to_keylist(key_data->surface, key_data->client, ev->keycode, TIZEN_KEYROUTER_MODE_PRESSED, EINA_TRUE);
 845              res = e_keyrouter_wl_key_send(ev, dev, (type==ECORE_EVENT_KEY_DOWN)?EINA_TRUE:EINA_FALSE, key_data->client, key_data->surface, EINA_FALSE);
 846
 847              pid = e_keyrouter_util_get_pid(NULL, key_data->surface);
 848              cmd = e_keyrouter_util_cmd_get_from_pid(pid);
 849              pname = e_keyrouter_util_process_name_get_from_cmd(cmd);
 850
 851              KLINF("FOCUS HOOK : %s(%s:%d) => wl_surface (%p) (pid: %d) (pname: %s)",
 852                    ((ECORE_EVENT_KEY_DOWN == type) ? "Down" : "Up"), ev->keyname, ev->keycode,
 853                    key_data->surface, pid, pname ?: "Unknown");
 854
 855              if(pname) E_FREE(pname);
 856              if(cmd) E_FREE(cmd);
 857              return EINA_TRUE;
 858           }
 859      }
 860    else
 861      {
 862         e_keyrouter_prepend_to_keylist(NULL, NULL, ev->keycode, TIZEN_KEYROUTER_MODE_PRESSED, EINA_TRUE);
 863         return EINA_FALSE;
 864      }
 865
 866    pid = e_keyrouter_util_get_pid(NULL, surface_focus);
 867    cmd = e_keyrouter_util_cmd_get_from_pid(pid);
 868    pname = e_keyrouter_util_process_name_get_from_cmd(cmd);
 869
 870    _e_keyrouter_send_key_event(type, surface_focus, NULL,ev, dev, EINA_TRUE, TIZEN_KEYROUTER_MODE_SHARED);
 871    KLINF("FOCUS DIRECT : %s(%s:%d) => wl_surface (%p) (pid: %d) (pname: %s)",
 872          ((ECORE_EVENT_KEY_DOWN == type) ? "Down" : "Up"), ev->keyname, ev->keycode, surface_focus, pid, pname ?: "Unknown");
 873    *delivered_surface = surface_focus;
 874    if(pname) E_FREE(pname);
 875    if(cmd) E_FREE(cmd);
 876    return res;
 877 }
 878
 879 static Eina_Bool
 880 _e_keyrouter_check_top_visible_window(E_Client *ec_focus, int arr_idx)
 881 {
 882    E_Client *ec_top = NULL;
 883    Eina_List *l = NULL, *l_next = NULL;
 884    E_Keyrouter_Key_List_NodePtr key_node_data = NULL;
 885
 886    ec_top = e_client_top_get();
 887
 888    while (ec_top)
 889      {
 890         if (e_client_visibility_get(ec_top) != E_VISIBILITY_UNOBSCURED)
 891           {
 892              if (ec_top == ec_focus)
 893                {
 894                   KLDBG("Top e_client (%p) is invisible(%d) but focus client", ec_top, ec_top->visible);
 895                   return EINA_FALSE;
 896                }
 897              ec_top = e_client_below_get(ec_top);
 898              continue;
 899           }
 900
 901         /* TODO: Check this client is located inside a display boundary */
 902         g_rec_mutex_lock(&krt->grab_key_mutex);
 903         Eina_List *top_ptr_list = krt->HardKeys[arr_idx].top_ptr;
 904         EINA_LIST_FOREACH_SAFE(top_ptr_list, l, l_next, key_node_data)
 905           {
 906              if (key_node_data)
 907                {
 908                   if (ec_top == e_client_from_surface_resource(key_node_data->surface))
 909                     {
 910                        krt->HardKeys[arr_idx].top_ptr = eina_list_promote_list(krt->HardKeys[arr_idx].top_ptr, l);
 911                        KLDBG("Move a client(e_client: %p, wl_surface: %p) to first index of list(key: %d)",
 912                                 ec_top, key_node_data->surface, arr_idx);
 913                        g_rec_mutex_unlock(&krt->grab_key_mutex);
 914                        return EINA_TRUE;
 915                     }
 916                }
 917           }
 918
 919         g_rec_mutex_unlock(&krt->grab_key_mutex);
 920
 921         if (ec_top == ec_focus)
 922           {
 923              KLDBG("The e_client(%p) is a focus client", ec_top);
 924              return EINA_FALSE;
 925           }
 926
 927         ec_top = e_client_below_get(ec_top);
 928      }
 929    return EINA_FALSE;
 930 }
 931
 932 /* Function for sending key event to wl_client(s) */
 933 static void
 934 _e_keyrouter_send_key_event(int type, struct wl_resource *surface, struct wl_client *wc, Ecore_Event_Key *ev, E_Device *dev, Eina_Bool focused, unsigned int mode)
 935 {
 936    struct wl_client *wc_send;
 937    Eina_Bool pressed = EINA_FALSE;
 938
 939    if (surface == NULL) wc_send = wc;
 940    else wc_send = wl_resource_get_client(surface);
 941
 942    if (!wc_send)
 943      {
 944         KLWRN("wl_surface: %p or wl_client: %p returns null wayland client", surface, wc);
 945         return;
 946      }
 947
 948    if (ECORE_EVENT_KEY_DOWN == type)
 949      {
 950         pressed = EINA_TRUE;
 951         e_keyrouter_prepend_to_keylist(surface, wc, ev->keycode, TIZEN_KEYROUTER_MODE_PRESSED, focused);
 952      }
 953
 954    if (e_config->key_input_ttrace_enable)
 955      {
 956         TRACE_INPUT_BEGIN(e_keyrouter_wl_key_send);
 957         ELOGF("INPUT", "e_keyrouter_wl_key_send|B|", NULL);
 958      }
 959
 960    e_keyrouter_wl_key_send(ev, dev, pressed, wc_send, surface, focused);
 961
 962    if (e_config->key_input_ttrace_enable)
 963      {
 964         TRACE_INPUT_END();
 965         ELOGF("INPUT", "e_keyrouter_wl_key_send|E|", NULL);
 966      }
 967
 968    return;
 969 }
 970
 971 struct wl_resource *
 972 e_keyrouter_util_get_surface_from_eclient(E_Client *client)
 973 {
 974    if (!client || !client->comp_data) return NULL;
 975
 976    return client->comp_data->wl_surface;
 977 }
 978
 979 int
 980 e_keyrouter_util_get_pid(struct wl_client *client, struct wl_resource *surface)
 981 {
 982    pid_t pid = 0;
 983    uid_t uid = 0;
 984    gid_t gid = 0;
 985    struct wl_client *cur_client = NULL;
 986
 987    if (client) cur_client = client;
 988    else if (surface) cur_client = wl_resource_get_client(surface);
 989    EINA_SAFETY_ON_NULL_RETURN_VAL(cur_client, 0);
 990
 991    wl_client_get_credentials(cur_client, &pid, &uid, &gid);
 992
 993    return pid;
 994 }
 995
 996 char *
 997 e_keyrouter_util_cmd_get_from_pid(int pid)
 998 {
 999    Eina_List *l;
1000    E_Comp_Connected_Client_Info *cdata;
1001
1002    EINA_SAFETY_ON_NULL_RETURN_VAL(e_comp, NULL);
1003
1004    EINA_LIST_FOREACH(e_comp->connected_clients, l, cdata)
1005      {
1006         if (cdata->pid == pid) return strdup(cdata->name);
1007      }
1008
1009    return NULL;
1010 }
1011
1012 char *
1013 e_keyrouter_util_process_name_get_from_cmd(char *cmd)
1014 {
1015    int len, i;
1016    char pbuf = '\0';
1017    char *pname = NULL;
1018    if (cmd)
1019      {
1020         len = strlen(cmd);
1021         for (i = 0; i < len; i++)
1022           {
1023              pbuf = cmd[len - i - 1];
1024              if (pbuf == '/')
1025                {
1026                   pname = &cmd[len - i];
1027                   return strdup(pname);
1028                }
1029           }
1030      }
1031    return NULL;
1032 }
1033