src/e_test_event.cpp

   1 #include <Ecore_Wl2.h>
   2
   3 #include "e_test_event.h"
   4
   5 #define E_TEST_WORK_TIME 3.0
   6 #define E_TC_SIGN_WIN_INFO "usiiiiibbbiibbbbbi"
   7
   8 static const char effect_started[] = "effect,started";
   9 static const char effect_done[] = "effect,done";
  10 static const char launch_done[] = "launch,done";
  11
  12 /* callbacks - event */
  13 static void
  14 _cb_resource_id(void *data,
  15                 struct tizen_resource *tizen_resource,
  16                 uint32_t id)
  17 {
  18    Ecore_Window *res_id = (Ecore_Window *)data;
  19    *res_id = id;
  20    etRunner::get().finishWork();
  21 }
  22
  23 static void
  24 _cb_geometry(void *data EINA_UNUSED,
  25              struct wl_output *wl_output EINA_UNUSED,
  26              int x, int y, int w, int h,
  27              int subpixel EINA_UNUSED,
  28              const char *make EINA_UNUSED,
  29              const char *model EINA_UNUSED,
  30              int transform EINA_UNUSED)
  31 {
  32    etRunner::get().output.x = x;
  33    etRunner::get().output.y = y;
  34    etRunner::get().output.w = w;
  35    etRunner::get().output.h = h;
  36 }
  37
  38 static void
  39 _cb_mode(void *data EINA_UNUSED,
  40          struct wl_output *wl_output EINA_UNUSED,
  41          unsigned int flags,
  42          int w, int h,
  43          int refresh EINA_UNUSED)
  44 {
  45    if (flags & WL_OUTPUT_MODE_CURRENT)
  46      {
  47         etRunner::get().output.w = w;
  48         etRunner::get().output.h = h;
  49      }
  50
  51    etRunner::get().finishWork();
  52 }
  53
  54 static void
  55 _cb_done(void *data EINA_UNUSED,
  56          struct wl_output *output EINA_UNUSED)
  57 {
  58    ;
  59 }
  60
  61 static void
  62 _cb_scale(void *data EINA_UNUSED,
  63           struct wl_output *output EINA_UNUSED,
  64           int scale EINA_UNUSED)
  65 {
  66    ;
  67 }
  68
  69 /* callbacks - method */
  70 static void _cb_method_win_info_get(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  71 static void _cb_method_win_info_list_get(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  72 static void _cb_method_window_register(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  73 static void _cb_method_zone_rotation_change(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  74 static void _cb_method_window_effect(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  75 static void _cb_method_set_tc_start_end(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  76 static void _cb_method_set_tc_timeout(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  77 static void _cb_method_transient_for_below(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  78 static void _cb_method_aux_hint_get(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  79
  80 /* callbacks - signal */
  81 static void _cb_signal_vis_changed(void *data, const Eldbus_Message *msg);
  82 static void _cb_signal_stack_changed(void *data, const Eldbus_Message *msg);
  83 static void _cb_signal_win_rot_changed(void *data, const Eldbus_Message *msg);
  84 static void _cb_signal_focus_changed(void *data, const Eldbus_Message *msg);
  85 static void _cb_signal_render_while_effect_run(void *data, const Eldbus_Message *msg);
  86 static void _cb_signal_aux_hint_changed(void *data, const Eldbus_Message *msg);
  87
  88 /* callbacks - ecore */
  89 static Eina_Bool _cb_ecore_key_down(void *data, int type, void *event);
  90 static Eina_Bool _cb_ecore_key_up(void *data, int type, void *event);
  91
  92 /* callbacks - evas */
  93 static void _cb_evas_key_down(void * data, Evas * evas, Evas_Object * obj, void * event_info);
  94 static void _cb_evas_key_up(void * data, Evas * evas, Evas_Object * obj, void * event_info);
  95
  96 /* callbacks -  smart  */
  97 static void _cb_evas_smart_cb_effect_started(void *data, Evas_Object * obj, void *event_info);
  98 static void _cb_evas_smart_cb_effect_done(void *data, Evas_Object * obj, void *event_info);
  99 static void _cb_evas_smart_cb_launch_done(void *data, Evas_Object * obj, void *event_info);
 100
 101 /* callbacks - timer */
 102 static Eina_Bool _cb_work_timeout(void *data);
 103
 104 /* callbacks - gesture */
 105 static Eina_Bool _cb_gesture_tap(void *data, int type, void *event);
 106 static Eina_Bool _cb_gesture_edge_swipe(void *data, int type, void *event);
 107 static Eina_Bool _cb_gesture_edge_drag(void *data, int type, void *event);
 108
 109 /**********************
 110       listeners
 111  **********************/
 112 static const struct tizen_resource_listener _e_test_tizen_resource_listener =
 113 {
 114    _cb_resource_id,
 115 };
 116
 117 static const struct wl_output_listener _e_test_output_listener =
 118 {
 119    _cb_geometry,
 120    _cb_mode,
 121    _cb_done,
 122    _cb_scale
 123 };
 124
 125 /**********************
 126    class etRunner
 127  **********************/
 128 etRunner etRunner::inst;
 129
 130 Eina_Bool
 131 etRunner::init()
 132 {
 133    Eina_Bool res = EINA_FALSE;
 134
 135    worker.waitTime = E_TEST_WORK_TIME;
 136
 137    logDomain = eina_log_domain_register("e-tc", EINA_COLOR_BLUE);
 138
 139    // Init Ecore_Wl2
 140    if (!ecore_wl2_connected_display_get(NULL))
 141      ecore_wl2_display_connect(NULL);
 142
 143    // init tizen_extension protocol
 144    res = initProtocols();
 145    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 146
 147    // init eldbus
 148    eldbus_init();
 149
 150    dbus.conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
 151    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.conn, EINA_FALSE);
 152
 153    dbus.ds_obj = eldbus_object_get(dbus.conn,
 154                                 "org.enlightenment.wm",
 155                                 "/org/enlightenment/wm");
 156    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.ds_obj, EINA_FALSE);
 157
 158    dbus.ds_proxy = eldbus_proxy_get(dbus.ds_obj,
 159                                  "org.enlightenment.wm.Test");
 160    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.ds_proxy, EINA_FALSE);
 161
 162    dbus.deviced_obj = eldbus_object_get(dbus.conn,
 163                                         "org.tizen.system.deviced",
 164                                         "/Org/Tizen/System/DeviceD/Display");
 165    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.deviced_obj, EINA_FALSE);
 166
 167    dbus.deviced_proxy = eldbus_proxy_get(dbus.deviced_obj,
 168                                          "org.tizen.system.deviced.display");
 169    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.deviced_proxy, EINA_FALSE);
 170
 171    // reset registered window of e_test_helper
 172    res = resetRegisterWin();
 173    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 174
 175    // init input generator
 176    inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, NULL);
 177    EINA_SAFETY_ON_NULL_RETURN_VAL(inputGenerator, EINA_FALSE);
 178
 179    // init gesture handler
 180    gestureHandler = efl_util_gesture_initialize();
 181    EINA_SAFETY_ON_NULL_RETURN_VAL(gestureHandler, EINA_FALSE);
 182
 183    // add signal handlers
 184    res = addSignalHandlers();
 185    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 186
 187    return EINA_TRUE;
 188 }
 189
 190 void
 191 etRunner::shutdown()
 192 {
 193    eina_log_domain_unregister(logDomain);
 194
 195    freeLastWinInfoList();
 196    delSignalHandlers();
 197
 198    // deinit tizen_extension protocol
 199    if (tzPolicy)
 200      {
 201         tizen_policy_destroy(tzPolicy);
 202         tzPolicy = NULL;
 203      }
 204
 205    if (tzSurface)
 206      {
 207         tizen_surface_destroy(tzSurface);
 208         tzSurface = NULL;
 209      }
 210
 211    if (tzlaunch_splash)
 212      {
 213         tizen_launch_splash_destroy(tzlaunch_splash);
 214         tzlaunch_splash = NULL;
 215      }
 216
 217    if (tzlaunch_effect)
 218      {
 219         tizen_launch_effect_destroy(tzlaunch_effect);
 220         tzlaunch_effect = NULL;
 221      }
 222
 223    // deinit eldbus
 224    eldbus_proxy_unref(dbus.deviced_proxy);
 225    eldbus_object_unref(dbus.deviced_obj);
 226    eldbus_proxy_unref(dbus.ds_proxy);
 227    eldbus_object_unref(dbus.ds_obj);
 228    eldbus_connection_unref(dbus.conn);
 229    eldbus_shutdown();
 230
 231    // deinit input generator
 232    efl_util_input_deinitialize_generator(inputGenerator);
 233
 234    // deinit gesture handler
 235    efl_util_gesture_deinitialize(gestureHandler);
 236 }
 237
 238 Eina_Bool
 239 etRunner::registerWin(etWin *tw)
 240 {
 241    Eldbus_Pending *p = NULL;
 242    Eina_Bool accepted = EINA_FALSE;
 243
 244    p = eldbus_proxy_call(dbus.ds_proxy,
 245                          "RegisterWindow",
 246                          _cb_method_window_register,
 247                          &accepted,
 248                          -1,
 249                          "u",
 250                          tw->native_win);
 251    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 252
 253    work();
 254
 255    return accepted;
 256 }
 257
 258 Eina_Bool
 259 etRunner::deregisterWin(etWin *tw)
 260 {
 261    Eldbus_Pending *p = NULL;
 262    Eina_Bool accepted = EINA_FALSE;
 263
 264    p = eldbus_proxy_call(dbus.ds_proxy,
 265                          "DeregisterWindow",
 266                          _cb_method_window_register,
 267                          &accepted,
 268                          -1,
 269                          "u",
 270                          tw->native_win);
 271    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 272
 273    work();
 274
 275    return accepted;
 276 }
 277
 278 Eina_Bool
 279 etRunner::resetRegisterWin()
 280 {
 281    Eldbus_Pending *p = NULL;
 282    Eina_Bool accepted = EINA_FALSE;
 283
 284    p = eldbus_proxy_call(dbus.ds_proxy,
 285                          "ResetRegisterWindow",
 286                          _cb_method_window_register,
 287                          &accepted,
 288                          -1,
 289                          "");
 290    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 291
 292    work();
 293
 294    return accepted;
 295 }
 296
 297 Eina_Bool
 298 etRunner::setWinActivate(etWin *tw)
 299 {
 300    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 301
 302    tw->updateGeometry();
 303
 304    tizen_policy_activate(tzPolicy,
 305                          getWlSurface(tw->elm_win));
 306
 307    return EINA_TRUE;
 308 }
 309
 310 Eina_Bool
 311 etRunner::requestKillWinByName(const char *name)
 312 {
 313    Eldbus_Pending *p = NULL;
 314
 315    EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
 316
 317    p = eldbus_proxy_call(dbus.ds_proxy,
 318                          "RequestKillWin",
 319                          NULL,
 320                          NULL,
 321                          -1,
 322                          "s",
 323                          name);
 324    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 325
 326    return EINA_TRUE;
 327 }
 328
 329 Eina_Bool
 330 etRunner::setWinIconic(etWin *tw,
 331                       Eina_Bool set)
 332 {
 333    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 334
 335    if (set)
 336      tizen_policy_iconify(tzPolicy,
 337                           getWlSurface(tw->elm_win));
 338    else
 339      tizen_policy_uniconify(tzPolicy,
 340                             getWlSurface(tw->elm_win));
 341
 342    return EINA_TRUE;
 343 }
 344
 345 Eina_Bool
 346 etRunner::setWinStack(etWin *tw,
 347                       etWin *sibiling,
 348                       Eina_Bool above)
 349 {
 350    Eldbus_Pending *p = NULL;
 351    p = eldbus_proxy_call(dbus.ds_proxy,
 352                          "SetWindowStack",
 353                          NULL,
 354                          NULL,
 355                          -1,
 356                          "uui",
 357                          tw->native_win,
 358                          sibiling? sibiling->native_win : 0,
 359                          above);
 360    EINA_SAFETY_ON_TRUE_RETURN_VAL(p != NULL, EINA_FALSE);
 361
 362    return EINA_TRUE;
 363 }
 364
 365 Eina_Bool
 366 etRunner::setWinRaise(etWin *tw)
 367 {
 368    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 369
 370    tizen_policy_raise(tzPolicy, getWlSurface(tw->elm_win));
 371
 372    return EINA_TRUE;
 373 }
 374
 375 Eina_Bool
 376 etRunner::setWinLower(etWin *tw)
 377 {
 378    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 379
 380    tizen_policy_lower(tzPolicy, getWlSurface(tw->elm_win));
 381
 382    return EINA_TRUE;
 383 }
 384
 385 Eina_Bool
 386 etRunner::setWinTransientFor(etWin *tw_child,
 387                              etWin *tw_parent,
 388                              Eina_Bool set)
 389 {
 390    EINA_SAFETY_ON_NULL_RETURN_VAL(tw_child, EINA_FALSE);
 391
 392    if (set)
 393      tizen_policy_set_transient_for(tzPolicy,
 394                                     tw_child->native_win,
 395                                     tw_parent->native_win);
 396    else
 397      tizen_policy_unset_transient_for(tzPolicy,
 398                                       tw_child->native_win);
 399
 400    return EINA_TRUE;
 401 }
 402
 403 Eina_Bool
 404 etRunner::setWinTransientForBelow(etWin *tw_child,
 405                                   etWin *tw_parent,
 406                                   Eina_Bool set)
 407 {
 408    Eina_Bool accepted = EINA_FALSE;
 409    Eldbus_Pending *p = NULL;
 410
 411    p = eldbus_proxy_call(dbus.ds_proxy,
 412                          "SetWindowTransientForBelow",
 413                          _cb_method_transient_for_below,
 414                          &accepted,
 415                          -1,
 416                          "uub",
 417                          tw_child->native_win,
 418                          tw_parent->native_win,
 419                          set);
 420    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 421
 422    work();
 423
 424    return accepted;
 425 }
 426
 427 Eina_Bool
 428 etRunner::setWinNotiLevel(etWin *tw,
 429                           efl_util_notification_level_e lv)
 430 {
 431    Eina_Bool res = EINA_FALSE;
 432
 433    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 434
 435    res = efl_util_set_notification_window_level(tw->elm_win, lv);
 436    EINA_SAFETY_ON_FALSE_RETURN_VAL(res == EFL_UTIL_ERROR_NONE, EINA_FALSE);
 437
 438    return EINA_TRUE;
 439 }
 440
 441 efl_util_notification_level_e
 442 etRunner::getWinNotiLevel(etWin *tw)
 443 {
 444    Eina_Bool res = EINA_FALSE;
 445    efl_util_notification_level_e lv = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
 446
 447    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
 448
 449    res = efl_util_get_notification_window_level(tw->elm_win, &lv);
 450    EINA_SAFETY_ON_FALSE_RETURN_VAL(res == EFL_UTIL_ERROR_NONE, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
 451
 452    return lv;
 453 }
 454
 455 Eina_Bool
 456 etRunner::setFocusSkip(etWin *tw, Eina_Bool set)
 457 {
 458    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 459
 460    if (set)
 461      tizen_policy_set_focus_skip(tzPolicy,
 462                                  getWlSurface(tw->elm_win));
 463    else
 464      tizen_policy_unset_focus_skip(tzPolicy,
 465                                    getWlSurface(tw->elm_win));
 466
 467    return EINA_TRUE;
 468 }
 469
 470 Eina_Bool
 471 etRunner::setFocusSkipEcoreWl2(etWin *tw, Eina_Bool set)
 472 {
 473    Ecore_Wl2_Window *wlwin = NULL;
 474
 475    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 476
 477    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(tw->elm_win);
 478    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EINA_FALSE);
 479
 480    ecore_wl2_window_focus_skip_set(wlwin, set);
 481
 482    return EINA_TRUE;
 483 }
 484
 485 Eina_Bool
 486 etRunner::setZoneRotation(int angle)
 487 {
 488    Eldbus_Pending *p = NULL;
 489    Eina_Bool allowed = EINA_FALSE;
 490
 491    p = eldbus_proxy_call(dbus.ds_proxy,
 492                          "ChangeZoneRotation",
 493                          _cb_method_zone_rotation_change,
 494                          &allowed,
 495                          -1,
 496                          "i",
 497                          angle);
 498    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 499
 500    work();
 501
 502    return allowed;
 503 }
 504
 505 Eina_Bool
 506 etRunner::addAuxHint(etWin *tw, int hint_id, const char *hint_key, const char *hint_val)
 507 {
 508    Ecore_Wl2_Window *wlwin = NULL;
 509
 510    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 511
 512    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(tw->elm_win);
 513    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EINA_FALSE);
 514
 515    ecore_wl2_window_aux_hint_add(wlwin, hint_id, hint_key, hint_val);
 516
 517    return EINA_TRUE;
 518 }
 519
 520 Eina_Bool
 521 etRunner::changeAuxHint(etWin *tw, int hint_id, const char *hint_val)
 522 {
 523    Ecore_Wl2_Window *wlwin = NULL;
 524
 525    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 526
 527    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(tw->elm_win);
 528    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EINA_FALSE);
 529
 530    ecore_wl2_window_aux_hint_change(wlwin, hint_id, hint_val);
 531
 532    return EINA_TRUE;
 533 }
 534
 535 Eina_Bool
 536 etRunner::delAuxHint(etWin *tw, int hint_id)
 537 {
 538    Ecore_Wl2_Window *wlwin = NULL;
 539
 540    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 541
 542    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(tw->elm_win);
 543    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EINA_FALSE);
 544
 545    ecore_wl2_window_aux_hint_del(wlwin, hint_id);
 546
 547    return EINA_TRUE;
 548 }
 549
 550 Eina_Bool
 551 etRunner::setTCStart()
 552 {
 553    Eldbus_Pending *p = NULL;
 554    Eina_Bool res = EINA_FALSE;
 555
 556    p = eldbus_proxy_call(dbus.ds_proxy,
 557                          "StartTestCase",
 558                          _cb_method_set_tc_start_end,
 559                          &res,
 560                          -1,
 561                          "");
 562    EINA_SAFETY_ON_NULL_GOTO(p, err);
 563
 564    work();
 565
 566    EINA_SAFETY_ON_FALSE_GOTO(res, err);
 567
 568    return EINA_TRUE;
 569
 570 err:
 571    setTCEnd();
 572    return EINA_FALSE;
 573 }
 574
 575 Eina_Bool
 576 etRunner::setTCEnd()
 577 {
 578    Eldbus_Pending *p = NULL;
 579    Eina_Bool res = EINA_FALSE;
 580
 581    p = eldbus_proxy_call(dbus.ds_proxy,
 582                          "EndTestCase",
 583                          _cb_method_set_tc_start_end,
 584                          &res,
 585                          -1,
 586                          "");
 587    if (p == NULL) res = EINA_FALSE;
 588
 589    work();
 590
 591    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 592
 593    return EINA_TRUE;
 594 }
 595
 596 Eina_Bool
 597 etRunner::setTCTimeout(Eina_Bool set, int timeout)
 598 {
 599    Eldbus_Pending *p = NULL;
 600    Eina_Bool res = EINA_FALSE;
 601
 602    if (timeout < 0) return EINA_FALSE;
 603
 604    p = eldbus_proxy_call(dbus.ds_proxy,
 605                          "SetTestTimeout",
 606                          _cb_method_set_tc_timeout,
 607                          &res,
 608                          -1,
 609                          "bu",
 610                          set,
 611                          timeout);
 612    EINA_SAFETY_ON_NULL_GOTO(p, err);
 613
 614    work();
 615
 616    EINA_SAFETY_ON_FALSE_GOTO(res, err);
 617
 618    return EINA_TRUE;
 619
 620 err:
 621    setTCEnd();
 622    return EINA_FALSE;
 623 }
 624
 625 Eina_Bool
 626 etRunner::getWinInfo(etWin *tw)
 627 {
 628    Eldbus_Pending *p = NULL;
 629    Ecore_Window win;
 630    int retry = 10;
 631
 632    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 633
 634    win = tw->native_win;
 635    retry = (int) win;
 636
 637    while (retry)
 638      {
 639         p = eldbus_proxy_call(dbus.ds_proxy,
 640                               "GetWinInfo",
 641                               _cb_method_win_info_get,
 642                               tw,
 643                               -1,
 644                               "u",
 645                               win);
 646         EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 647
 648         elm_run();
 649
 650         if ((tw->native_win == win) && (!tw->effect))
 651           return EINA_TRUE;
 652         else
 653           retry--;
 654      }
 655
 656    if (tw->native_win != win)
 657      {
 658         ERR("Something Wrong. Difference with quering window"
 659             "and received window from server");
 660         tw->native_win = win;
 661      }
 662
 663    return EINA_FALSE;
 664 }
 665
 666 Eina_List *
 667 etRunner::getWinInfoList()
 668 {
 669    Eldbus_Pending *p = NULL;
 670    Window_Info_List *info_list = NULL;
 671    etWin *tw = NULL;
 672    Eina_List *result = NULL;
 673
 674    info_list = E_NEW(Window_Info_List, 1);
 675    EINA_SAFETY_ON_NULL_RETURN_VAL(info_list, NULL);
 676
 677    while (info_list)
 678      {
 679         p = eldbus_proxy_call(dbus.ds_proxy,
 680                               "GetWinsInfo",
 681                               _cb_method_win_info_list_get,
 682                               info_list,
 683                               -1,
 684                               "");
 685         EINA_SAFETY_ON_NULL_RETURN_VAL(p, NULL);
 686
 687         work();
 688
 689         if (info_list->retry)
 690           {
 691              info_list->retry = EINA_FALSE;
 692              EINA_LIST_CAST_FREE(info_list->list, tw, etWin*)
 693                {
 694                   if (tw)
 695                     delete tw;
 696                }
 697
 698              continue;
 699           }
 700
 701         break;
 702      }
 703
 704    result = eina_list_clone(info_list->list);
 705    E_FREE(info_list);
 706
 707    freeLastWinInfoList();
 708    listWinInfo = result;
 709
 710    return result;
 711 }
 712
 713 void
 714 etRunner::freeWinInfoList(Eina_List *list)
 715 {
 716    etWin *tw = NULL;
 717
 718    EINA_SAFETY_ON_NULL_RETURN(list);
 719
 720    if (listWinInfo == list)
 721      listWinInfo = NULL;
 722
 723    EINA_LIST_CAST_FREE(list, tw, etWin*)
 724      {
 725         if (tw != NULL)
 726           delete tw;
 727      }
 728
 729    list = NULL;
 730 }
 731
 732 void
 733 etRunner::freeLastWinInfoList()
 734 {
 735    if (listWinInfo)
 736      freeWinInfoList(listWinInfo);
 737
 738    listWinInfo = NULL;
 739 }
 740
 741 void
 742 etRunner::setLastWinInfoList(Eina_List *list)
 743 {
 744    EINA_SAFETY_ON_NULL_RETURN(list);
 745
 746    freeLastWinInfoList();
 747
 748    listWinInfo = list;
 749 }
 750
 751 Ecore_Window
 752 etRunner::getWinId(Evas_Object *elm_win)
 753 {
 754    struct wl_surface *surf = NULL;
 755    Ecore_Window id = 0;
 756    struct tizen_resource *tzres = NULL;
 757
 758    surf = getWlSurface(elm_win);
 759    EINA_SAFETY_ON_NULL_RETURN_VAL(surf, 0);
 760
 761    tzres = tizen_surface_get_tizen_resource(tzSurface, surf);
 762    EINA_SAFETY_ON_NULL_RETURN_VAL(tzres, 0);
 763
 764    tizen_resource_add_listener(tzres,
 765                                &_e_test_tizen_resource_listener, &id);
 766
 767    work();
 768
 769    tizen_resource_destroy(tzres);
 770
 771    return id;
 772 }
 773
 774 struct wl_surface *
 775 etRunner::getWlSurface(Evas_Object *elm_win)
 776 {
 777    Ecore_Wl2_Window *wlwin = NULL;
 778    struct wl_surface *surf = NULL;
 779
 780    EINA_SAFETY_ON_NULL_RETURN_VAL(elm_win, NULL);
 781
 782    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(elm_win);
 783    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, NULL);
 784
 785    surf = ecore_wl2_window_surface_get(wlwin);
 786    EINA_SAFETY_ON_NULL_RETURN_VAL(surf, NULL);
 787
 788    return surf;
 789 }
 790
 791 Eina_Bool
 792 etRunner::setDpms(Eina_Bool on)
 793 {
 794    Eldbus_Pending *p = NULL;
 795    p = eldbus_proxy_call(dbus.ds_proxy,
 796                          "DPMS",
 797                          NULL,
 798                          NULL,
 799                          -1,
 800                          "u",
 801                          on);
 802    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 803    return EINA_TRUE;
 804 }
 805
 806 Eina_Bool
 807 etRunner::setDevctlDisplayLock(Eina_Bool lock)
 808 {
 809    Eldbus_Pending *p = NULL;
 810
 811    if (lock)
 812      {
 813         p = eldbus_proxy_call(dbus.deviced_proxy,
 814                               "lockstate",
 815                               NULL,
 816                               NULL,
 817                               -1,
 818                               "sssi",
 819                               "lcdon",
 820                               "gotostatenow",
 821                               "holdkeyblock",
 822                               "0");
 823      }
 824    else
 825      {
 826         p = eldbus_proxy_call(dbus.deviced_proxy,
 827                               "unlockstate",
 828                               NULL,
 829                               NULL,
 830                               -1,
 831                               "ss",
 832                               "lcdon",
 833                               "resettimer");
 834      }
 835    EINA_SAFETY_ON_TRUE_RETURN_VAL(p != NULL, EINA_FALSE);
 836
 837    return EINA_TRUE;
 838 }
 839
 840 Eina_Bool
 841 etRunner::setDevctlDisplayOn(Eina_Bool on)
 842 {
 843    Eldbus_Pending *p = NULL;
 844
 845    p = eldbus_proxy_call(dbus.deviced_proxy,
 846                          "changestate",
 847                          NULL,
 848                          NULL,
 849                          -1,
 850                          "s",
 851                          on? "lcdon" : "lcdoff");
 852    EINA_SAFETY_ON_TRUE_RETURN_VAL(p != NULL, EINA_FALSE);
 853
 854    return EINA_TRUE;
 855 }
 856
 857 Eina_Bool
 858 etRunner::feedMouseDown(int x, int y)
 859 {
 860    Eldbus_Pending *p = NULL;
 861    p = eldbus_proxy_call(dbus.ds_proxy,
 862                          "EventMouse",
 863                          NULL,
 864                          NULL,
 865                          -1,
 866                          "uii",
 867                          0,
 868                          x, y);
 869    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 870    return EINA_TRUE;
 871 }
 872
 873 Eina_Bool
 874 etRunner::feedMouseMove(int x, int y)
 875 {
 876    Eldbus_Pending *p = NULL;
 877    p = eldbus_proxy_call(dbus.ds_proxy,
 878                          "EventMouse",
 879                          NULL,
 880                          NULL,
 881                          -1,
 882                          "uii",
 883                          1,
 884                          x, y);
 885    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 886    return EINA_TRUE;
 887 }
 888
 889 Eina_Bool
 890 etRunner::feedMouseUp(int x, int y)
 891 {
 892    Eldbus_Pending *p = NULL;
 893    p = eldbus_proxy_call(dbus.ds_proxy,
 894                          "EventMouse",
 895                          NULL,
 896                          NULL,
 897                          -1,
 898                          "uii",
 899                          2,
 900                          x, y);
 901    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 902    return EINA_TRUE;
 903 }
 904
 905 Eina_Bool
 906 etRunner::feedKeyDown(const char *key)
 907 {
 908    Eldbus_Pending *p = NULL;
 909    p = eldbus_proxy_call(dbus.ds_proxy,
 910                          "EventKey",
 911                          NULL,
 912                          NULL,
 913                          -1,
 914                          "us",
 915                          0,
 916                          key);
 917    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 918    return EINA_TRUE;
 919 }
 920
 921 Eina_Bool
 922 etRunner::feedKeyUp(const char *key)
 923 {
 924    Eldbus_Pending *p = NULL;
 925    p = eldbus_proxy_call(dbus.ds_proxy,
 926                          "EventKey",
 927                          NULL,
 928                          NULL,
 929                          -1,
 930                          "us",
 931                          1,
 932                          key);
 933    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 934    return EINA_TRUE;
 935 }
 936
 937 Eina_Bool
 938 etRunner::generateMouseDown(int x, int y)
 939 {
 940    // Using efl_util_input_generate instead of generate event by eldbus
 941    int ret = EFL_UTIL_ERROR_NONE;
 942
 943    if (inputGenerator == NULL)
 944      {
 945         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
 946         work();
 947      }
 948
 949    ret = efl_util_input_generate_touch(inputGenerator,
 950                                        0,
 951                                        EFL_UTIL_INPUT_TOUCH_BEGIN,
 952                                        x, y);
 953    if (ret != EFL_UTIL_ERROR_NONE)
 954      {
 955         efl_util_input_deinitialize_generator(inputGenerator);
 956         inputGenerator = NULL;
 957         return EINA_FALSE;
 958      }
 959
 960    return EINA_TRUE;
 961 }
 962
 963 Eina_Bool
 964 etRunner::generateMouseMove(int x, int y)
 965 {
 966    // Using efl_util_input_generate instead of generate event by eldbus
 967    int ret = EFL_UTIL_ERROR_NONE;
 968
 969    if (inputGenerator == NULL)
 970      {
 971         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
 972         work();
 973      }
 974
 975    ret = efl_util_input_generate_touch(inputGenerator,
 976                                        0,
 977                                        EFL_UTIL_INPUT_TOUCH_UPDATE,
 978                                        x, y);
 979    if (ret != EFL_UTIL_ERROR_NONE)
 980      {
 981         efl_util_input_deinitialize_generator(inputGenerator);
 982         inputGenerator = NULL;
 983         return EINA_FALSE;
 984      }
 985
 986    return EINA_TRUE;
 987 }
 988
 989 Eina_Bool
 990 etRunner::generateMouseUp(int x, int y)
 991 {
 992    // Using efl_util_input_generate instead of generate event by eldbus
 993    int ret = EFL_UTIL_ERROR_NONE;
 994
 995    if (inputGenerator == NULL)
 996      {
 997         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
 998         work();
 999      }
1000
1001    ret = efl_util_input_generate_touch(inputGenerator,
1002                                        0,
1003                                        EFL_UTIL_INPUT_TOUCH_END,
1004                                        x, y);
1005    if (ret != EFL_UTIL_ERROR_NONE)
1006      {
1007         efl_util_input_deinitialize_generator(inputGenerator);
1008         inputGenerator = NULL;
1009         return EINA_FALSE;
1010      }
1011
1012    return EINA_TRUE;
1013 }
1014
1015 Eina_Bool
1016 etRunner::generateKeyPress(const char *keyname)
1017 {
1018    // Using efl_util_input_generate instead of generate event by eldbus
1019    int ret = EFL_UTIL_ERROR_NONE;
1020
1021    if (inputGenerator == NULL)
1022      {
1023         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, NULL);
1024         work();
1025      }
1026
1027    ret = efl_util_input_generate_key(inputGenerator,
1028                                        keyname,
1029                                        1);
1030    if (ret != EFL_UTIL_ERROR_NONE)
1031      {
1032         efl_util_input_deinitialize_generator(inputGenerator);
1033         inputGenerator = NULL;
1034         return EINA_FALSE;
1035      }
1036
1037    return EINA_TRUE;
1038 }
1039
1040 Eina_Bool
1041 etRunner::generateKeyRelease(const char *keyname)
1042 {
1043    // Using efl_util_input_generate instead of generate event by eldbus
1044    int ret = EFL_UTIL_ERROR_NONE;
1045
1046    if (inputGenerator == NULL)
1047      {
1048         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, NULL);
1049         work();
1050      }
1051
1052    ret = efl_util_input_generate_key(inputGenerator,
1053                                        keyname,
1054                                        0);
1055    if (ret != EFL_UTIL_ERROR_NONE)
1056      {
1057         efl_util_input_deinitialize_generator(inputGenerator);
1058         inputGenerator = NULL;
1059         return EINA_FALSE;
1060      }
1061
1062    return EINA_TRUE;
1063 }
1064
1065 Eina_Bool
1066 etRunner::generateKeyEvent(const char *keyname, double delay)
1067 {
1068    Eina_Bool res = EINA_FALSE;
1069
1070    res = etRunner::get().generateKeyPress(keyname);
1071    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
1072
1073    res = etRunner::get().generateKeyRelease(keyname);
1074    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
1075
1076    return res;
1077 }
1078
1079 Eina_Bool
1080 etRunner::generateTouchDown(int idx, int x, int y)
1081 {
1082    // Using efl_util_input_generate instead of generate event by eldbus
1083    int ret = EFL_UTIL_ERROR_NONE;
1084
1085    if (inputGenerator == NULL)
1086      {
1087         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
1088         work();
1089      }
1090
1091    ret = efl_util_input_generate_touch(inputGenerator,
1092                                        idx,
1093                                        EFL_UTIL_INPUT_TOUCH_BEGIN,
1094                                        x, y);
1095    if (ret != EFL_UTIL_ERROR_NONE)
1096      {
1097         efl_util_input_deinitialize_generator(inputGenerator);
1098         inputGenerator = NULL;
1099         return EINA_FALSE;
1100      }
1101
1102    return EINA_TRUE;
1103 }
1104
1105 Eina_Bool
1106 etRunner::generateTouchMove(int idx, int x, int y)
1107 {
1108    // Using efl_util_input_generate instead of generate event by eldbus
1109    int ret = EFL_UTIL_ERROR_NONE;
1110
1111    if (inputGenerator == NULL)
1112      {
1113         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
1114         work();
1115      }
1116
1117    ret = efl_util_input_generate_touch(inputGenerator,
1118                                        idx,
1119                                        EFL_UTIL_INPUT_TOUCH_UPDATE,
1120                                        x, y);
1121    if (ret != EFL_UTIL_ERROR_NONE)
1122      {
1123         efl_util_input_deinitialize_generator(inputGenerator);
1124         inputGenerator = NULL;
1125         return EINA_FALSE;
1126      }
1127
1128    return EINA_TRUE;
1129 }
1130
1131 Eina_Bool
1132 etRunner::generateTouchUp(int idx, int x, int y)
1133 {
1134    // Using efl_util_input_generate instead of generate event by eldbus
1135    int ret = EFL_UTIL_ERROR_NONE;
1136
1137    if (inputGenerator == NULL)
1138      {
1139         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
1140         work();
1141      }
1142
1143    ret = efl_util_input_generate_touch(inputGenerator,
1144                                        idx,
1145                                        EFL_UTIL_INPUT_TOUCH_END,
1146                                        x, y);
1147    if (ret != EFL_UTIL_ERROR_NONE)
1148      {
1149         efl_util_input_deinitialize_generator(inputGenerator);
1150         inputGenerator = NULL;
1151         return EINA_FALSE;
1152      }
1153
1154    return EINA_TRUE;
1155 }
1156
1157 Eina_Bool
1158 etRunner::setSplashLaunch(const char *path, int type)
1159 {
1160    const char *effect_type = "launch";
1161    struct wl_array option;
1162
1163    // init tzlaunch_splash
1164    if (tzlaunch_splash)
1165      {
1166         tizen_launch_splash_destroy(tzlaunch_splash);
1167         tzlaunch_splash = NULL;
1168      }
1169    if (tzlaunch_effect) tzlaunch_splash = tizen_launch_effect_create_splash_img(tzlaunch_effect);
1170    EINA_SAFETY_ON_NULL_RETURN_VAL(tzlaunch_splash, EINA_FALSE);
1171
1172    wl_array_init(&option);
1173    tizen_launch_splash_launch(tzlaunch_splash, path, type,
1174                               24, 0, 0,
1175                               effect_type, NULL, &option);
1176    wl_array_release(&option);
1177
1178    return EINA_TRUE;
1179 }
1180
1181 Eina_Bool
1182 etRunner::setSplashOwner()
1183 {
1184
1185    EINA_SAFETY_ON_NULL_RETURN_VAL(tzlaunch_splash, EINA_FALSE);
1186
1187    tizen_launch_splash_owner(tzlaunch_splash, (int)getpid());
1188
1189    return EINA_TRUE;
1190 }
1191
1192 Eina_Bool
1193 etRunner::setWinEffect(etWin *tw)
1194 {
1195    Eldbus_Pending *p = NULL;
1196    Eina_Bool accepted = EINA_FALSE;
1197
1198    this->ev.elm_win = tw->elm_win;
1199
1200    p = eldbus_proxy_call(dbus.ds_proxy,
1201                          "RenderTrace",
1202                          _cb_method_window_effect,
1203                          &accepted,
1204                          -1,
1205                          "us",
1206                          tw->native_win,
1207                          "effect");
1208    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1209
1210    work();
1211    return accepted;
1212 }
1213
1214 Eina_Bool
1215 etRunner::freezeEvent()
1216 {
1217    Eldbus_Pending *p = NULL;
1218    p = eldbus_proxy_call(dbus.ds_proxy,
1219                          "EventFreeze",
1220                          NULL,
1221                          NULL,
1222                          -1,
1223                          "u",
1224                          1);
1225    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1226    return EINA_TRUE;
1227 }
1228
1229 Eina_Bool
1230 etRunner::thawEvent()
1231 {
1232    Eldbus_Pending *p = NULL;
1233    p = eldbus_proxy_call(dbus.ds_proxy,
1234                          "EventFreeze",
1235                          NULL,
1236                          NULL,
1237                          -1,
1238                          "u",
1239                          0);
1240    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1241    return EINA_TRUE;
1242 }
1243
1244 Eina_Bool
1245 etRunner::addSupportedAuxHint(const char *hint)
1246 {
1247    Eldbus_Pending *p = NULL;
1248    p = eldbus_proxy_call(dbus.ds_proxy,
1249                          "AddSupportedAuxHint",
1250                          NULL,
1251                          NULL,
1252                          -1,
1253                          "s",
1254                          hint);
1255    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1256    return EINA_TRUE;
1257 }
1258
1259 Eina_Bool
1260 etRunner::delSupportedAuxHint(const char *hint)
1261 {
1262    Eldbus_Pending *p = NULL;
1263    p = eldbus_proxy_call(dbus.ds_proxy,
1264                          "DelSupportedAuxHint",
1265                          NULL,
1266                          NULL,
1267                          -1,
1268                          "s",
1269                          hint);
1270    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1271    return EINA_TRUE;
1272 }
1273
1274 std::shared_ptr<auxHintEventItem>
1275 etRunner::getAuxHint(etWin *tw, const char *hint_key)
1276 {
1277    Eldbus_Pending *p = NULL;
1278    auxHintEventItem *hint = NULL;
1279
1280    p = eldbus_proxy_call(dbus.ds_proxy,
1281                          "GetAuxHint",
1282                          _cb_method_aux_hint_get,
1283                          &hint,
1284                          -1,
1285                          "us",
1286                          tw->native_win,
1287                          hint_key);
1288    EINA_SAFETY_ON_NULL_RETURN_VAL(p, nullptr);
1289
1290    work();
1291
1292    if (hint)
1293      {
1294         std::shared_ptr<auxHintEventItem> shared_hint = std::make_shared<auxHintEventItem>(tw->native_win, E_TC_EVENT_TYPE_AUX_HINT_CHANGED, hint->getID(), hint->getHint().c_str(), hint->getVal().c_str());
1295         delete hint;
1296         return shared_hint;
1297      }
1298
1299    return NULL;
1300 }
1301
1302 std::shared_ptr<eventItem>
1303 etRunner::waitEvent(etWin *win, E_TC_Event_Type ev_type)
1304 {
1305    std::shared_ptr<eventItem> recv_item = NULL;
1306    std::list<std::shared_ptr<eventItem>>::iterator itr;
1307
1308    // swap event
1309    switch (ev_type)
1310      {
1311       case E_TC_EVENT_TYPE_VIS_ON:
1312       case E_TC_EVENT_TYPE_VIS_OFF:
1313       case E_TC_EVENT_TYPE_VIS_CHANGED:
1314          ev_type = E_TC_EVENT_TYPE_VIS_CHANGED;
1315          break;
1316       case E_TC_EVENT_TYPE_STACK_RAISE:
1317       case E_TC_EVENT_TYPE_STACK_LOWER:
1318       case E_TC_EVENT_TYPE_STACK_ABOVE:
1319       case E_TC_EVENT_TYPE_STACK_BELOW:
1320       case E_TC_EVENT_TYPE_STACK_CHANGED:
1321          ev_type = E_TC_EVENT_TYPE_STACK_CHANGED;
1322          break;
1323       default:
1324          break;
1325      }
1326
1327    // Add event callbacks if needs
1328    if (ev_type == E_TC_EVENT_TYPE_EFFECT_EVAS_CB)
1329      {
1330         ev.elm_win = win->elm_win;
1331         ev.native_win = win->native_win;
1332         ev.effect.state_smcb = E_TC_EVAS_SMART_CB_STATE_NONE;
1333
1334         evas_object_smart_callback_add(this->ev.elm_win, effect_started, _cb_evas_smart_cb_effect_started, this);
1335         evas_object_smart_callback_add(this->ev.elm_win, effect_done, _cb_evas_smart_cb_effect_done, this);
1336         evas_object_smart_callback_add(this->ev.elm_win, launch_done, _cb_evas_smart_cb_launch_done, this);
1337      }
1338    else if (ev_type == E_TC_EVENT_TYPE_INPUT_EVAS_KEY)
1339      {
1340         ev.elm_win = win->elm_win;
1341         ev.native_win = win->native_win;
1342         evas_object_event_callback_add(this->ev.elm_win, EVAS_CALLBACK_KEY_DOWN, _cb_evas_key_down, this);
1343         evas_object_event_callback_add(this->ev.elm_win, EVAS_CALLBACK_KEY_UP, _cb_evas_key_up, this);
1344
1345         ev.key.evas_state = EINA_FALSE;
1346      }
1347
1348    // pre-waiting events
1349    work(0.5);
1350
1351    if (*ev.wait_event_index == ev.last_event)
1352      {
1353         work(0.5); // waiting additional time
1354         if (*ev.wait_event_index == ev.last_event)
1355         {
1356            std::shared_ptr<eventItem> res = std::make_shared<eventItem>(0, E_TC_EVENT_TYPE_NONE);
1357            res->result = EINA_FALSE;
1358            res->isTimeout = EINA_TRUE;
1359           return res;
1360         }
1361      }
1362
1363    // search from latest waitEvent called point
1364    itr = ev.wait_event_index;
1365    if (itr == ev.recv_queue.end()) itr = ev.recv_queue.begin();
1366    else itr++;
1367
1368    for (; itr != ev.recv_queue.end() ; itr++)
1369      {
1370         recv_item = *itr;
1371         if ((recv_item->isSameWin(win?win->native_win:0)) &&
1372             (recv_item->isSameType(ev_type)))
1373           {
1374              ev.wait_event_index = itr;
1375              recv_item->result = EINA_TRUE;
1376              return recv_item;
1377           }
1378      }
1379
1380    if (recv_item == NULL)
1381    {
1382       recv_item = std::make_shared<eventItem>(0, E_TC_EVENT_TYPE_NONE);
1383       recv_item->result = EINA_FALSE;
1384    }
1385    return recv_item;
1386 }
1387
1388 void
1389 etRunner::flushEventQueue()
1390 {
1391    std::list<std::shared_ptr<eventItem>>::iterator itr;
1392    std::shared_ptr<eventItem> ei = NULL;
1393    if (!ev.recv_queue.empty())
1394         ev.recv_queue.erase(ev.recv_queue.begin(), ev.recv_queue.end());
1395    ev.wait_event_index = ev.recv_queue.end();
1396    ev.last_event = NULL;
1397    ev.last_checkpoint = NULL;
1398 }
1399
1400 Eina_Bool
1401 etRunner::insertEventQueue(std::shared_ptr<eventItem> ei)
1402 {
1403    EINA_SAFETY_ON_NULL_RETURN_VAL(ei, EINA_FALSE);
1404
1405    ev.recv_queue.push_back(ei);
1406    ev.last_event = ei;
1407
1408    return EINA_TRUE;
1409 }
1410
1411 Eina_Bool
1412 etRunner::insertEventQueue(Ecore_Window id, E_TC_Event_Type ev_type)
1413 {
1414    std::shared_ptr<eventItem> ei = std::make_shared<eventItem>(id, ev_type);
1415    EINA_SAFETY_ON_NULL_RETURN_VAL(ei, EINA_FALSE);
1416
1417    ev.recv_queue.push_back(ei);
1418    ev.last_event = ei;
1419
1420    return EINA_TRUE;
1421 }
1422
1423 Eina_Bool
1424 etRunner::isEventOccuredAfterCheckpoint(etWin *tw, E_TC_Event_Type ev_type)
1425 {
1426    std::list<std::shared_ptr<eventItem>>::iterator itr;
1427    std::shared_ptr<eventItem> ei = NULL;
1428    Ecore_Window id = tw->native_win;
1429
1430    for(itr = ev.recv_queue.begin() ; itr != ev.recv_queue.end() ; itr++)
1431      {
1432         ei = *itr;
1433
1434         if (ev.last_checkpoint && ev.last_checkpoint != ei)
1435           continue;
1436
1437         if (ei->isSameWin(id) && ei->isSameType(ev_type))
1438           return EINA_TRUE;
1439      }
1440
1441    return EINA_FALSE;
1442 }
1443
1444 void
1445 etRunner::setEventCheckpoint()
1446 {
1447    ev.last_checkpoint = ev.last_event;
1448    return;
1449 }
1450
1451 Eina_Bool
1452 etRunner::addSignalHandlers()
1453 {
1454    Eldbus_Signal_Handler *sh = NULL;
1455    Ecore_Event_Handler *eh = NULL;
1456
1457    flushEventQueue();
1458
1459    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1460                                         "VisibilityChanged",
1461                                         _cb_signal_vis_changed,
1462                                         this);
1463    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1464    ev.sh_list = eina_list_append(ev.sh_list, sh);
1465
1466    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1467                                         "StackChanged",
1468                                         _cb_signal_stack_changed,
1469                                         this);
1470    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1471    ev.sh_list = eina_list_append(ev.sh_list, sh);
1472
1473    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1474                                         "WinRotationChanged",
1475                                         _cb_signal_win_rot_changed,
1476                                         this);
1477    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1478    ev.sh_list = eina_list_append(ev.sh_list, sh);
1479
1480    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1481                                         "FocusChanged",
1482                                         _cb_signal_focus_changed,
1483                                         this);
1484    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1485    ev.sh_list = eina_list_append(ev.sh_list, sh);
1486
1487    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1488                                         "RenderRun",
1489                                         _cb_signal_render_while_effect_run,
1490                                         this);
1491    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1492    ev.sh_list = eina_list_append(ev.sh_list, sh);
1493
1494    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1495                                         "AuxHintChanged",
1496                                         _cb_signal_aux_hint_changed,
1497                                         this);
1498    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1499    ev.sh_list = eina_list_append(ev.sh_list, sh);
1500
1501    eh = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, _cb_ecore_key_down, this);
1502    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1503    ev.eh_list = eina_list_append(ev.eh_list, eh);
1504
1505    eh = ecore_event_handler_add(ECORE_EVENT_KEY_UP, _cb_ecore_key_up, this);
1506    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1507    ev.eh_list = eina_list_append(ev.eh_list, eh);
1508
1509    eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_TAP, _cb_gesture_tap, this);
1510    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1511    ev.eh_list = eina_list_append(ev.eh_list, eh);
1512
1513    eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE, _cb_gesture_edge_swipe, this);
1514    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1515    ev.eh_list = eina_list_append(ev.eh_list, eh);
1516
1517    eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_EDGE_DRAG, _cb_gesture_edge_drag, this);
1518    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1519    ev.eh_list = eina_list_append(ev.eh_list, eh);
1520
1521    ev.key.ecore_state = EINA_FALSE;
1522
1523    return EINA_TRUE;
1524
1525 err:
1526    printf("failed to init handlers\n");
1527    delSignalHandlers();
1528    return EINA_FALSE;
1529 }
1530
1531 void
1532 etRunner::delSignalHandlers()
1533 {
1534    Eldbus_Signal_Handler *sh = NULL;
1535    Ecore_Event_Handler *eh = NULL;
1536
1537    EINA_LIST_CAST_FREE(ev.sh_list, sh, Eldbus_Signal_Handler*)
1538      {
1539         eldbus_signal_handler_del(sh);
1540      }
1541
1542    EINA_LIST_CAST_FREE(ev.eh_list, eh, Ecore_Event_Handler*)
1543      {
1544         ecore_event_handler_del(eh);
1545      }
1546
1547    flushEventQueue();
1548 }
1549
1550 void
1551 etRunner::work()
1552 {
1553    /* give a turn to deal with deferred job for given time*/
1554    addTimer(worker.waitTime);
1555    elm_run();
1556 }
1557
1558 void
1559 etRunner::work(double time)
1560 {
1561    /* give a turn to deal with deferred job for given time*/
1562    if (time < 0.0) time = 0.0;
1563
1564    addTimer(time);
1565    elm_run();
1566 }
1567
1568 void
1569 etRunner::finishWork()
1570 {
1571    if (worker.timer)
1572      delTimer();
1573
1574    elm_exit();
1575 }
1576
1577 void
1578 etRunner::printWinInfoList()
1579 {
1580    etWin *tw = NULL;
1581    Eina_List *l = NULL, *ll = NULL;
1582
1583    printf("--------------------------------------------------------------------------------------------------------------------------\n");
1584    l = getWinInfoList();
1585    EINA_LIST_CAST_FOREACH(l, ll, tw, etWin*)
1586      {
1587         printf("%04d WinID:%5u alpha:%d %5d,%5d (%5dx%5d) vis(Win:%d Obj:%d Opaque:%2d Type:%2d Skip:%d) Icon:%d Focus(Win:%d Obj:%d) :: %20s\n",
1588                tw->layer,
1589                (unsigned int)tw->native_win,
1590                tw->alpha,
1591                tw->x, tw->y, tw->w, tw->h,
1592                tw->Vis.win,
1593                tw->Vis.obj,
1594                tw->Vis.opaque,
1595                tw->Vis.type,
1596                tw->Vis.skip,
1597                tw->iconic,
1598                tw->Focus.win,
1599                tw->Focus.obj,
1600                tw->name);
1601      }
1602    freeWinInfoList(l);
1603    printf("--------------------------------------------------------------------------------------------------------------------------\n");
1604 }
1605
1606 void
1607 etRunner::delTimer()
1608 {
1609    if (!worker.timer) return;
1610
1611    ecore_timer_del(worker.timer);
1612    worker.timer = NULL;
1613 }
1614
1615 void
1616 etRunner::addTimer()
1617 {
1618    delTimer();
1619
1620    worker.timer = ecore_timer_add(worker.waitTime,
1621                                   _cb_work_timeout,
1622                                   this);
1623 }
1624
1625 void
1626 etRunner::addTimer(double time)
1627 {
1628    delTimer();
1629
1630    worker.timer = ecore_timer_add(time,
1631                                   _cb_work_timeout,
1632                                   this);
1633 }
1634
1635 void
1636 etRunner::waitForDestroy()
1637 {
1638    work(E_TEST_WORK_TIME);
1639 }
1640
1641 Eina_Bool
1642 etRunner::initProtocols()
1643 {
1644    Eina_Iterator *globals = NULL;
1645    Ecore_Wl2_Global *global = NULL;
1646    struct wl_registry *registry = NULL;
1647
1648    registry = ecore_wl2_display_registry_get(ecore_wl2_connected_display_get(NULL));
1649    globals = ecore_wl2_display_globals_get(ecore_wl2_connected_display_get(NULL));
1650
1651    EINA_SAFETY_ON_NULL_GOTO(registry, err);
1652    EINA_SAFETY_ON_NULL_GOTO(globals, err);
1653
1654    EINA_ITERATOR_FOREACH(globals, global)
1655      {
1656         if (!strcmp(global->interface, "tizen_policy"))
1657           {
1658              tzPolicy = (struct tizen_policy *)
1659                 wl_registry_bind(registry,
1660                                  global->id,
1661                                  &tizen_policy_interface,
1662                                  (global->version > 7)? 7 : global->version);
1663           }
1664         if (!strcmp(global->interface, "tizen_surface"))
1665           {
1666              tzSurface = (struct tizen_surface *)
1667                 wl_registry_bind(registry,
1668                                  global->id,
1669                                  &tizen_surface_interface,
1670                                  (global->version > 1)? 1 : global->version);
1671           }
1672         if (!strcmp(global->interface, "tizen_launch_effect"))
1673           {
1674              tzlaunch_effect = (struct tizen_launch_effect *)
1675                 wl_registry_bind(registry,
1676                                  global->id,
1677                                  &tizen_launch_effect_interface,
1678                                  (global->version > 1)? 1 : global->version);
1679           }
1680         if (!strcmp(global->interface, "wl_output"))
1681           {
1682              wlOutput = (struct wl_output *)
1683                 wl_registry_bind(registry,
1684                                  global->id,
1685                                  &wl_output_interface,
1686                                  (global->version > 2)? 2 : global->version);
1687              wl_output_add_listener(wlOutput, &_e_test_output_listener, NULL);
1688
1689              work();
1690
1691              if (wlOutput)
1692                {
1693                   wl_output_destroy(wlOutput);
1694                   wlOutput = NULL;
1695                }
1696           }
1697      }
1698
1699    EINA_SAFETY_ON_NULL_GOTO(tzPolicy, err);
1700    EINA_SAFETY_ON_NULL_GOTO(tzSurface, err);
1701    EINA_SAFETY_ON_NULL_GOTO(tzlaunch_effect, err);
1702
1703    eina_iterator_free(globals);
1704    return EINA_TRUE;
1705
1706 err:
1707    if (globals)
1708      eina_iterator_free(globals);
1709    return EINA_FALSE;
1710 }
1711
1712 /* callbacks - method */
1713 static void
1714 _cb_method_win_info_get(void *data,
1715                         const Eldbus_Message *msg,
1716                         Eldbus_Pending *p)
1717 {
1718    const char *name = NULL, *text = NULL, *wname = NULL;
1719    etWin *tw = NULL;
1720    Eina_Bool res = EINA_FALSE;
1721
1722    tw = (etWin *)data;
1723
1724    res = eldbus_message_error_get(msg, &name, &text);
1725    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1726
1727    res = eldbus_message_arguments_get
1728       (msg,
1729        E_TC_SIGN_WIN_INFO,
1730        &tw->native_win,
1731        &wname,
1732        &tw->x, &tw->y, &tw->w, &tw->h,
1733        &tw->layer,
1734        &tw->effect,
1735        &tw->Vis.win,
1736        &tw->Vis.obj,
1737        &tw->Vis.opaque,
1738        &tw->Vis.type,
1739        &tw->Vis.skip,
1740        &tw->iconic,
1741        &tw->alpha,
1742        &tw->Focus.win,
1743        &tw->Focus.obj,
1744        &tw->rot);
1745
1746    if (wname)
1747      {
1748         // change window name from char * to Eina_Stringshare
1749         if (tw->name)
1750           eina_stringshare_del(tw->name);
1751         tw->name = eina_stringshare_add(wname);
1752      }
1753
1754 finish:
1755    if ((name) || (text))
1756      {
1757         ERR("errname:%s errmsg:%s\n", name, text);
1758      }
1759
1760    etRunner::get().finishWork();
1761 }
1762
1763 static void
1764 _cb_method_win_info_list_get(void *data,
1765                              const Eldbus_Message *msg,
1766                              Eldbus_Pending *p)
1767 {
1768    const char *name = NULL, *text = NULL, *wname = NULL;
1769    Eldbus_Message_Iter *array = NULL, *ec = NULL;
1770    Window_Info_List *info_list = (Window_Info_List *)data;
1771    Eina_Bool res = EINA_FALSE, animating = EINA_FALSE;
1772
1773    if (info_list == NULL)
1774      goto finish;
1775
1776    res = eldbus_message_error_get(msg, &name, &text);
1777    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1778
1779    res = eldbus_message_arguments_get(msg, "a(" E_TC_SIGN_WIN_INFO ")", &array);
1780    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1781
1782    while (eldbus_message_iter_get_and_next(array, 'r', &ec))
1783      {
1784         etWin *tw = new etWin();
1785         if (!tw) continue;
1786
1787         res = eldbus_message_iter_arguments_get(
1788            ec,
1789            E_TC_SIGN_WIN_INFO,
1790            &tw->native_win,
1791            &wname,
1792            &tw->x, &tw->y, &tw->w, &tw->h,
1793            &tw->layer,
1794            &tw->effect,
1795            &tw->Vis.win,
1796            &tw->Vis.obj,
1797            &tw->Vis.opaque,
1798            &tw->Vis.type,
1799            &tw->Vis.skip,
1800            &tw->iconic,
1801            &tw->alpha,
1802            &tw->Focus.win,
1803            &tw->Focus.obj,
1804            &tw->rot);
1805
1806         if (wname)
1807           {
1808              // change name to eina_stringshare
1809              if (tw->name)
1810                {
1811                   WRN("Failed to get win info\n");
1812                   delete tw;
1813                   continue;
1814                }
1815              tw->name = eina_stringshare_add(wname);
1816           }
1817
1818         if (tw->effect)
1819           animating = EINA_TRUE;
1820
1821         if (!res)
1822           {
1823              WRN("Failed to get win info\n");
1824              delete tw;
1825              continue;
1826           }
1827
1828         info_list->list = eina_list_append(info_list->list, tw);
1829      }
1830
1831    if (animating)
1832      info_list->retry = EINA_TRUE;
1833
1834 finish:
1835    if ((name) || (text))
1836      {
1837         ERR("errname:%s errmsg:%s\n", name, text);
1838      }
1839
1840    etRunner::get().finishWork();
1841 }
1842
1843 static void
1844 _cb_method_window_register(void *data,
1845                            const Eldbus_Message *msg,
1846                            Eldbus_Pending *p)
1847 {
1848    const char *name = NULL, *text = NULL;
1849    Eina_Bool res = EINA_FALSE;
1850    Eina_Bool *accepted = (Eina_Bool *)data;
1851
1852    *accepted = EINA_FALSE;
1853
1854    res = eldbus_message_error_get(msg, &name, &text);
1855    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1856
1857    res = eldbus_message_arguments_get(msg, "b", accepted);
1858
1859 finish:
1860    if ((name) || (text))
1861      {
1862         ERR("errname: %s errmsg: %s\n", name, text);
1863      }
1864
1865    etRunner::get().finishWork();
1866 }
1867
1868 static void
1869 _cb_method_zone_rotation_change(void *data,
1870                                 const Eldbus_Message *msg,
1871                                 Eldbus_Pending *p)
1872 {
1873    const char *name = NULL, *text = NULL;
1874    Eina_Bool res = EINA_FALSE;
1875    Eina_Bool *allowed = (Eina_Bool *)data;
1876
1877    *allowed = EINA_FALSE;
1878
1879    res = eldbus_message_error_get(msg, &name, &text);
1880    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1881
1882    res = eldbus_message_arguments_get(msg, "b", allowed);
1883    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1884    EINA_SAFETY_ON_FALSE_GOTO(*allowed, finish);
1885
1886 finish:
1887    if ((name) || (text))
1888      {
1889         ERR("errname: %s errmsg: %s\n", name, text);
1890      }
1891
1892    etRunner::get().finishWork();
1893 }
1894
1895 static void
1896 _cb_method_window_effect(void *data,
1897                                 const Eldbus_Message *msg,
1898                                 Eldbus_Pending *p)
1899 {
1900    const char *name = NULL, *text = NULL;
1901    Eina_Bool res = EINA_FALSE;
1902    Eina_Bool *allowed = (Eina_Bool *)data;
1903
1904    *allowed = EINA_FALSE;
1905
1906    res = eldbus_message_error_get(msg, &name, &text);
1907    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1908
1909    res = eldbus_message_arguments_get(msg, "b", allowed);
1910    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1911    EINA_SAFETY_ON_FALSE_GOTO(*allowed, finish);
1912
1913 finish:
1914    if ((name) || (text))
1915      {
1916         ERR("errname: %s errmsg: %s\n", name, text);
1917      }
1918
1919    etRunner::get().finishWork();
1920 }
1921
1922 static void
1923 _cb_method_set_tc_start_end(void *data,
1924                             const Eldbus_Message *msg,
1925                             Eldbus_Pending *p)
1926 {
1927    const char *name = NULL, *text = NULL;
1928    Eina_Bool res = EINA_FALSE;
1929    Eina_Bool *accept = (Eina_Bool *)data;
1930
1931    *accept = EINA_FALSE;
1932
1933    res = eldbus_message_error_get(msg, &name, &text);
1934    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1935
1936    res = eldbus_message_arguments_get(msg, "b", accept);
1937    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1938    EINA_SAFETY_ON_FALSE_GOTO(*accept, finish);
1939
1940 finish:
1941    if ((name) || (text))
1942      {
1943         ERR("errname: %s errmsg: %s\n", name, text);
1944      }
1945
1946    etRunner::get().finishWork();
1947 }
1948
1949 static void
1950 _cb_method_set_tc_timeout(void *data,
1951                           const Eldbus_Message *msg,
1952                           Eldbus_Pending *p)
1953 {
1954    const char *name = NULL, *text = NULL;
1955    Eina_Bool res = EINA_FALSE;
1956    Eina_Bool *accept = (Eina_Bool *)data;
1957
1958    *accept = EINA_FALSE;
1959
1960    res = eldbus_message_error_get(msg, &name, &text);
1961    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1962
1963    res = eldbus_message_arguments_get(msg, "b", accept);
1964    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1965    EINA_SAFETY_ON_FALSE_GOTO(*accept, finish);
1966
1967 finish:
1968    if ((name) || (text))
1969      {
1970         ERR("errname: %s errmsg: %s\n", name, text);
1971      }
1972
1973    etRunner::get().finishWork();
1974 }
1975
1976 static void
1977 _cb_method_transient_for_below(void *data,
1978                                const Eldbus_Message *msg,
1979                                Eldbus_Pending *p)
1980 {
1981    const char *name = NULL, *text = NULL;
1982    Eina_Bool res = EINA_FALSE;
1983    Eina_Bool *accept = (Eina_Bool *)data;
1984
1985    *accept = EINA_FALSE;
1986
1987    res = eldbus_message_error_get(msg, &name, &text);
1988    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1989
1990    res = eldbus_message_arguments_get(msg, "b", accept);
1991    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1992    EINA_SAFETY_ON_FALSE_GOTO(*accept, finish);
1993
1994 finish:
1995    if ((name) || (text))
1996      {
1997         ERR("errname: %s errmsg: %s\n", name, text);
1998      }
1999
2000    etRunner::get().finishWork();
2001 }
2002
2003 static void
2004 _cb_method_aux_hint_get(void *data,
2005                         const Eldbus_Message *msg,
2006                         Eldbus_Pending *p)
2007 {
2008    auxHintEventItem **hint = (auxHintEventItem **) data;
2009    const char *name = NULL, *text = NULL;
2010    Eina_Bool res = EINA_FALSE;
2011    int id;
2012    const char *hint_key, *hint_val;
2013
2014    res = eldbus_message_error_get(msg, &name, &text);
2015    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2016
2017    res = eldbus_message_arguments_get(msg, "iss", &id, &hint_key, &hint_val);
2018    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2019
2020    *hint = new auxHintEventItem(0, E_TC_EVENT_TYPE_AUX_HINT_CHANGED, id, hint_key, hint_val);
2021
2022 finish:
2023    if ((name) || (text))
2024      {
2025         ERR("errname: %s errmsg: %s\n", name, text);
2026      }
2027
2028    etRunner::get().finishWork();
2029 }
2030
2031 /* callbacks - signal */
2032 static void
2033 _cb_signal_vis_changed(void *data,
2034                        const Eldbus_Message *msg)
2035 {
2036    etRunner *runner = (etRunner *)data;
2037    const char *name = NULL, *text = NULL;
2038    Eina_Bool res = EINA_FALSE;
2039    int vis = 0;
2040    Ecore_Window id;
2041
2042    res = eldbus_message_error_get(msg, &name, &text);
2043    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2044
2045    res = eldbus_message_arguments_get(msg, "ub", &id, &vis);
2046    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2047
2048    runner->insertEventQueue(id, E_TC_EVENT_TYPE_VIS_CHANGED);
2049
2050 finish:
2051    if ((name) || (text))
2052      {
2053         ERR("errname:%s errmsg:%s\n", name, text);
2054      }
2055 }
2056
2057 static void
2058 _cb_signal_stack_changed(void *data,
2059                          const Eldbus_Message *msg)
2060 {
2061    etRunner *runner = (etRunner *)data;
2062    const char *name = NULL, *text = NULL;
2063    Eina_Bool res = EINA_FALSE;
2064    Ecore_Window id = 0;
2065
2066    res = eldbus_message_error_get(msg, &name, &text);
2067    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2068
2069    res = eldbus_message_arguments_get(msg, "u", &id);
2070    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2071
2072    runner->insertEventQueue(id, E_TC_EVENT_TYPE_STACK_CHANGED);
2073
2074 finish:
2075    if ((name) || (text))
2076      {
2077         ERR("errname:%s errmsg:%s\n", name, text);
2078      }
2079 }
2080
2081 static void
2082 _cb_signal_win_rot_changed(void *data,
2083                            const Eldbus_Message *msg)
2084 {
2085    etRunner *runner = (etRunner *)data;
2086    const char *name = NULL, *text = NULL;
2087    Eina_Bool res = EINA_FALSE;
2088    int angle = 0;
2089    Ecore_Window id;
2090
2091    res = eldbus_message_error_get(msg, &name, &text);
2092    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2093
2094    /* TODO unused 'window id' and 'angle' */
2095    res = eldbus_message_arguments_get(msg, "ui", &id, &angle);
2096    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2097
2098    runner->insertEventQueue(id, E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE);
2099
2100 finish:
2101    if ((name) || (text))
2102      {
2103         ERR("errname:%s errmsg:%s\n", name, text);
2104      }
2105 }
2106
2107 static void
2108 _cb_signal_focus_changed(void *data,
2109                          const Eldbus_Message *msg)
2110 {
2111    etRunner *runner = (etRunner *)data;
2112    const char *name = NULL, *text = NULL;
2113    Eina_Bool res = EINA_FALSE;
2114    Ecore_Window id = 0;
2115
2116    res = eldbus_message_error_get(msg, &name, &text);
2117    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2118
2119    res = eldbus_message_arguments_get(msg, "u", &id);
2120    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2121
2122    runner->insertEventQueue(id, E_TC_EVENT_TYPE_FOCUS_CHANGED);
2123
2124 finish:
2125    if ((name) || (text))
2126      {
2127         ERR("errname:%s errmsg:%s\n", name, text);
2128      }
2129 }
2130
2131 static void
2132 _cb_signal_render_while_effect_run(void *data,
2133                       const Eldbus_Message *msg)
2134 {
2135    etRunner *runner = (etRunner *)data;
2136    const char *name = NULL, *text = NULL;
2137    Eina_Bool res = EINA_FALSE;
2138    Ecore_Window id = 0;
2139
2140    res = eldbus_message_error_get(msg, &name, &text);
2141    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2142
2143    res = eldbus_message_arguments_get(msg, "u", &id);
2144    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2145
2146    runner->insertEventQueue(id, E_TC_EVENT_TYPE_EFFECT);
2147
2148 finish:
2149    if ((name) || (text))
2150      {
2151         ERR("errname:%s errmsg:%s\n", name, text);
2152      }
2153 }
2154
2155 static void
2156 _cb_signal_aux_hint_changed(void *data,
2157                          const Eldbus_Message *msg)
2158 {
2159    etRunner *runner = (etRunner *)data;
2160    const char *name = NULL, *text = NULL;
2161    Eina_Bool res = EINA_FALSE;
2162    Ecore_Window win = 0;
2163    uint32_t hint_id;
2164    std::shared_ptr<auxHintEventItem> hint = NULL;
2165    const char *hint_key, *hint_val;
2166
2167    res = eldbus_message_error_get(msg, &name, &text);
2168    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2169
2170    res = eldbus_message_arguments_get(msg, "uuss", &win, &hint_id, &hint_key, &hint_val);
2171    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2172
2173    hint = std::make_shared<auxHintEventItem>(win, E_TC_EVENT_TYPE_AUX_HINT_CHANGED, hint_id, hint_key, hint_val);
2174    EINA_SAFETY_ON_NULL_GOTO(hint, finish);
2175
2176    runner->insertEventQueue(hint);
2177
2178 finish:
2179    if ((name) || (text))
2180      {
2181         ERR("errname:%s errmsg:%s\n", name, text);
2182      }
2183 }
2184
2185 /* callbacks - timer */
2186 static Eina_Bool
2187 _cb_work_timeout(void *data)
2188 {
2189    etRunner::get().finishWork();
2190    return ECORE_CALLBACK_CANCEL;
2191 }
2192
2193 /* callbacks - ecore */
2194 static Eina_Bool
2195 _cb_ecore_key_down(void *data, int type, void *event)
2196 {
2197    Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
2198    etRunner *runner = (etRunner *)data;
2199
2200    if (runner->ev.key.name == NULL) return ECORE_CALLBACK_PASS_ON;
2201
2202    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
2203      {
2204         if (runner->ev.key.ecore_state == EINA_FALSE &&
2205             type == ECORE_EVENT_KEY_DOWN)
2206           {
2207              runner->ev.key.ecore_state = EINA_TRUE;
2208           }
2209      }
2210
2211    return ECORE_CALLBACK_PASS_ON;
2212 }
2213
2214 static Eina_Bool
2215 _cb_ecore_key_up(void *data, int type, void *event)
2216 {
2217    Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
2218    etRunner *runner = (etRunner *)data;
2219
2220    if (runner->ev.key.name == NULL) return ECORE_CALLBACK_PASS_ON;
2221
2222    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
2223      {
2224         if (runner->ev.key.ecore_state == EINA_TRUE &&
2225             type == ECORE_EVENT_KEY_UP)
2226           {
2227              runner->ev.key.ecore_state = EINA_FALSE;
2228              runner->insertEventQueue(0, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
2229           }
2230      }
2231
2232    return ECORE_CALLBACK_PASS_ON;
2233 }
2234
2235 /* callbacks - evas */
2236 static void
2237 _cb_evas_key_down(void *data, Evas * evas, Evas_Object * obj, void * event_info)
2238 {
2239    Evas_Event_Key_Down *ev;
2240    etRunner *runner = (etRunner *)data;
2241
2242    ev = (Evas_Event_Key_Down *)event_info;
2243
2244    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
2245      {
2246         if (runner->ev.key.evas_state == EINA_FALSE &&
2247             runner->ev.elm_win == obj)
2248           {
2249              runner->ev.key.evas_state = EINA_TRUE;
2250           }
2251      }
2252 }
2253
2254 static void
2255 _cb_evas_key_up(void * data, Evas * evas, Evas_Object * obj, void * event_info)
2256 {
2257    Evas_Event_Key_Up *ev;
2258    etRunner *runner = (etRunner *)data;
2259
2260    ev = (Evas_Event_Key_Up *)event_info;
2261
2262    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
2263      {
2264         if (runner->ev.key.evas_state == EINA_TRUE &&
2265             runner->ev.elm_win == obj)
2266           {
2267              runner->ev.key.evas_state = EINA_FALSE;
2268              runner->ev.elm_win = NULL;
2269
2270              runner->insertEventQueue(runner->ev.native_win, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
2271           }
2272      }
2273 }
2274
2275 /* callbacks -  smart object */
2276 static void
2277 _cb_evas_smart_cb_effect_started(void *data, Evas_Object * obj, void *event_info)
2278 {
2279    etRunner *runner = (etRunner *)data;
2280    if (runner && runner->ev.elm_win == obj)
2281      {
2282         runner->ev.effect.state_smcb = E_TC_EVAS_SMART_CB_STATE_EFFECT_STARTED;
2283      }
2284 }
2285
2286 static void
2287 _cb_evas_smart_cb_effect_done(void *data, Evas_Object * obj, void *event_info)
2288 {
2289    etRunner *runner = (etRunner *)data;
2290    if (runner && runner->ev.elm_win == obj)
2291      {
2292         runner->ev.effect.state_smcb |= E_TC_EVAS_SMART_CB_STATE_EFFECT_DONE;
2293
2294         runner->insertEventQueue(runner->ev.native_win, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
2295
2296         evas_object_smart_callback_del(runner->ev.elm_win, effect_started, _cb_evas_smart_cb_effect_started);
2297         evas_object_smart_callback_del(runner->ev.elm_win, effect_done, _cb_evas_smart_cb_effect_done);
2298         evas_object_smart_callback_del(runner->ev.elm_win, launch_done, _cb_evas_smart_cb_launch_done);
2299      }
2300 }
2301
2302 static void
2303 _cb_evas_smart_cb_launch_done(void *data, Evas_Object * obj, void *event_info)
2304 {
2305    etRunner *runner = (etRunner *)data;
2306    if (runner && runner->ev.elm_win == obj)
2307      {
2308         runner->ev.effect.state_smcb  |= E_TC_EVAS_SMART_CB_STATE_LAUNCH_DONE;
2309
2310         if((runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_EFFECT_STARTED) &&
2311            (runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_EFFECT_DONE) &&
2312            (runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_LAUNCH_DONE))
2313           {
2314              runner->insertEventQueue(runner->ev.native_win, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
2315
2316              evas_object_smart_callback_del(runner->ev.elm_win, effect_started, _cb_evas_smart_cb_effect_started);
2317              evas_object_smart_callback_del(runner->ev.elm_win, effect_done, _cb_evas_smart_cb_effect_done);
2318              evas_object_smart_callback_del(runner->ev.elm_win, launch_done, _cb_evas_smart_cb_launch_done);
2319           }
2320      }
2321 }
2322
2323 static Eina_Bool
2324 _cb_gesture_tap(void *data, int type, void *event)
2325 {
2326    etRunner *runner = (etRunner *)data;
2327    efl_util_event_gesture_tap_s *ev =
2328      (efl_util_event_gesture_tap_s *)event;
2329
2330    if ((ev->fingers == (unsigned int)runner->ev.gesture.tap.fingers) &&
2331        (ev->repeats == (unsigned int)runner->ev.gesture.tap.repeats))
2332      {
2333         runner->insertEventQueue(0, E_TC_EVENT_TYPE_GESTURE_TAP);
2334         //ecore_event_handler_del(runner->ev.key.eh);
2335      }
2336
2337    return ECORE_CALLBACK_PASS_ON;
2338 }
2339
2340 static Eina_Bool
2341 _cb_gesture_tap_delay_timer(void *data)
2342 {
2343    etRunner *runner = (etRunner *)data;
2344    int i;
2345
2346    for (i = 0; i < runner->ev.gesture.tap.fingers; i++)
2347      {
2348         if (!runner->ev.gesture.tap.pressed)
2349           {
2350             runner->generateTouchDown(i, 100 * (i + 1), 100 * (i + 1));
2351           }
2352         else
2353           {
2354             runner->generateTouchUp(i, 100 * (i + 1), 100 * (i + 1));
2355           }
2356      }
2357
2358    runner->ev.gesture.timer = NULL;
2359
2360    runner->ev.gesture.tap.pressed = !runner->ev.gesture.tap.pressed;
2361    if (!runner->ev.gesture.tap.pressed)
2362      {
2363         runner->ev.gesture.tap.current_repeats--;
2364      }
2365
2366    if (runner->ev.gesture.tap.current_repeats > 0)
2367      {
2368         runner->ev.gesture.timer = ecore_timer_add(0.11,
2369                                                    _cb_gesture_tap_delay_timer,
2370                                                    runner);
2371      }
2372
2373    return ECORE_CALLBACK_CANCEL;
2374 }
2375
2376 Eina_Bool
2377 etRunner::generateTapGesture()
2378 {
2379    ev.gesture.tap.current_repeats = ev.gesture.tap.repeats;
2380    ev.gesture.tap.pressed = EINA_FALSE;
2381
2382    ev.gesture.timer = ecore_timer_add(0.11,
2383                                       _cb_gesture_tap_delay_timer,
2384                                       this);
2385
2386    return EINA_TRUE;
2387 }
2388
2389 static Eina_Bool
2390 _cb_gesture_edge_swipe(void *data, int type, void *event)
2391 {
2392    etRunner *runner = (etRunner *)data;
2393    efl_util_event_gesture_edge_swipe_s *ev =
2394      (efl_util_event_gesture_edge_swipe_s *)event;
2395
2396    if ((ev->fingers == (unsigned int)runner->ev.gesture.edge.fingers) &&
2397        (ev->edge == (unsigned int)runner->ev.gesture.edge.edge))
2398      {
2399         if (runner->ev.gesture.timer)
2400           runner->ev.gesture.edge.get_event = EINA_TRUE;
2401      }
2402
2403    return ECORE_CALLBACK_PASS_ON;
2404 }
2405
2406 static Eina_Bool
2407 _cb_gesture_edge_swipe_delay_timer(void *data)
2408 {
2409    etRunner *runner = (etRunner *)data;
2410    int i, cnt, fingers, w, h;
2411    efl_util_gesture_edge_e edge;
2412
2413    cnt = ++runner->ev.gesture.edge.touch_count;
2414    fingers = runner->ev.gesture.edge.fingers;
2415    edge = runner->ev.gesture.edge.edge;
2416    w = runner->output.w - 1;
2417    h = runner->output.h - 1;
2418
2419    if (cnt == 1)
2420      {
2421         for (i = 0; i < fingers; i++)
2422           {
2423              switch (edge)
2424                {
2425                   case EFL_UTIL_GESTURE_EDGE_TOP:
2426                     runner->generateTouchDown(i, 100 * (i + 1), 1);
2427                     break;
2428                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2429                     runner->generateTouchDown(i, w - 1, 100 * (i + 1));
2430                     break;
2431                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2432                     runner->generateTouchDown(i, 100 * (i + 1), h - 1);
2433                     break;
2434                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2435                     runner->generateTouchDown(i, 1, 100 * (i + 1));
2436                     break;
2437                   default:
2438                     break;
2439                }
2440           }
2441      }
2442    else if (cnt < 5)
2443      {
2444         for (i = 0; i < fingers; i++)
2445           {
2446              switch (edge)
2447                {
2448                   case EFL_UTIL_GESTURE_EDGE_TOP:
2449                     runner->generateTouchMove(i, 100 * (i + 1), 40 * cnt * cnt);
2450                     break;
2451                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2452                     runner->generateTouchMove(i, (w - 1) - (40 * cnt * cnt), 100 * (i + 1));
2453                     break;
2454                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2455                     runner->generateTouchMove(i, 100 * (i + 1), (h - 1) - (40 * cnt * cnt));
2456                     break;
2457                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2458                     runner->generateTouchMove(i, 40 * cnt * cnt, 100 * (i + 1));
2459                     break;
2460                   default:
2461                     break;
2462                }
2463           }
2464      }
2465    else
2466      {
2467         cnt--;
2468         for (i = 0; i < fingers; i++)
2469           {
2470              switch (edge)
2471                {
2472                   case EFL_UTIL_GESTURE_EDGE_TOP:
2473                     runner->generateTouchUp(i, 100 * (i + 1), 40 * cnt * cnt);
2474                     break;
2475                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2476                     runner->generateTouchUp(i, (w - 1) - (40 * cnt * cnt), 100 * (i + 1));
2477                     break;
2478                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2479                     runner->generateTouchUp(i, 100 * (i + 1), (h - 1) - (40 * cnt * cnt));
2480                     break;
2481                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2482                     runner->generateTouchUp(i, 40 * cnt * cnt, 100 * (i + 1));
2483                     break;
2484                   default:
2485                     break;
2486                }
2487           }
2488
2489         runner->ev.gesture.timer = NULL;
2490         if (runner->ev.gesture.edge.get_event)
2491           {
2492              runner->insertEventQueue(0, E_TC_EVENT_TYPE_GESTURE_EDGE_SWIPE);
2493              //ecore_event_handler_del(runner->ev.key.eh);
2494           }
2495         return ECORE_CALLBACK_CANCEL;
2496      }
2497
2498    runner->ev.gesture.timer = NULL;
2499    runner->ev.gesture.timer = ecore_timer_add(0.11,
2500                                               _cb_gesture_edge_swipe_delay_timer,
2501                                               runner);
2502
2503    return ECORE_CALLBACK_CANCEL;
2504 }
2505
2506 Eina_Bool
2507 etRunner::generateEdgeSwipeGesture()
2508 {
2509    ev.gesture.edge.touch_count = 0;
2510    ev.gesture.edge.get_event = EINA_FALSE;
2511
2512    ev.gesture.timer = ecore_timer_add(0.11,
2513                                       _cb_gesture_edge_swipe_delay_timer,
2514                                       this);
2515
2516    return EINA_TRUE;
2517 }
2518
2519 static Eina_Bool
2520 _cb_gesture_edge_drag(void *data, int type, void *event)
2521 {
2522    etRunner *runner = (etRunner *)data;
2523    efl_util_event_gesture_edge_drag_s *ev =
2524      (efl_util_event_gesture_edge_drag_s *)event;
2525
2526    if ((ev->fingers == (unsigned int)runner->ev.gesture.edge.fingers) &&
2527        (ev->edge == (unsigned int)runner->ev.gesture.edge.edge) &&
2528        (ev->mode == EFL_UTIL_GESTURE_MODE_END))
2529      {
2530         runner->insertEventQueue(0, E_TC_EVENT_TYPE_GESTURE_EDGE_DRAG);
2531         //ecore_event_handler_del(runner->ev.key.eh);
2532      }
2533
2534    return ECORE_CALLBACK_PASS_ON;
2535 }
2536
2537 static Eina_Bool
2538 _cb_gesture_edge_drag_delay_timer(void *data)
2539 {
2540    etRunner *runner = (etRunner *)data;
2541    int i, cnt, fingers, w, h;
2542    efl_util_gesture_edge_e edge;
2543
2544    cnt = ++runner->ev.gesture.edge.touch_count;
2545    fingers = runner->ev.gesture.edge.fingers;
2546    edge = runner->ev.gesture.edge.edge;
2547    w = runner->output.w - 1;
2548    h = runner->output.h - 1;
2549
2550    if (cnt == 1)
2551      {
2552         for (i = 0; i < fingers; i++)
2553           {
2554              switch (edge)
2555                {
2556                   case EFL_UTIL_GESTURE_EDGE_TOP:
2557                     runner->generateTouchDown(i, 100 * (i + 1), 1);
2558                     break;
2559                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2560                     runner->generateTouchDown(i, w - 1, 100 * (i + 1));
2561                     break;
2562                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2563                     runner->generateTouchDown(i, 100 * (i + 1), h - 1);
2564                     break;
2565                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2566                     runner->generateTouchDown(i, 1, 100 * (i + 1));
2567                     break;
2568                   default:
2569                     break;
2570                }
2571           }
2572      }
2573    else if (cnt < 5)
2574      {
2575         for (i = 0; i < fingers; i++)
2576           {
2577              switch (edge)
2578                {
2579                   case EFL_UTIL_GESTURE_EDGE_TOP:
2580                     runner->generateTouchMove(i, 100 * (i + 1), 50 * cnt);
2581                     break;
2582                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2583                     runner->generateTouchMove(i, (w - 1) - (50 * cnt), 100 * (i + 1));
2584                     break;
2585                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2586                     runner->generateTouchMove(i, 100 * (i + 1), (h - 1) - (50 * cnt));
2587                     break;
2588                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2589                     runner->generateTouchMove(i, 50 * cnt, 100 * (i + 1));
2590                     break;
2591                   default:
2592                     break;
2593                }
2594           }
2595      }
2596    else
2597      {
2598         cnt--;
2599         for (i = 0; i < fingers; i++)
2600           {
2601              switch (edge)
2602                {
2603                   case EFL_UTIL_GESTURE_EDGE_TOP:
2604                     runner->generateTouchUp(i, 100 * (i + 1), 50 * cnt);
2605                     break;
2606                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2607                     runner->generateTouchUp(i, (w - 1) - (50 * cnt), 100 * (i + 1));
2608                     break;
2609                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2610                     runner->generateTouchUp(i, 100 * (i + 1), (h - 1) - (50 * cnt));
2611                     break;
2612                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2613                     runner->generateTouchUp(i, 50 * cnt, 100 * (i + 1));
2614                     break;
2615                   default:
2616                     break;
2617                }
2618           }
2619
2620         runner->ev.gesture.timer = NULL;
2621         return ECORE_CALLBACK_CANCEL;
2622      }
2623
2624    runner->ev.gesture.timer = NULL;
2625    runner->ev.gesture.timer = ecore_timer_add(0.11,
2626                                               _cb_gesture_edge_drag_delay_timer,
2627                                               runner);
2628
2629    return ECORE_CALLBACK_CANCEL;
2630 }
2631
2632 Eina_Bool
2633 etRunner::generateEdgeDragGesture()
2634 {
2635    ev.gesture.edge.touch_count = 0;
2636
2637    ev.gesture.timer = ecore_timer_add(0.11,
2638                                       _cb_gesture_edge_drag_delay_timer,
2639                                       this);
2640
2641    return EINA_TRUE;
2642 }