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 /* callbacks - method */
  24 static void _cb_method_win_info_get(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  25 static void _cb_method_win_info_list_get(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  26 static void _cb_method_window_register(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  27 static void _cb_method_zone_rotation_change(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  28 static void _cb_method_window_effect(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  29
  30 /* callbacks - signal */
  31 static void _cb_signal_vis_changed(void *data, const Eldbus_Message *msg);
  32 static void _cb_signal_stack_changed(void *data, const Eldbus_Message *msg);
  33 static void _cb_signal_win_rot_changed(void *data, const Eldbus_Message *msg);
  34 static void _cb_signal_focus_changed(void *data, const Eldbus_Message *msg);
  35 static void _cb_signal_effect_run(void *data, const Eldbus_Message *msg);
  36
  37 /* callbacks - ecore */
  38 static Eina_Bool _cb_ecore_key(void *data, int type, void *event);
  39 static Eina_Bool _cb_key_delay_timer(void *data);
  40
  41 /* callbacks - evas */
  42 static void _cb_evas_key_down(void * data, Evas * evas, Evas_Object * obj, void * event_info);
  43 static void _cb_evas_key_up(void * data, Evas * evas, Evas_Object * obj, void * event_info);
  44
  45 /* callbacks -  smart  */
  46 static void _cb_evas_smart_cb_effect_started(void *data, Evas_Object * obj, void *event_info);
  47 static void _cb_evas_smart_cb_effect_done(void *data, Evas_Object * obj, void *event_info);
  48 static void _cb_evas_smart_cb_launch_done(void *data, Evas_Object * obj, void *event_info);
  49
  50 /* callbacks - timer */
  51 static Eina_Bool _cb_work_timeout(void *data);
  52 static Eina_Bool _ev_wait_timeout(void *data);
  53
  54 /* callbacks - gesture */
  55 static Eina_Bool _cb_gesture_tap(void *data, int type, void *event);
  56
  57 /* functions - gesture */
  58 static void _gesture_tap_generate(etRunner *runner);
  59
  60 /**********************
  61       listeners
  62  **********************/
  63 static const struct tizen_resource_listener _e_test_tizen_resource_listener =
  64 {
  65    _cb_resource_id,
  66 };
  67
  68 /**********************
  69    class etRunner
  70  **********************/
  71 etRunner etRunner::inst;
  72
  73 Eina_Bool
  74 etRunner::init()
  75 {
  76    Eina_Bool res = EINA_FALSE;
  77
  78    worker.waitTime = E_TEST_WORK_TIME;
  79
  80    logDomain = eina_log_domain_register("e-tc", EINA_COLOR_BLUE);
  81
  82    // Init Ecore_Wl2
  83    if (!ecore_wl2_connected_display_get(NULL))
  84      ecore_wl2_display_connect(NULL);
  85
  86    // init tizen_extension protocol
  87    res = initProtocols();
  88    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
  89
  90    // init eldbus
  91    eldbus_init();
  92
  93    dbus.conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
  94    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.conn, EINA_FALSE);
  95
  96    dbus.obj = eldbus_object_get(dbus.conn,
  97                                 "org.enlightenment.wm",
  98                                 "/org/enlightenment/wm");
  99    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.obj, EINA_FALSE);
 100
 101    dbus.proxy = eldbus_proxy_get(dbus.obj,
 102                                  "org.enlightenment.wm.Test");
 103    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.proxy, EINA_FALSE);
 104
 105    // reset registered window of e_test_helper
 106    res = resetRegisterWin();
 107    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 108
 109    // init input generator
 110    inputGenerator = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
 111
 112    return EINA_TRUE;
 113 }
 114
 115 void
 116 etRunner::shutdown()
 117 {
 118    eina_log_domain_unregister(logDomain);
 119
 120    freeLastWinInfoList();
 121
 122    // deinit tizen_extension protocol
 123    if (tzPolicy)
 124      {
 125         tizen_policy_destroy(tzPolicy);
 126         tzPolicy = NULL;
 127      }
 128
 129    if (tzSurface)
 130      {
 131         tizen_surface_destroy(tzSurface);
 132         tzSurface = NULL;
 133      }
 134
 135    if (tzlaunch_splash)
 136      {
 137         tizen_launch_splash_destroy(tzlaunch_splash);
 138         tzlaunch_splash = NULL;
 139      }
 140
 141    if (tzlaunch_effect)
 142      {
 143         tizen_launch_effect_destroy(tzlaunch_effect);
 144         tzlaunch_effect = NULL;
 145      }
 146
 147    // deinit eldbus
 148    eldbus_proxy_unref(dbus.proxy);
 149    eldbus_object_unref(dbus.obj);
 150    eldbus_connection_unref(dbus.conn);
 151    eldbus_shutdown();
 152
 153    // deinit input generator
 154    efl_util_input_deinitialize_generator(inputGenerator);
 155 }
 156
 157 Eina_Bool
 158 etRunner::registerWin(etWin *tw)
 159 {
 160    Eldbus_Pending *p = NULL;
 161    Eina_Bool accepted = EINA_FALSE;
 162
 163    p = eldbus_proxy_call(dbus.proxy,
 164                          "RegisterWindow",
 165                          _cb_method_window_register,
 166                          &accepted,
 167                          -1,
 168                          "u",
 169                          tw->native_win);
 170    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 171
 172    work();
 173
 174    return accepted;
 175 }
 176
 177 Eina_Bool
 178 etRunner::deregisterWin(etWin *tw)
 179 {
 180    Eldbus_Pending *p = NULL;
 181    Eina_Bool accepted = EINA_FALSE;
 182
 183    p = eldbus_proxy_call(dbus.proxy,
 184                          "DeregisterWindow",
 185                          _cb_method_window_register,
 186                          &accepted,
 187                          -1,
 188                          "u",
 189                          tw->native_win);
 190    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 191
 192    work();
 193
 194    return accepted;
 195 }
 196
 197 Eina_Bool
 198 etRunner::resetRegisterWin()
 199 {
 200    Eldbus_Pending *p = NULL;
 201    Eina_Bool accepted = EINA_FALSE;
 202
 203    p = eldbus_proxy_call(dbus.proxy,
 204                          "ResetRegisterWindow",
 205                          _cb_method_window_register,
 206                          &accepted,
 207                          -1,
 208                          "");
 209    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 210
 211    work();
 212
 213    return accepted;
 214 }
 215
 216 Eina_Bool
 217 etRunner::setWinActivate(etWin *tw)
 218 {
 219    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 220
 221    tw->updateGeometry();
 222
 223    tizen_policy_activate(tzPolicy,
 224                          getWlSurface(tw->elm_win));
 225
 226    return EINA_TRUE;
 227 }
 228
 229 Eina_Bool
 230 etRunner::setWinIconic(etWin *tw,
 231                       Eina_Bool set)
 232 {
 233    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 234
 235    if (set)
 236      tizen_policy_iconify(tzPolicy,
 237                           getWlSurface(tw->elm_win));
 238    else
 239      tizen_policy_uniconify(tzPolicy,
 240                             getWlSurface(tw->elm_win));
 241
 242    return EINA_TRUE;
 243 }
 244
 245 Eina_Bool
 246 etRunner::setWinStack(etWin *tw,
 247                       etWin *sibiling,
 248                       Eina_Bool above)
 249 {
 250    Eldbus_Pending *p = NULL;
 251    p = eldbus_proxy_call(dbus.proxy,
 252                          "SetWindowStack",
 253                          NULL,
 254                          NULL,
 255                          -1,
 256                          "uui",
 257                          tw->native_win,
 258                          sibiling? sibiling->native_win : 0,
 259                          above);
 260    EINA_SAFETY_ON_TRUE_RETURN_VAL(p != NULL, EINA_FALSE);
 261
 262    return EINA_TRUE;
 263 }
 264
 265 Eina_Bool
 266 etRunner::setWinTransientFor(etWin *tw_child,
 267                              etWin *tw_parent,
 268                              Eina_Bool set)
 269 {
 270    EINA_SAFETY_ON_NULL_RETURN_VAL(tw_child, EINA_FALSE);
 271
 272    if (set)
 273      tizen_policy_set_transient_for(tzPolicy,
 274                                     tw_child->native_win,
 275                                     tw_parent->native_win);
 276    else
 277      tizen_policy_unset_transient_for(tzPolicy,
 278                                       tw_child->native_win);
 279
 280    return EINA_TRUE;
 281 }
 282
 283 Eina_Bool
 284 etRunner::setWinNotiLevel(etWin *tw,
 285                           efl_util_notification_level_e lv)
 286 {
 287    Eina_Bool res = EINA_FALSE;
 288
 289    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 290
 291    res = efl_util_set_notification_window_level(tw->elm_win, lv);
 292    EINA_SAFETY_ON_FALSE_RETURN_VAL(res == EFL_UTIL_ERROR_NONE, EINA_FALSE);
 293
 294    return EINA_TRUE;
 295 }
 296
 297 efl_util_notification_level_e
 298 etRunner::getWinNotiLevel(etWin *tw)
 299 {
 300    Eina_Bool res = EINA_FALSE;
 301    efl_util_notification_level_e lv = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
 302
 303    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
 304
 305    res = efl_util_get_notification_window_level(tw->elm_win, &lv);
 306    EINA_SAFETY_ON_FALSE_RETURN_VAL(res == EFL_UTIL_ERROR_NONE, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
 307
 308    return lv;
 309 }
 310
 311 Eina_Bool
 312 etRunner::setFocusSkip(etWin *tw, Eina_Bool set)
 313 {
 314    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 315
 316    if (set)
 317      tizen_policy_set_focus_skip(tzPolicy,
 318                                  getWlSurface(tw->elm_win));
 319    else
 320      tizen_policy_unset_focus_skip(tzPolicy,
 321                                    getWlSurface(tw->elm_win));
 322
 323    return EINA_TRUE;
 324 }
 325
 326 Eina_Bool
 327 etRunner::setZoneRotation(int angle)
 328 {
 329    Eldbus_Pending *p = NULL;
 330    Eina_Bool allowed = EINA_FALSE;
 331
 332    p = eldbus_proxy_call(dbus.proxy,
 333                          "ChangeZoneRotation",
 334                          _cb_method_zone_rotation_change,
 335                          &allowed,
 336                          -1,
 337                          "i",
 338                          angle);
 339    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 340
 341    work();
 342
 343    return allowed;
 344 }
 345
 346 Eina_Bool
 347 etRunner::getWinInfo(etWin *tw)
 348 {
 349    Eldbus_Pending *p = NULL;
 350    Ecore_Window win;
 351    int retry = 10;
 352
 353    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 354
 355    win = tw->native_win;
 356    retry = (int) win;
 357
 358    while (retry)
 359      {
 360         p = eldbus_proxy_call(dbus.proxy,
 361                               "GetWinInfo",
 362                               _cb_method_win_info_get,
 363                               tw,
 364                               -1,
 365                               "u",
 366                               win);
 367         EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 368
 369         elm_run();
 370
 371         if ((tw->native_win == win) && (!tw->effect))
 372           return EINA_TRUE;
 373         else
 374           retry--;
 375      }
 376
 377    if (tw->native_win != win)
 378      {
 379         ERR("Something Wrong. Difference with quering window"
 380             "and received window from server");
 381         tw->native_win = win;
 382      }
 383
 384    return EINA_FALSE;
 385 }
 386
 387 Eina_List *
 388 etRunner::getWinInfoList()
 389 {
 390    Eldbus_Pending *p = NULL;
 391    Window_Info_List *info_list = NULL;
 392    etWin *tw = NULL;
 393    Eina_List *result = NULL;
 394
 395    info_list = E_NEW(Window_Info_List, 1);
 396    EINA_SAFETY_ON_NULL_RETURN_VAL(info_list, NULL);
 397
 398    while (info_list)
 399      {
 400         p = eldbus_proxy_call(dbus.proxy,
 401                               "GetWinsInfo",
 402                               _cb_method_win_info_list_get,
 403                               info_list,
 404                               -1,
 405                               "");
 406         EINA_SAFETY_ON_NULL_RETURN_VAL(p, NULL);
 407
 408         work();
 409
 410         if (info_list->retry)
 411           {
 412              info_list->retry = EINA_FALSE;
 413              EINA_LIST_CAST_FREE(info_list->list, tw, etWin*)
 414                {
 415                   if (tw)
 416                     delete tw;
 417                }
 418
 419              continue;
 420           }
 421
 422         break;
 423      }
 424
 425    result = eina_list_clone(info_list->list);
 426    E_FREE(info_list);
 427
 428    freeLastWinInfoList();
 429    listWinInfo = result;
 430
 431    return result;
 432 }
 433
 434 void
 435 etRunner::freeWinInfoList(Eina_List *list)
 436 {
 437    etWin *tw = NULL;
 438
 439    EINA_SAFETY_ON_NULL_RETURN(list);
 440
 441    if (listWinInfo == list)
 442      listWinInfo = NULL;
 443
 444    EINA_LIST_CAST_FREE(list, tw, etWin*)
 445      {
 446         if (tw != NULL)
 447           delete tw;
 448      }
 449
 450    list = NULL;
 451 }
 452
 453 void
 454 etRunner::freeLastWinInfoList()
 455 {
 456    if (listWinInfo)
 457      freeWinInfoList(listWinInfo);
 458
 459    listWinInfo = NULL;
 460 }
 461
 462 void
 463 etRunner::setLastWinInfoList(Eina_List *list)
 464 {
 465    EINA_SAFETY_ON_NULL_RETURN(list);
 466
 467    freeLastWinInfoList();
 468
 469    listWinInfo = list;
 470 }
 471
 472 Ecore_Window
 473 etRunner::getWinId(Evas_Object *elm_win)
 474 {
 475    struct wl_surface *surf = NULL;
 476    Ecore_Window id = 0;
 477    struct tizen_resource *tzres = NULL;
 478
 479    surf = getWlSurface(elm_win);
 480    EINA_SAFETY_ON_NULL_RETURN_VAL(surf, 0);
 481
 482    tzres = tizen_surface_get_tizen_resource(tzSurface, surf);
 483    EINA_SAFETY_ON_NULL_RETURN_VAL(tzres, 0);
 484
 485    tizen_resource_add_listener(tzres,
 486                                &_e_test_tizen_resource_listener, &id);
 487
 488    work();
 489
 490    tizen_resource_destroy(tzres);
 491
 492    return id;
 493 }
 494
 495 struct wl_surface *
 496 etRunner::getWlSurface(Evas_Object *elm_win)
 497 {
 498    Ecore_Wl2_Window *wlwin = NULL;
 499    struct wl_surface *surf = NULL;
 500
 501    EINA_SAFETY_ON_NULL_RETURN_VAL(elm_win, NULL);
 502
 503    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(elm_win);
 504    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, NULL);
 505
 506    surf = ecore_wl2_window_surface_get(wlwin);
 507    EINA_SAFETY_ON_NULL_RETURN_VAL(surf, NULL);
 508
 509    return surf;
 510 }
 511
 512 Eina_Bool
 513 etRunner::setDpms(Eina_Bool on)
 514 {
 515    Eldbus_Pending *p = NULL;
 516    p = eldbus_proxy_call(dbus.proxy,
 517                          "DPMS",
 518                          NULL,
 519                          NULL,
 520                          -1,
 521                          "u",
 522                          on);
 523    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 524    return EINA_TRUE;
 525 }
 526
 527 Eina_Bool
 528 etRunner::feedMouseDown(int x, int y)
 529 {
 530    Eldbus_Pending *p = NULL;
 531    p = eldbus_proxy_call(dbus.proxy,
 532                          "EventMouse",
 533                          NULL,
 534                          NULL,
 535                          -1,
 536                          "uii",
 537                          0,
 538                          x, y);
 539    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 540    return EINA_TRUE;
 541 }
 542
 543 Eina_Bool
 544 etRunner::feedMouseMove(int x, int y)
 545 {
 546    Eldbus_Pending *p = NULL;
 547    p = eldbus_proxy_call(dbus.proxy,
 548                          "EventMouse",
 549                          NULL,
 550                          NULL,
 551                          -1,
 552                          "uii",
 553                          1,
 554                          x, y);
 555    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 556    return EINA_TRUE;
 557 }
 558
 559 Eina_Bool
 560 etRunner::feedMouseUp(int x, int y)
 561 {
 562    Eldbus_Pending *p = NULL;
 563    p = eldbus_proxy_call(dbus.proxy,
 564                          "EventMouse",
 565                          NULL,
 566                          NULL,
 567                          -1,
 568                          "uii",
 569                          2,
 570                          x, y);
 571    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 572    return EINA_TRUE;
 573 }
 574
 575 Eina_Bool
 576 etRunner::feedKeyDown(const char *key)
 577 {
 578    Eldbus_Pending *p = NULL;
 579    p = eldbus_proxy_call(dbus.proxy,
 580                          "EventKey",
 581                          NULL,
 582                          NULL,
 583                          -1,
 584                          "us",
 585                          0,
 586                          key);
 587    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 588    return EINA_TRUE;
 589 }
 590
 591 Eina_Bool
 592 etRunner::feedKeyUp(const char *key)
 593 {
 594    Eldbus_Pending *p = NULL;
 595    p = eldbus_proxy_call(dbus.proxy,
 596                          "EventKey",
 597                          NULL,
 598                          NULL,
 599                          -1,
 600                          "us",
 601                          1,
 602                          key);
 603    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 604    return EINA_TRUE;
 605 }
 606
 607 Eina_Bool
 608 etRunner::generateMouseDown(int x, int y)
 609 {
 610    // Using efl_util_input_generate instead of generate event by eldbus
 611    int ret = EFL_UTIL_ERROR_NONE;
 612
 613    if (inputGenerator == NULL)
 614      {
 615         inputGenerator = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
 616         work();
 617      }
 618
 619    ret = efl_util_input_generate_touch(inputGenerator,
 620                                        0,
 621                                        EFL_UTIL_INPUT_TOUCH_BEGIN,
 622                                        x, y);
 623    if (ret != EFL_UTIL_ERROR_NONE)
 624      {
 625         efl_util_input_deinitialize_generator(inputGenerator);
 626         inputGenerator = NULL;
 627         return EINA_FALSE;
 628      }
 629
 630    return EINA_TRUE;
 631 }
 632
 633 Eina_Bool
 634 etRunner::generateMouseMove(int x, int y)
 635 {
 636    // Using efl_util_input_generate instead of generate event by eldbus
 637    int ret = EFL_UTIL_ERROR_NONE;
 638
 639    if (inputGenerator == NULL)
 640      {
 641         inputGenerator = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
 642         work();
 643      }
 644
 645    ret = efl_util_input_generate_touch(inputGenerator,
 646                                        0,
 647                                        EFL_UTIL_INPUT_TOUCH_UPDATE,
 648                                        x, y);
 649    if (ret != EFL_UTIL_ERROR_NONE)
 650      {
 651         efl_util_input_deinitialize_generator(inputGenerator);
 652         inputGenerator = NULL;
 653         return EINA_FALSE;
 654      }
 655
 656    return EINA_TRUE;
 657 }
 658
 659 Eina_Bool
 660 etRunner::generateMouseUp(int x, int y)
 661 {
 662    // Using efl_util_input_generate instead of generate event by eldbus
 663    int ret = EFL_UTIL_ERROR_NONE;
 664
 665    if (inputGenerator == NULL)
 666      {
 667         inputGenerator = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
 668         work();
 669      }
 670
 671    ret = efl_util_input_generate_touch(inputGenerator,
 672                                        0,
 673                                        EFL_UTIL_INPUT_TOUCH_END,
 674                                        x, y);
 675    if (ret != EFL_UTIL_ERROR_NONE)
 676      {
 677         efl_util_input_deinitialize_generator(inputGenerator);
 678         inputGenerator = NULL;
 679         return EINA_FALSE;
 680      }
 681
 682    return EINA_TRUE;
 683 }
 684
 685 Eina_Bool
 686 etRunner::generateKeyPress(const char *keyname)
 687 {
 688    // Using efl_util_input_generate instead of generate event by eldbus
 689    int ret = EFL_UTIL_ERROR_NONE;
 690
 691    if (inputGenerator == NULL)
 692      {
 693         inputGenerator = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
 694         work();
 695      }
 696
 697    ret = efl_util_input_generate_key(inputGenerator,
 698                                        keyname,
 699                                        1);
 700    if (ret != EFL_UTIL_ERROR_NONE)
 701      {
 702         efl_util_input_deinitialize_generator(inputGenerator);
 703         inputGenerator = NULL;
 704         return EINA_FALSE;
 705      }
 706
 707    return EINA_TRUE;
 708 }
 709
 710 Eina_Bool
 711 etRunner::generateKeyRelease(const char *keyname)
 712 {
 713    // Using efl_util_input_generate instead of generate event by eldbus
 714    int ret = EFL_UTIL_ERROR_NONE;
 715
 716    if (inputGenerator == NULL)
 717      {
 718         inputGenerator = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
 719         work();
 720      }
 721
 722    ret = efl_util_input_generate_key(inputGenerator,
 723                                        keyname,
 724                                        0);
 725    if (ret != EFL_UTIL_ERROR_NONE)
 726      {
 727         efl_util_input_deinitialize_generator(inputGenerator);
 728         inputGenerator = NULL;
 729         return EINA_FALSE;
 730      }
 731
 732    return EINA_TRUE;
 733 }
 734
 735 void
 736 etRunner::generateKeyEvent(const char *keyname, double delay)
 737 {
 738    this->ev.key.timer = ecore_timer_add(delay,
 739                                         _cb_key_delay_timer,
 740                                         this);
 741 }
 742
 743 Eina_Bool
 744 etRunner::generateTouchDown(int idx, int x, int y)
 745 {
 746    // Using efl_util_input_generate instead of generate event by eldbus
 747    int ret = EFL_UTIL_ERROR_NONE;
 748
 749    if (inputGenerator == NULL)
 750      {
 751         inputGenerator = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
 752         work();
 753      }
 754
 755    ret = efl_util_input_generate_touch(inputGenerator,
 756                                        idx,
 757                                        EFL_UTIL_INPUT_TOUCH_BEGIN,
 758                                        x, y);
 759    if (ret != EFL_UTIL_ERROR_NONE)
 760      {
 761         efl_util_input_deinitialize_generator(inputGenerator);
 762         inputGenerator = NULL;
 763         return EINA_FALSE;
 764      }
 765
 766    return EINA_TRUE;
 767 }
 768
 769 Eina_Bool
 770 etRunner::generateTouchMove(int idx, int x, int y)
 771 {
 772    // Using efl_util_input_generate instead of generate event by eldbus
 773    int ret = EFL_UTIL_ERROR_NONE;
 774
 775    if (inputGenerator == NULL)
 776      {
 777         inputGenerator = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
 778         work();
 779      }
 780
 781    ret = efl_util_input_generate_touch(inputGenerator,
 782                                        idx,
 783                                        EFL_UTIL_INPUT_TOUCH_UPDATE,
 784                                        x, y);
 785    if (ret != EFL_UTIL_ERROR_NONE)
 786      {
 787         efl_util_input_deinitialize_generator(inputGenerator);
 788         inputGenerator = NULL;
 789         return EINA_FALSE;
 790      }
 791
 792    return EINA_TRUE;
 793 }
 794
 795 Eina_Bool
 796 etRunner::generateTouchUp(int idx, int x, int y)
 797 {
 798    // Using efl_util_input_generate instead of generate event by eldbus
 799    int ret = EFL_UTIL_ERROR_NONE;
 800
 801    if (inputGenerator == NULL)
 802      {
 803         inputGenerator = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
 804         work();
 805      }
 806
 807    ret = efl_util_input_generate_touch(inputGenerator,
 808                                        idx,
 809                                        EFL_UTIL_INPUT_TOUCH_END,
 810                                        x, y);
 811    if (ret != EFL_UTIL_ERROR_NONE)
 812      {
 813         efl_util_input_deinitialize_generator(inputGenerator);
 814         inputGenerator = NULL;
 815         return EINA_FALSE;
 816      }
 817
 818    return EINA_TRUE;
 819 }
 820
 821 Eina_Bool
 822 etRunner::setSplashLaunch(const char *path, int type)
 823 {
 824    const char *effect_type = "launch";
 825    struct wl_array options1, options2;
 826
 827    // init tzlaunch_splash
 828    if (tzlaunch_splash)
 829      {
 830         tizen_launch_splash_destroy(tzlaunch_splash);
 831         tzlaunch_splash = NULL;
 832      }
 833    if (tzlaunch_effect) tzlaunch_splash = tizen_launch_effect_create_splash_img(tzlaunch_effect);
 834    EINA_SAFETY_ON_NULL_RETURN_VAL(tzlaunch_splash, EINA_FALSE);
 835
 836    wl_array_init(&options1);
 837    tizen_launch_effect_type_set(tzlaunch_effect, "launch", 555, &options1);
 838    wl_array_release(&options1);
 839
 840    wl_array_init(&options2);
 841    tizen_launch_splash_launch(tzlaunch_splash, path, type,
 842                               24, 0, 0,
 843                               effect_type, NULL, &options2);
 844    wl_array_release(&options2);
 845
 846    return EINA_TRUE;
 847 }
 848
 849 Eina_Bool
 850 etRunner::setSplashOwner()
 851 {
 852
 853    EINA_SAFETY_ON_NULL_RETURN_VAL(tzlaunch_splash, EINA_FALSE);
 854
 855    tizen_launch_splash_owner(tzlaunch_splash, (int)getpid());
 856
 857    return EINA_TRUE;
 858 }
 859
 860 Eina_Bool
 861 etRunner::setWindowEffectType(etWin *tw, E_TC_Window_Effect_type type)
 862 {
 863    Eldbus_Pending *p = NULL;
 864    Eina_Bool accepted = EINA_FALSE;
 865
 866    this->ev.effect.type = type;
 867    this->ev.win = tw->elm_win;
 868
 869    p = eldbus_proxy_call(dbus.proxy,
 870                          "SetWindowEffect",
 871                          _cb_method_window_effect,
 872                          &accepted,
 873                          -1,
 874                          "ui",
 875                          tw->native_win,
 876                          type);
 877    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 878
 879    this->ev.sh = eldbus_proxy_signal_handler_add(dbus.proxy,
 880                                                  "EffectRun",
 881                                                  _cb_signal_effect_run,
 882                                                  this);
 883    EINA_SAFETY_ON_NULL_RETURN_VAL(this->ev.sh, EINA_FALSE);
 884    work();
 885
 886    return accepted;
 887 }
 888
 889 Eina_Bool
 890 etRunner::freezeEvent()
 891 {
 892    Eldbus_Pending *p = NULL;
 893    p = eldbus_proxy_call(dbus.proxy,
 894                          "EventFreeze",
 895                          NULL,
 896                          NULL,
 897                          -1,
 898                          "u",
 899                          1);
 900    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 901    return EINA_TRUE;
 902 }
 903
 904 Eina_Bool
 905 etRunner::thawEvent()
 906 {
 907    Eldbus_Pending *p = NULL;
 908    p = eldbus_proxy_call(dbus.proxy,
 909                          "EventFreeze",
 910                          NULL,
 911                          NULL,
 912                          -1,
 913                          "u",
 914                          0);
 915    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 916    return EINA_TRUE;
 917 }
 918
 919 Eina_Bool
 920 etRunner::waitEvent(E_TC_Event_Type ev_type)
 921 {
 922    Eldbus_Signal_Handler *sh = NULL;
 923    Ecore_Event_Handler *eh = NULL, *eh2 = NULL;
 924    Eina_Bool res = EINA_FALSE;
 925
 926    EINA_SAFETY_ON_FALSE_RETURN_VAL((E_TC_EVENT_TYPE_NONE < ev_type), res);
 927    EINA_SAFETY_ON_FALSE_RETURN_VAL((E_TC_EVENT_TYPE_MAX > ev_type), res);
 928
 929    switch (ev_type)
 930      {
 931       case E_TC_EVENT_TYPE_VIS_ON:
 932       case E_TC_EVENT_TYPE_VIS_OFF:
 933       case E_TC_EVENT_TYPE_VIS_CHANGED:
 934          sh = eldbus_proxy_signal_handler_add(dbus.proxy,
 935                                               "VisibilityChanged",
 936                                               _cb_signal_vis_changed,
 937                                               this);
 938          EINA_SAFETY_ON_NULL_GOTO(sh, finish);
 939          break;
 940
 941       case E_TC_EVENT_TYPE_STACK_RAISE:
 942       case E_TC_EVENT_TYPE_STACK_LOWER:
 943       case E_TC_EVENT_TYPE_STACK_ABOVE:
 944       case E_TC_EVENT_TYPE_STACK_BELOW:
 945          sh = eldbus_proxy_signal_handler_add(dbus.proxy,
 946                                               "StackChanged",
 947                                               _cb_signal_stack_changed,
 948                                               this);
 949          EINA_SAFETY_ON_NULL_GOTO(sh, finish);
 950          break;
 951
 952       case E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE:
 953          sh = eldbus_proxy_signal_handler_add(dbus.proxy,
 954                                               "WinRotationChanged",
 955                                               _cb_signal_win_rot_changed,
 956                                               this);
 957          EINA_SAFETY_ON_NULL_GOTO(sh, finish);
 958          break;
 959
 960       case E_TC_EVENT_TYPE_FOCUS_CHANGED:
 961          sh = eldbus_proxy_signal_handler_add(dbus.proxy,
 962                                               "FocusChanged",
 963                                               _cb_signal_focus_changed,
 964                                               this);
 965          EINA_SAFETY_ON_NULL_GOTO(sh, finish);
 966          break;
 967
 968       case E_TC_EVENT_TYPE_INPUT_ECORE_KEY:
 969          eh = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, _cb_ecore_key, this);
 970          EINA_SAFETY_ON_NULL_GOTO(eh, finish);
 971          eh2 = ecore_event_handler_add(ECORE_EVENT_KEY_UP, _cb_ecore_key, this);
 972          EINA_SAFETY_ON_NULL_GOTO(eh2, finish);
 973
 974          this->ev.key.state = EINA_FALSE;
 975          this->generateKeyEvent(this->ev.key.name, 1.0);
 976          break;
 977
 978       case E_TC_EVENT_TYPE_INPUT_EVAS_KEY:
 979          evas_object_event_callback_add(this->ev.win, EVAS_CALLBACK_KEY_DOWN, _cb_evas_key_down, this);
 980          evas_object_event_callback_add(this->ev.win, EVAS_CALLBACK_KEY_UP, _cb_evas_key_up, this);
 981
 982          this->ev.key.state = EINA_FALSE;
 983          this->generateKeyEvent(this->ev.key.name, 1.0);
 984          break;
 985
 986       case E_TC_EVENT_TYPE_EFFECT:
 987          EINA_SAFETY_ON_NULL_GOTO(this->ev.sh, finish);
 988          break;
 989
 990       case E_TC_EVENT_TYPE_EFFECT_EVAS_CB:
 991          this->ev.effect.state_smcb = E_TC_EVAS_SMART_CB_STATE_NONE;
 992          evas_object_smart_callback_add(this->ev.win, effect_started, _cb_evas_smart_cb_effect_started, this);
 993          evas_object_smart_callback_add(this->ev.win, effect_done, _cb_evas_smart_cb_effect_done, this);
 994          evas_object_smart_callback_add(this->ev.win, launch_done, _cb_evas_smart_cb_launch_done, this);
 995          break;
 996
 997       case E_TC_EVENT_TYPE_GESTURE_TAP:
 998          eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_TAP, _cb_gesture_tap, this);
 999          _gesture_tap_generate(this);
1000          break;
1001
1002       default:
1003          goto finish;
1004          break;
1005      }
1006
1007    if (ev.expire_timer)
1008      ecore_timer_del(ev.expire_timer);
1009
1010    ev.request = ev_type;
1011    ev.response = E_TC_EVENT_TYPE_NONE;
1012    ev.expire_timer = ecore_timer_add(5.0, _ev_wait_timeout, this);
1013
1014    elm_run();
1015
1016    if (ev.expire_timer)
1017      {
1018         ecore_timer_del(ev.expire_timer);
1019         ev.expire_timer = NULL;
1020      }
1021
1022    if (sh) eldbus_signal_handler_del(sh);
1023    if (this->ev.sh) eldbus_signal_handler_del(this->ev.sh);
1024
1025    if (eh) ecore_event_handler_del(eh);
1026    if (eh2) ecore_event_handler_del(eh2);
1027
1028    if (ev_type == E_TC_EVENT_TYPE_INPUT_EVAS_KEY)
1029      {
1030         evas_object_event_callback_del(this->ev.win, EVAS_CALLBACK_KEY_DOWN, _cb_evas_key_down);
1031         evas_object_event_callback_del(this->ev.win, EVAS_CALLBACK_KEY_UP, _cb_evas_key_up);
1032      }
1033    else if (ev_type == E_TC_EVENT_TYPE_EFFECT_EVAS_CB)
1034      {
1035         evas_object_smart_callback_del(this->ev.win, effect_started, _cb_evas_smart_cb_effect_started);
1036         evas_object_smart_callback_del(this->ev.win, effect_done, _cb_evas_smart_cb_effect_done);
1037         evas_object_smart_callback_del(this->ev.win, launch_done, _cb_evas_smart_cb_launch_done);
1038      }
1039
1040    res = (ev.response == ev.request);
1041    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1042
1043 finish:
1044    ev.request = E_TC_EVENT_TYPE_NONE;
1045    ev.response = E_TC_EVENT_TYPE_NONE;
1046
1047    return res;
1048 }
1049
1050 void
1051 etRunner::work()
1052 {
1053    /* give a turn to deal with deferred job for given time*/
1054    addTimer(worker.waitTime);
1055    elm_run();
1056 }
1057
1058 void
1059 etRunner::work(double time)
1060 {
1061    /* give a turn to deal with deferred job for given time*/
1062    if (time < 0.0) time = 0.0;
1063
1064    addTimer(time);
1065    elm_run();
1066 }
1067
1068 void
1069 etRunner::finishWork()
1070 {
1071    if (worker.timer)
1072      delTimer();
1073
1074    elm_exit();
1075 }
1076
1077 void
1078 etRunner::printWinInfoList()
1079 {
1080    etWin *tw = NULL;
1081    Eina_List *l = NULL, *ll = NULL;
1082
1083    printf("--------------------------------------------------------------------------------------------------------------------------\n");
1084    l = getWinInfoList();
1085    EINA_LIST_CAST_FOREACH(l, ll, tw, etWin*)
1086      {
1087         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",
1088                tw->layer,
1089                (unsigned int)tw->native_win,
1090                tw->alpha,
1091                tw->x, tw->y, tw->w, tw->h,
1092                tw->Vis.win,
1093                tw->Vis.obj,
1094                tw->Vis.opaque,
1095                tw->Vis.type,
1096                tw->Vis.skip,
1097                tw->iconic,
1098                tw->Focus.win,
1099                tw->Focus.obj,
1100                tw->name);
1101      }
1102    freeWinInfoList(l);
1103    printf("--------------------------------------------------------------------------------------------------------------------------\n");
1104 }
1105
1106 void
1107 etRunner::delTimer()
1108 {
1109    if (!worker.timer) return;
1110
1111    ecore_timer_del(worker.timer);
1112    worker.timer = NULL;
1113 }
1114
1115 void
1116 etRunner::addTimer()
1117 {
1118    delTimer();
1119
1120    worker.timer = ecore_timer_add(worker.waitTime,
1121                                   _cb_work_timeout,
1122                                   this);
1123 }
1124
1125 void
1126 etRunner::addTimer(double time)
1127 {
1128    delTimer();
1129
1130    worker.timer = ecore_timer_add(time,
1131                                   _cb_work_timeout,
1132                                   this);
1133 }
1134
1135 void
1136 etRunner::waitForDestroy()
1137 {
1138    work(E_TEST_WORK_TIME);
1139 }
1140
1141 Eina_Bool
1142 etRunner::initProtocols()
1143 {
1144    Eina_Iterator *globals = NULL;
1145    Ecore_Wl2_Global *global = NULL;
1146    struct wl_registry *registry = NULL;
1147
1148    registry = ecore_wl2_display_registry_get(ecore_wl2_connected_display_get(NULL));
1149    globals = ecore_wl2_display_globals_get(ecore_wl2_connected_display_get(NULL));
1150
1151    EINA_SAFETY_ON_NULL_GOTO(registry, err);
1152    EINA_SAFETY_ON_NULL_GOTO(globals, err);
1153
1154    EINA_ITERATOR_FOREACH(globals, global)
1155      {
1156         if (!strcmp(global->interface, "tizen_policy"))
1157           {
1158              tzPolicy = (struct tizen_policy *)
1159                 wl_registry_bind(registry,
1160                                  global->id,
1161                                  &tizen_policy_interface,
1162                                  (global->version > 7)? 7 : global->version);
1163           }
1164         if (!strcmp(global->interface, "tizen_surface"))
1165           {
1166              tzSurface = (struct tizen_surface *)
1167                 wl_registry_bind(registry,
1168                                  global->id,
1169                                  &tizen_surface_interface,
1170                                  (global->version > 1)? 1 : global->version);
1171           }
1172         if (!strcmp(global->interface, "tizen_launch_effect"))
1173           {
1174              tzlaunch_effect = (struct tizen_launch_effect *)
1175                 wl_registry_bind(registry,
1176                                  global->id,
1177                                  &tizen_launch_effect_interface,
1178                                  (global->version > 1)? 1 : global->version);
1179           }
1180      }
1181
1182    EINA_SAFETY_ON_NULL_GOTO(tzPolicy, err);
1183    EINA_SAFETY_ON_NULL_GOTO(tzSurface, err);
1184    EINA_SAFETY_ON_NULL_GOTO(tzlaunch_effect, err);
1185
1186    eina_iterator_free(globals);
1187    return EINA_TRUE;
1188
1189 err:
1190    if (globals)
1191      eina_iterator_free(globals);
1192    return EINA_FALSE;
1193 }
1194
1195 /* callbacks - method */
1196 static void
1197 _cb_method_win_info_get(void *data,
1198                         const Eldbus_Message *msg,
1199                         Eldbus_Pending *p)
1200 {
1201    const char *name = NULL, *text = NULL, *wname = NULL;
1202    etWin *tw = NULL;
1203    Eina_Bool res = EINA_FALSE;
1204
1205    tw = (etWin *)data;
1206
1207    res = eldbus_message_error_get(msg, &name, &text);
1208    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1209
1210    res = eldbus_message_arguments_get
1211       (msg,
1212        E_TC_SIGN_WIN_INFO,
1213        &tw->native_win,
1214        &wname,
1215        &tw->x, &tw->y, &tw->w, &tw->h,
1216        &tw->layer,
1217        &tw->effect,
1218        &tw->Vis.win,
1219        &tw->Vis.obj,
1220        &tw->Vis.opaque,
1221        &tw->Vis.type,
1222        &tw->Vis.skip,
1223        &tw->iconic,
1224        &tw->alpha,
1225        &tw->Focus.win,
1226        &tw->Focus.obj,
1227        &tw->rot);
1228
1229    if (wname)
1230      {
1231         // change window name from char * to Eina_Stringshare
1232         if (tw->name)
1233           eina_stringshare_del(tw->name);
1234         tw->name = eina_stringshare_add(wname);
1235      }
1236
1237 finish:
1238    if ((name) || (text))
1239      {
1240         ERR("errname:%s errmsg:%s\n", name, text);
1241      }
1242
1243    etRunner::get().finishWork();
1244 }
1245
1246 static void
1247 _cb_method_win_info_list_get(void *data,
1248                              const Eldbus_Message *msg,
1249                              Eldbus_Pending *p)
1250 {
1251    const char *name = NULL, *text = NULL, *wname = NULL;
1252    Eldbus_Message_Iter *array = NULL, *ec = NULL;
1253    Ecore_Window target_win = 0;
1254    Window_Info_List *info_list = (Window_Info_List *)data;
1255    Eina_Bool res = EINA_FALSE, animating = EINA_FALSE;
1256
1257    if (info_list == NULL)
1258      goto finish;
1259
1260    res = eldbus_message_error_get(msg, &name, &text);
1261    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1262
1263    res = eldbus_message_arguments_get(msg, "ua(" E_TC_SIGN_WIN_INFO ")", &target_win, &array);
1264    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1265
1266    while (eldbus_message_iter_get_and_next(array, 'r', &ec))
1267      {
1268         etWin *tw = new etWin();
1269         if (!tw) continue;
1270
1271         res = eldbus_message_iter_arguments_get(
1272            ec,
1273            E_TC_SIGN_WIN_INFO,
1274            &tw->native_win,
1275            &wname,
1276            &tw->x, &tw->y, &tw->w, &tw->h,
1277            &tw->layer,
1278            &tw->effect,
1279            &tw->Vis.win,
1280            &tw->Vis.obj,
1281            &tw->Vis.opaque,
1282            &tw->Vis.type,
1283            &tw->Vis.skip,
1284            &tw->iconic,
1285            &tw->alpha,
1286            &tw->Focus.win,
1287            &tw->Focus.obj,
1288            &tw->rot);
1289
1290         if (wname)
1291           {
1292              // change name to eina_stringshare
1293              if (tw->name)
1294                {
1295                   WRN("Failed to get win info\n");
1296                   delete tw;
1297                   continue;
1298                }
1299              tw->name = eina_stringshare_add(wname);
1300           }
1301
1302         if (tw->effect)
1303           animating = EINA_TRUE;
1304
1305         if (!res)
1306           {
1307              WRN("Failed to get win info\n");
1308              delete tw;
1309              continue;
1310           }
1311
1312         info_list->list = eina_list_append(info_list->list, tw);
1313      }
1314
1315    if (animating)
1316      info_list->retry = EINA_TRUE;
1317
1318 finish:
1319    if ((name) || (text))
1320      {
1321         ERR("errname:%s errmsg:%s\n", name, text);
1322      }
1323
1324    etRunner::get().finishWork();
1325 }
1326
1327 static void
1328 _cb_method_window_register(void *data,
1329                            const Eldbus_Message *msg,
1330                            Eldbus_Pending *p)
1331 {
1332    const char *name = NULL, *text = NULL;
1333    Eina_Bool res = EINA_FALSE;
1334    Eina_Bool *accepted = (Eina_Bool *)data;
1335
1336    *accepted = EINA_FALSE;
1337
1338    res = eldbus_message_error_get(msg, &name, &text);
1339    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1340
1341    res = eldbus_message_arguments_get(msg, "b", accepted);
1342
1343 finish:
1344    if ((name) || (text))
1345      {
1346         ERR("errname: %s errmsg: %s\n", name, text);
1347      }
1348
1349    etRunner::get().finishWork();
1350 }
1351
1352 static void
1353 _cb_method_zone_rotation_change(void *data,
1354                                 const Eldbus_Message *msg,
1355                                 Eldbus_Pending *p)
1356 {
1357    const char *name = NULL, *text = NULL;
1358    Eina_Bool res = EINA_FALSE;
1359    Eina_Bool *allowed = (Eina_Bool *)data;
1360
1361    *allowed = EINA_FALSE;
1362
1363    res = eldbus_message_error_get(msg, &name, &text);
1364    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1365
1366    res = eldbus_message_arguments_get(msg, "b", allowed);
1367    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1368    EINA_SAFETY_ON_FALSE_GOTO(*allowed, finish);
1369
1370 finish:
1371    if ((name) || (text))
1372      {
1373         ERR("errname: %s errmsg: %s\n", name, text);
1374      }
1375
1376    etRunner::get().finishWork();
1377 }
1378
1379 static void
1380 _cb_method_window_effect(void *data,
1381                                 const Eldbus_Message *msg,
1382                                 Eldbus_Pending *p)
1383 {
1384    const char *name = NULL, *text = NULL;
1385    Eina_Bool res = EINA_FALSE;
1386    Eina_Bool *allowed = (Eina_Bool *)data;
1387
1388    *allowed = EINA_FALSE;
1389
1390    res = eldbus_message_error_get(msg, &name, &text);
1391    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1392
1393    res = eldbus_message_arguments_get(msg, "b", allowed);
1394    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1395    EINA_SAFETY_ON_FALSE_GOTO(*allowed, finish);
1396
1397 finish:
1398    if ((name) || (text))
1399      {
1400         ERR("errname: %s errmsg: %s\n", name, text);
1401      }
1402
1403    etRunner::get().finishWork();
1404 }
1405
1406 /* callbacks - signal */
1407 static void
1408 _cb_signal_vis_changed(void *data,
1409                        const Eldbus_Message *msg)
1410 {
1411    etRunner *runner = (etRunner *)data;
1412    const char *name = NULL, *text = NULL;
1413    Eina_Bool res = EINA_FALSE;
1414    int vis = 0;
1415    Ecore_Window id;
1416
1417    res = eldbus_message_error_get(msg, &name, &text);
1418    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1419
1420    res = eldbus_message_arguments_get(msg, "ub", &id, &vis);
1421    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1422
1423    /* TODO */
1424    if (((E_TC_EVENT_TYPE_VIS_ON  == runner->ev.request) && (vis)) ||
1425        ((E_TC_EVENT_TYPE_VIS_OFF == runner->ev.request) && (!vis)) ||
1426        (E_TC_EVENT_TYPE_VIS_CHANGED == runner->ev.request))
1427      {
1428         runner->ev.response = runner->ev.request;
1429         elm_exit();
1430      }
1431
1432 finish:
1433    if ((name) || (text))
1434      {
1435         ERR("errname:%s errmsg:%s\n", name, text);
1436      }
1437 }
1438
1439 static void
1440 _cb_signal_stack_changed(void *data,
1441                          const Eldbus_Message *msg)
1442 {
1443    etRunner *runner = (etRunner *)data;
1444    const char *name = NULL, *text = NULL;
1445    Eina_Bool res = EINA_FALSE;
1446
1447    res = eldbus_message_error_get(msg, &name, &text);
1448    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1449
1450    /* TODO */
1451    if ((E_TC_EVENT_TYPE_STACK_RAISE <= runner->ev.request) &&
1452        (E_TC_EVENT_TYPE_STACK_BELOW >= runner->ev.request))
1453      {
1454         runner->ev.response = runner->ev.request;
1455         elm_exit();
1456      }
1457
1458 finish:
1459    if ((name) || (text))
1460      {
1461         ERR("errname:%s errmsg:%s\n", name, text);
1462      }
1463 }
1464
1465 static void
1466 _cb_signal_win_rot_changed(void *data,
1467                            const Eldbus_Message *msg)
1468 {
1469    etRunner *runner = (etRunner *)data;
1470    const char *name = NULL, *text = NULL;
1471    Eina_Bool res = EINA_FALSE;
1472    int angle = 0;
1473    Ecore_Window id;
1474
1475    res = eldbus_message_error_get(msg, &name, &text);
1476    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1477
1478    /* TODO unused 'window id' and 'angle' */
1479    res = eldbus_message_arguments_get(msg, "ui", &id, &angle);
1480    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1481
1482    runner->ev.response = runner->ev.request;
1483    elm_exit();
1484
1485 finish:
1486    if ((name) || (text))
1487      {
1488         ERR("errname:%s errmsg:%s\n", name, text);
1489      }
1490 }
1491
1492 static void
1493 _cb_signal_focus_changed(void *data,
1494                          const Eldbus_Message *msg)
1495 {
1496    etRunner *runner = (etRunner *)data;
1497    const char *name = NULL, *text = NULL;
1498    Eina_Bool res = EINA_FALSE;
1499
1500    res = eldbus_message_error_get(msg, &name, &text);
1501    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1502
1503    if (E_TC_EVENT_TYPE_FOCUS_CHANGED == runner->ev.request)
1504      {
1505         runner->ev.response = runner->ev.request;
1506         elm_exit();
1507      }
1508
1509 finish:
1510    if ((name) || (text))
1511      {
1512         ERR("errname:%s errmsg:%s\n", name, text);
1513      }
1514 }
1515
1516 static void
1517 _cb_signal_effect_run(void *data,
1518                       const Eldbus_Message *msg)
1519 {
1520    etRunner *runner = (etRunner *)data;
1521    const char *name = NULL, *text = NULL;
1522    Eina_Bool res = EINA_FALSE;
1523    unsigned int effect_type = 0;
1524    Ecore_Window id;
1525
1526    res = eldbus_message_error_get(msg, &name, &text);
1527    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1528
1529    res = eldbus_message_arguments_get(msg, "ui", &id, &effect_type);
1530    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1531
1532    if (effect_type == runner->ev.effect.type)
1533      {
1534         runner->ev.response = runner->ev.request;
1535         elm_exit();
1536      }
1537 finish:
1538    if ((name) || (text))
1539      {
1540         ERR("errname:%s errmsg:%s\n", name, text);
1541      }
1542 }
1543
1544 /* callbacks - timer */
1545 static Eina_Bool
1546 _cb_work_timeout(void *data)
1547 {
1548    etRunner::get().finishWork();
1549    return ECORE_CALLBACK_CANCEL;
1550 }
1551
1552 static Eina_Bool
1553 _ev_wait_timeout(void *data)
1554 {
1555    etRunner *runner = (etRunner *)data;
1556
1557    runner->ev.expire_timer = NULL;
1558    runner->ev.response = E_TC_EVENT_TYPE_TIMEOUT;
1559
1560    ERR("ev:%d\n", runner->ev.request);
1561
1562    elm_exit();
1563
1564    return ECORE_CALLBACK_DONE;
1565 }
1566
1567 /* callbacks - ecore */
1568 static Eina_Bool
1569 _cb_ecore_key(void *data, int type, void *event)
1570 {
1571    Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
1572    etRunner *runner = (etRunner *)data;
1573
1574    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
1575      {
1576         if (runner->ev.key.state == EINA_FALSE &&
1577             type == ECORE_EVENT_KEY_DOWN)
1578           {
1579              runner->ev.key.state = EINA_TRUE;
1580           }
1581         else if (runner->ev.key.state == EINA_TRUE &&
1582             type == ECORE_EVENT_KEY_UP)
1583           {
1584              runner->ev.response = runner->ev.request;
1585              runner->ev.key.state = EINA_FALSE;
1586              elm_exit();
1587           }
1588      }
1589
1590    return ECORE_CALLBACK_PASS_ON;
1591 }
1592
1593 /* callbacks - evas */
1594 static void
1595 _cb_evas_key_down(void *data, Evas * evas, Evas_Object * obj, void * event_info)
1596 {
1597    Evas_Event_Key_Down *ev;
1598    etRunner *runner = (etRunner *)data;
1599
1600    ev = (Evas_Event_Key_Down *)event_info;
1601
1602    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
1603      {
1604         if (runner->ev.key.state == EINA_FALSE &&
1605             runner->ev.win == obj)
1606           {
1607              runner->ev.key.state = EINA_TRUE;
1608           }
1609      }
1610 }
1611
1612 static void
1613 _cb_evas_key_up(void * data, Evas * evas, Evas_Object * obj, void * event_info)
1614 {
1615    Evas_Event_Key_Up *ev;
1616    etRunner *runner = (etRunner *)data;
1617
1618    ev = (Evas_Event_Key_Up *)event_info;
1619
1620    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
1621      {
1622         if (runner->ev.key.state == EINA_TRUE &&
1623             runner->ev.win == obj)
1624           {
1625              runner->ev.response = runner->ev.request;
1626              runner->ev.key.state = EINA_FALSE;
1627              runner->ev.win = NULL;
1628              elm_exit();
1629           }
1630      }
1631 }
1632
1633 /* callbacks -  smart object */
1634 static void
1635 _cb_evas_smart_cb_effect_started(void *data, Evas_Object * obj, void *event_info)
1636 {
1637    etRunner *runner = (etRunner *)data;
1638    if (runner && runner->ev.win == obj)
1639      {
1640         runner->ev.effect.state_smcb = E_TC_EVAS_SMART_CB_STATE_EFFECT_STARTED;
1641      }
1642 }
1643
1644 static void
1645 _cb_evas_smart_cb_effect_done(void *data, Evas_Object * obj, void *event_info)
1646 {
1647    etRunner *runner = (etRunner *)data;
1648    if (runner && runner->ev.win == obj)
1649      {
1650         runner->ev.effect.state_smcb |= E_TC_EVAS_SMART_CB_STATE_EFFECT_DONE;
1651
1652         if((runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_EFFECT_STARTED) &&
1653            (runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_EFFECT_DONE))
1654           {
1655              runner->ev.response = runner->ev.request;
1656              elm_exit();
1657           }
1658      }
1659 }
1660
1661 static void
1662 _cb_evas_smart_cb_launch_done(void *data, Evas_Object * obj, void *event_info)
1663 {
1664    etRunner *runner = (etRunner *)data;
1665    if (runner && runner->ev.win == obj)
1666      {
1667         runner->ev.effect.state_smcb  |= E_TC_EVAS_SMART_CB_STATE_LAUNCH_DONE;
1668
1669         if((runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_EFFECT_STARTED) &&
1670            (runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_EFFECT_DONE) &&
1671            (runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_LAUNCH_DONE))
1672           {
1673              runner->ev.response = runner->ev.request;
1674              elm_exit();
1675           }
1676      }
1677 }
1678
1679 static Eina_Bool
1680 _cb_key_delay_timer(void *data)
1681 {
1682    etRunner *runner = (etRunner *)data;
1683
1684    runner->generateKeyPress(runner->ev.key.name);
1685    runner->generateKeyRelease(runner->ev.key.name);
1686
1687    runner->ev.key.timer = NULL;
1688
1689    return ECORE_CALLBACK_CANCEL;
1690 }
1691
1692 static Eina_Bool
1693 _cb_gesture_tap(void *data, int type, void *event)
1694 {
1695    etRunner *runner = (etRunner *)data;
1696    efl_util_event_gesture_tap_s *ev =
1697      (efl_util_event_gesture_tap_s *)event;
1698
1699    if ((ev->fingers == (unsigned int)runner->ev.gesture.tap.fingers) &&
1700        (ev->repeats == (unsigned int)runner->ev.gesture.tap.repeats))
1701      {
1702         runner->ev.response = E_TC_EVENT_TYPE_GESTURE_TAP;
1703         elm_exit();
1704      }
1705
1706    return ECORE_CALLBACK_PASS_ON;
1707 }
1708
1709 static Eina_Bool
1710 _cb_gesture_tap_delay_timer(void *data)
1711 {
1712    etRunner *runner = (etRunner *)data;
1713    int i;
1714
1715    for (i = 0; i < runner->ev.gesture.tap.fingers; i++)
1716      {
1717         if (!runner->ev.gesture.tap.pressed)
1718           {
1719             runner->generateTouchDown(i, 100 * (i + 1), 100 * (i + 1));
1720           }
1721         else
1722           {
1723             runner->generateTouchUp(i, 100 * (i + 1), 100 * (i + 1));
1724           }
1725      }
1726
1727    runner->ev.gesture.tap.timer = NULL;
1728
1729    runner->ev.gesture.tap.pressed = !runner->ev.gesture.tap.pressed;
1730    if (!runner->ev.gesture.tap.pressed)
1731      {
1732         runner->ev.gesture.tap.current_repeats--;
1733      }
1734
1735    if (runner->ev.gesture.tap.current_repeats > 0)
1736      {
1737         runner->ev.gesture.tap.timer = ecore_timer_add(0.11,
1738                                                        _cb_gesture_tap_delay_timer,
1739                                                        runner);
1740      }
1741
1742    return ECORE_CALLBACK_CANCEL;
1743 }
1744
1745 static void
1746 _gesture_tap_generate(etRunner *runner)
1747 {
1748    runner->ev.gesture.tap.current_repeats = runner->ev.gesture.tap.repeats;
1749    runner->ev.gesture.tap.pressed = EINA_FALSE;
1750
1751    runner->ev.gesture.tap.timer = ecore_timer_add(1.0,
1752                                                   _cb_gesture_tap_delay_timer,
1753                                                   runner);
1754 }