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