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 /* callbacks - event */
   9 static void
  10 _cb_resource_id(void *data,
  11                 struct tizen_resource *tizen_resource,
  12                 uint32_t id)
  13 {
  14    Ecore_Window *res_id = (Ecore_Window *)data;
  15    *res_id = id;
  16    elm_exit();
  17 }
  18
  19 /* callbacks - method */
  20 static void _cb_method_win_info_get(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  21 static void _cb_method_win_info_list_get(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  22 static void _cb_method_window_register(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  23 static void _cb_method_zone_rotation_change(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  24
  25 /* callbacks - signal */
  26 static void _cb_signal_vis_changed(void *data, const Eldbus_Message *msg);
  27 static void _cb_signal_stack_changed(void *data, const Eldbus_Message *msg);
  28 static void _cb_signal_win_rot_changed(void *data, const Eldbus_Message *msg);
  29 static void _cb_signal_focus_changed(void *data, const Eldbus_Message *msg);
  30
  31 /* callbacks - timer */
  32 static Eina_Bool _cb_work_timeout(void *data);
  33 static Eina_Bool _ev_wait_timeout(void *data);
  34
  35 /**********************
  36       listeners
  37  **********************/
  38 static const struct tizen_resource_listener _e_test_tizen_resource_listener =
  39 {
  40    _cb_resource_id,
  41 };
  42
  43 /**********************
  44    class etRunner
  45  **********************/
  46 etRunner etRunner::inst;
  47
  48 Eina_Bool
  49 etRunner::init()
  50 {
  51    Eina_Bool res = EINA_FALSE;
  52
  53    worker.waitTime = E_TEST_WORK_TIME;
  54
  55    logDomain = eina_log_domain_register("e-tc", EINA_COLOR_BLUE);
  56
  57    // Init Ecore_Wl2
  58    if (!ecore_wl2_connected_display_get(NULL))
  59      ecore_wl2_display_connect(NULL);
  60
  61    // init tizen_extension protocol
  62    res = initProtocols();
  63    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
  64
  65    // init eldbus
  66    eldbus_init();
  67
  68    dbus.conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
  69    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.conn, EINA_FALSE);
  70
  71    dbus.obj = eldbus_object_get(dbus.conn,
  72                                 "org.enlightenment.wm",
  73                                 "/org/enlightenment/wm");
  74    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.obj, EINA_FALSE);
  75
  76    dbus.proxy = eldbus_proxy_get(dbus.obj,
  77                                  "org.enlightenment.wm.Test");
  78    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.proxy, EINA_FALSE);
  79
  80    // reset registered window of e_test_helper
  81    res = resetRegisterWin();
  82    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
  83
  84    // init input generator
  85    inputGenerator = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
  86
  87    return EINA_TRUE;
  88 }
  89
  90 void
  91 etRunner::shutdown()
  92 {
  93    eina_log_domain_unregister(logDomain);
  94
  95    freeLastWinInfoList();
  96
  97    // deinit tizen_extension protocol
  98    if (tzPolicy)
  99      {
 100         tizen_policy_destroy(tzPolicy);
 101         tzPolicy = NULL;
 102      }
 103
 104    if (tzSurface)
 105      {
 106         tizen_surface_destroy(tzSurface);
 107         tzSurface = NULL;
 108      }
 109
 110    // deinit eldbus
 111    eldbus_proxy_unref(dbus.proxy);
 112    eldbus_object_unref(dbus.obj);
 113    eldbus_connection_unref(dbus.conn);
 114    eldbus_shutdown();
 115
 116    // deinit input generator
 117    efl_util_input_deinitialize_generator(inputGenerator);
 118 }
 119
 120 Eina_Bool
 121 etRunner::registerWin(etWin *tw)
 122 {
 123    Eldbus_Pending *p = NULL;
 124    Eina_Bool accepted = EINA_FALSE;
 125
 126    p = eldbus_proxy_call(dbus.proxy,
 127                          "RegisterWindow",
 128                          _cb_method_window_register,
 129                          &accepted,
 130                          -1,
 131                          "u",
 132                          tw->native_win);
 133    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 134
 135    elm_run();
 136
 137    return accepted;
 138 }
 139
 140 Eina_Bool
 141 etRunner::deregisterWin(etWin *tw)
 142 {
 143    Eldbus_Pending *p = NULL;
 144    Eina_Bool accepted = EINA_FALSE;
 145
 146    p = eldbus_proxy_call(dbus.proxy,
 147                          "DeregisterWindow",
 148                          _cb_method_window_register,
 149                          &accepted,
 150                          -1,
 151                          "u",
 152                          tw->native_win);
 153    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 154
 155    elm_run();
 156
 157    return accepted;
 158 }
 159
 160 Eina_Bool
 161 etRunner::resetRegisterWin()
 162 {
 163    Eldbus_Pending *p = NULL;
 164    Eina_Bool accepted = EINA_FALSE;
 165
 166    p = eldbus_proxy_call(dbus.proxy,
 167                          "ResetRegisterWindow",
 168                          _cb_method_window_register,
 169                          &accepted,
 170                          -1,
 171                          "");
 172    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 173
 174    elm_run();
 175
 176    return accepted;
 177 }
 178
 179 Eina_Bool
 180 etRunner::setWinActivate(etWin *tw)
 181 {
 182    // TODO:: change to send dbus message
 183    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 184
 185    tw->updateGeometry();
 186
 187    tizen_policy_activate(tzPolicy,
 188                          getWlSurface(tw->elm_win));
 189
 190    return EINA_TRUE;
 191 }
 192
 193 Eina_Bool
 194 etRunner::setWinIconic(etWin *tw,
 195                       Eina_Bool set)
 196 {
 197    // TODO:: change to send dbus message
 198    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 199
 200    if (set)
 201      tizen_policy_iconify(tzPolicy,
 202                           getWlSurface(tw->elm_win));
 203    else
 204      tizen_policy_uniconify(tzPolicy,
 205                             getWlSurface(tw->elm_win));
 206
 207    return EINA_TRUE;
 208 }
 209
 210 Eina_Bool
 211 etRunner::setWinStack(etWin *tw,
 212                       etWin *sibiling,
 213                       Eina_Bool above)
 214 {
 215    Eldbus_Pending *p = NULL;
 216    p = eldbus_proxy_call(dbus.proxy,
 217                          "SetWindowStack",
 218                          NULL,
 219                          NULL,
 220                          -1,
 221                          "uui",
 222                          tw->native_win,
 223                          sibiling? sibiling->native_win : 0,
 224                          above);
 225    EINA_SAFETY_ON_TRUE_RETURN_VAL(p != NULL, EINA_FALSE);
 226
 227    return EINA_TRUE;
 228 }
 229
 230 Eina_Bool
 231 etRunner::setWinTransientFor(etWin *tw_child,
 232                              etWin *tw_parent,
 233                              Eina_Bool set)
 234 {
 235    // TODO:: change to send dbus message
 236    EINA_SAFETY_ON_NULL_RETURN_VAL(tw_child, EINA_FALSE);
 237
 238    if (set)
 239      tizen_policy_set_transient_for(tzPolicy,
 240                                     tw_child->native_win,
 241                                     tw_parent->native_win);
 242    else
 243      tizen_policy_unset_transient_for(tzPolicy,
 244                                       tw_child->native_win);
 245
 246    return EINA_TRUE;
 247 }
 248
 249 Eina_Bool
 250 etRunner::setWinNotiLevel(etWin *tw,
 251                           efl_util_notification_level_e lv)
 252 {
 253    // TODO:: change to send dbus message
 254    Eina_Bool res = EINA_FALSE;
 255
 256    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 257
 258    res = efl_util_set_notification_window_level(tw->elm_win, lv);
 259    EINA_SAFETY_ON_FALSE_RETURN_VAL(res == EFL_UTIL_ERROR_NONE, EINA_FALSE);
 260
 261    return EINA_TRUE;
 262 }
 263
 264 efl_util_notification_level_e
 265 etRunner::getWinNotiLevel(etWin *tw)
 266 {
 267    // TODO:: change to send dbus message
 268    Eina_Bool res = EINA_FALSE;
 269    efl_util_notification_level_e lv = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
 270
 271    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
 272
 273    res = efl_util_get_notification_window_level(tw->elm_win, &lv);
 274    EINA_SAFETY_ON_FALSE_RETURN_VAL(res == EFL_UTIL_ERROR_NONE, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
 275
 276    return lv;
 277 }
 278
 279 Eina_Bool
 280 etRunner::setFocusSkip(etWin *tw, Eina_Bool set)
 281 {
 282    // TODO:: change to send dbus message
 283    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 284
 285    if (set)
 286      tizen_policy_set_focus_skip(tzPolicy,
 287                                  getWlSurface(tw->elm_win));
 288    else
 289      tizen_policy_unset_focus_skip(tzPolicy,
 290                                    getWlSurface(tw->elm_win));
 291
 292    return EINA_TRUE;
 293 }
 294
 295 Eina_Bool
 296 etRunner::setZoneRotation(int angle)
 297 {
 298    Eldbus_Pending *p = NULL;
 299    Eina_Bool allowed = EINA_FALSE;
 300
 301    p = eldbus_proxy_call(dbus.proxy,
 302                          "ChangeZoneRotation",
 303                          _cb_method_zone_rotation_change,
 304                          &allowed,
 305                          -1,
 306                          "i",
 307                          angle);
 308    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 309
 310    elm_run();
 311
 312    return allowed;
 313 }
 314
 315 Eina_Bool
 316 etRunner::getWinInfo(etWin *tw)
 317 {
 318    Eldbus_Pending *p = NULL;
 319    Ecore_Window win;
 320    int retry = 10;
 321
 322    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 323
 324    win = tw->native_win;
 325    retry = (int) win;
 326
 327    while (retry)
 328      {
 329         p = eldbus_proxy_call(dbus.proxy,
 330                               "GetWinInfo",
 331                               _cb_method_win_info_get,
 332                               tw,
 333                               -1,
 334                               "u",
 335                               win);
 336         EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 337
 338         elm_run();
 339
 340         if ((tw->native_win == win) && (!tw->effect))
 341           return EINA_TRUE;
 342         else
 343           retry--;
 344      }
 345
 346    if (tw->native_win != win)
 347      {
 348         ERR("Something Wrong. Difference with quering window"
 349             "and received window from server");
 350         tw->native_win = win;
 351      }
 352
 353    return EINA_FALSE;
 354 }
 355
 356 Eina_List *
 357 etRunner::getWinInfoList()
 358 {
 359    Eldbus_Pending *p = NULL;
 360    Window_Info_List *info_list = NULL;
 361    etWin *tw = NULL;
 362    Eina_List *result = NULL;
 363
 364    info_list = E_NEW(Window_Info_List, 1);
 365    EINA_SAFETY_ON_NULL_RETURN_VAL(info_list, NULL);
 366
 367    while (info_list)
 368      {
 369         p = eldbus_proxy_call(dbus.proxy,
 370                               "GetWinsInfo",
 371                               _cb_method_win_info_list_get,
 372                               info_list,
 373                               -1,
 374                               "");
 375         EINA_SAFETY_ON_NULL_RETURN_VAL(p, NULL);
 376
 377         elm_run();
 378
 379         if (info_list->retry)
 380           {
 381              info_list->retry = EINA_FALSE;
 382              EINA_LIST_CAST_FREE(info_list->list, tw, etWin*)
 383                {
 384                   if (tw)
 385                     delete tw;
 386                }
 387
 388              continue;
 389           }
 390
 391         break;
 392      }
 393
 394    result = eina_list_clone(info_list->list);
 395    E_FREE(info_list);
 396
 397    freeLastWinInfoList();
 398    listWinInfo = result;
 399
 400    return result;
 401 }
 402
 403 void
 404 etRunner::freeWinInfoList(Eina_List *list)
 405 {
 406    etWin *tw = NULL;
 407
 408    EINA_SAFETY_ON_NULL_RETURN(list);
 409
 410    if (listWinInfo == list)
 411      listWinInfo = NULL;
 412
 413    EINA_LIST_CAST_FREE(list, tw, etWin*)
 414      {
 415         if (tw != NULL)
 416           delete tw;
 417      }
 418
 419    list = NULL;
 420 }
 421
 422 void
 423 etRunner::freeLastWinInfoList()
 424 {
 425    if (listWinInfo)
 426      freeWinInfoList(listWinInfo);
 427
 428    listWinInfo = NULL;
 429 }
 430
 431 void
 432 etRunner::setLastWinInfoList(Eina_List *list)
 433 {
 434    EINA_SAFETY_ON_NULL_RETURN(list);
 435
 436    freeLastWinInfoList();
 437
 438    listWinInfo = list;
 439 }
 440
 441 Ecore_Window
 442 etRunner::getWinId(Evas_Object *elm_win)
 443 {
 444    struct wl_surface *surf = NULL;
 445    Ecore_Window id = 0;
 446    struct tizen_resource *tzres = NULL;
 447
 448    surf = getWlSurface(elm_win);
 449    EINA_SAFETY_ON_NULL_RETURN_VAL(surf, 0);
 450
 451    tzres = tizen_surface_get_tizen_resource(tzSurface, surf);
 452    EINA_SAFETY_ON_NULL_RETURN_VAL(tzres, 0);
 453
 454    tizen_resource_add_listener(tzres,
 455                                &_e_test_tizen_resource_listener, &id);
 456
 457    elm_run();
 458
 459    if (tzres) tizen_resource_destroy(tzres);
 460
 461    return id;
 462 }
 463
 464 struct wl_surface *
 465 etRunner::getWlSurface(Evas_Object *elm_win)
 466 {
 467    Ecore_Wl2_Window *wlwin = NULL;
 468    struct wl_surface *surf = NULL;
 469
 470    EINA_SAFETY_ON_NULL_RETURN_VAL(elm_win, NULL);
 471
 472    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(elm_win);
 473    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, NULL);
 474
 475    surf = ecore_wl2_window_surface_get(wlwin);
 476    EINA_SAFETY_ON_NULL_RETURN_VAL(surf, NULL);
 477
 478    return surf;
 479 }
 480
 481 Eina_Bool
 482 etRunner::setDpms(Eina_Bool on)
 483 {
 484    Eldbus_Pending *p = NULL;
 485    p = eldbus_proxy_call(dbus.proxy,
 486                          "DPMS",
 487                          NULL,
 488                          NULL,
 489                          -1,
 490                          "u",
 491                          on);
 492    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 493    return EINA_TRUE;
 494 }
 495
 496 Eina_Bool
 497 etRunner::feedMouseDown(int x, int y)
 498 {
 499    Eldbus_Pending *p = NULL;
 500    p = eldbus_proxy_call(dbus.proxy,
 501                          "EventMouse",
 502                          NULL,
 503                          NULL,
 504                          -1,
 505                          "uii",
 506                          0,
 507                          x, y);
 508    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 509    return EINA_TRUE;
 510 }
 511
 512 Eina_Bool
 513 etRunner::feedMouseMove(int x, int y)
 514 {
 515    Eldbus_Pending *p = NULL;
 516    p = eldbus_proxy_call(dbus.proxy,
 517                          "EventMouse",
 518                          NULL,
 519                          NULL,
 520                          -1,
 521                          "uii",
 522                          1,
 523                          x, y);
 524    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 525    return EINA_TRUE;
 526 }
 527
 528 Eina_Bool
 529 etRunner::feedMouseUp(int x, int y)
 530 {
 531    Eldbus_Pending *p = NULL;
 532    p = eldbus_proxy_call(dbus.proxy,
 533                          "EventMouse",
 534                          NULL,
 535                          NULL,
 536                          -1,
 537                          "uii",
 538                          2,
 539                          x, y);
 540    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 541    return EINA_TRUE;
 542 }
 543
 544 Eina_Bool
 545 etRunner::feedKeyDown(const char *key)
 546 {
 547    Eldbus_Pending *p = NULL;
 548    p = eldbus_proxy_call(dbus.proxy,
 549                          "EventKey",
 550                          NULL,
 551                          NULL,
 552                          -1,
 553                          "us",
 554                          0,
 555                          key);
 556    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 557    return EINA_TRUE;
 558 }
 559
 560 Eina_Bool
 561 etRunner::feedKeyUp(const char *key)
 562 {
 563    Eldbus_Pending *p = NULL;
 564    p = eldbus_proxy_call(dbus.proxy,
 565                          "EventKey",
 566                          NULL,
 567                          NULL,
 568                          -1,
 569                          "us",
 570                          1,
 571                          key);
 572    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 573    return EINA_TRUE;
 574 }
 575
 576 Eina_Bool
 577 etRunner::generateMouseDown(int x, int y)
 578 {
 579    // Using efl_util_input_generate instead of generate event by eldbus
 580    int ret = EFL_UTIL_ERROR_NONE;
 581
 582    if (inputGenerator == NULL)
 583      {
 584         inputGenerator = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
 585         work();
 586      }
 587
 588    ret = efl_util_input_generate_touch(inputGenerator,
 589                                        0,
 590                                        EFL_UTIL_INPUT_TOUCH_BEGIN,
 591                                        x, y);
 592    if (ret != EFL_UTIL_ERROR_NONE)
 593      {
 594         efl_util_input_deinitialize_generator(inputGenerator);
 595         inputGenerator = NULL;
 596         return EINA_FALSE;
 597      }
 598
 599    return EINA_TRUE;
 600 }
 601
 602 Eina_Bool
 603 etRunner::generateMouseMove(int x, int y)
 604 {
 605    // Using efl_util_input_generate instead of generate event by eldbus
 606    int ret = EFL_UTIL_ERROR_NONE;
 607
 608    if (inputGenerator == NULL)
 609      {
 610         inputGenerator = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
 611         work();
 612      }
 613
 614    ret = efl_util_input_generate_touch(inputGenerator,
 615                                        0,
 616                                        EFL_UTIL_INPUT_TOUCH_UPDATE,
 617                                        x, y);
 618    if (ret != EFL_UTIL_ERROR_NONE)
 619      {
 620         efl_util_input_deinitialize_generator(inputGenerator);
 621         inputGenerator = NULL;
 622         return EINA_FALSE;
 623      }
 624
 625    return EINA_TRUE;
 626 }
 627
 628 Eina_Bool
 629 etRunner::generateMouseUp(int x, int y)
 630 {
 631    // Using efl_util_input_generate instead of generate event by eldbus
 632    int ret = EFL_UTIL_ERROR_NONE;
 633
 634    if (inputGenerator == NULL)
 635      {
 636         inputGenerator = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
 637         work();
 638      }
 639
 640    ret = efl_util_input_generate_touch(inputGenerator,
 641                                        0,
 642                                        EFL_UTIL_INPUT_TOUCH_END,
 643                                        x, y);
 644    if (ret != EFL_UTIL_ERROR_NONE)
 645      {
 646         efl_util_input_deinitialize_generator(inputGenerator);
 647         inputGenerator = NULL;
 648         return EINA_FALSE;
 649      }
 650
 651    return EINA_TRUE;
 652 }
 653
 654 Eina_Bool
 655 etRunner::freezeEvent()
 656 {
 657    Eldbus_Pending *p = NULL;
 658    p = eldbus_proxy_call(dbus.proxy,
 659                          "EventFreeze",
 660                          NULL,
 661                          NULL,
 662                          -1,
 663                          "u",
 664                          1);
 665    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 666    return EINA_TRUE;
 667 }
 668
 669 Eina_Bool
 670 etRunner::thawEvent()
 671 {
 672    Eldbus_Pending *p = NULL;
 673    p = eldbus_proxy_call(dbus.proxy,
 674                          "EventFreeze",
 675                          NULL,
 676                          NULL,
 677                          -1,
 678                          "u",
 679                          0);
 680    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 681    return EINA_TRUE;
 682 }
 683
 684 Eina_Bool
 685 etRunner::waitEvent(E_TC_Event_Type ev_type)
 686 {
 687    Eldbus_Signal_Handler *sh;
 688    Eina_Bool res = EINA_FALSE;
 689
 690    EINA_SAFETY_ON_FALSE_RETURN_VAL((E_TC_EVENT_TYPE_NONE < ev_type), res);
 691    EINA_SAFETY_ON_FALSE_RETURN_VAL((E_TC_EVENT_TYPE_MAX > ev_type), res);
 692
 693    switch (ev_type)
 694      {
 695       case E_TC_EVENT_TYPE_VIS_ON:
 696       case E_TC_EVENT_TYPE_VIS_OFF:
 697       case E_TC_EVENT_TYPE_VIS_CHANGED:
 698          sh = eldbus_proxy_signal_handler_add(dbus.proxy,
 699                                               "VisibilityChanged",
 700                                               _cb_signal_vis_changed,
 701                                               this);
 702          EINA_SAFETY_ON_NULL_GOTO(sh, finish);
 703          break;
 704
 705       case E_TC_EVENT_TYPE_STACK_RAISE:
 706       case E_TC_EVENT_TYPE_STACK_LOWER:
 707       case E_TC_EVENT_TYPE_STACK_ABOVE:
 708       case E_TC_EVENT_TYPE_STACK_BELOW:
 709          sh = eldbus_proxy_signal_handler_add(dbus.proxy,
 710                                               "StackChanged",
 711                                               _cb_signal_stack_changed,
 712                                               this);
 713          EINA_SAFETY_ON_NULL_GOTO(sh, finish);
 714          break;
 715
 716       case E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE:
 717          sh = eldbus_proxy_signal_handler_add(dbus.proxy,
 718                                               "WinRotationChanged",
 719                                               _cb_signal_win_rot_changed,
 720                                               this);
 721          EINA_SAFETY_ON_NULL_GOTO(sh, finish);
 722          break;
 723
 724       case E_TC_EVENT_TYPE_FOCUS_CHANGED:
 725          sh = eldbus_proxy_signal_handler_add(dbus.proxy,
 726                                               "FocusChanged",
 727                                               _cb_signal_focus_changed,
 728                                               this);
 729          EINA_SAFETY_ON_NULL_GOTO(sh, finish);
 730          break;
 731
 732       default:
 733          goto finish;
 734          break;
 735      }
 736
 737    if (ev.expire_timer)
 738      ecore_timer_del(ev.expire_timer);
 739
 740    ev.request = ev_type;
 741    ev.response = E_TC_EVENT_TYPE_NONE;
 742    ev.expire_timer = ecore_timer_add(5.0, _ev_wait_timeout, this);
 743
 744    elm_run();
 745
 746    if (ev.expire_timer)
 747      {
 748         ecore_timer_del(ev.expire_timer);
 749         ev.expire_timer = NULL;
 750      }
 751
 752    eldbus_signal_handler_del(sh);
 753
 754    res = (ev.response == ev.request);
 755    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
 756
 757 finish:
 758    ev.request = E_TC_EVENT_TYPE_NONE;
 759    ev.response = E_TC_EVENT_TYPE_NONE;
 760
 761    return res;
 762 }
 763
 764 void
 765 etRunner::work()
 766 {
 767    /* give a turn to deal with deferred job for E_TEST_WORK_TIME */
 768    worker.timer = ecore_timer_add(worker.waitTime,
 769                                   _cb_work_timeout,
 770                                   this);
 771    elm_run();
 772 }
 773
 774 void
 775 etRunner::finishWork()
 776 {
 777    if (worker.timer)
 778      {
 779         ecore_timer_del(worker.timer);
 780         worker.timer = NULL;
 781      }
 782
 783    elm_exit();
 784 }
 785
 786 void
 787 etRunner::printWinInfoList()
 788 {
 789    etWin *tw = NULL;
 790    Eina_List *l = NULL, *ll = NULL;
 791
 792    printf("--------------------------------------------------------------------------------------------------------------------------\n");
 793    l = getWinInfoList();
 794    EINA_LIST_CAST_FOREACH(l, ll, tw, etWin*)
 795      {
 796         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",
 797                tw->layer,
 798                (unsigned int)tw->native_win,
 799                tw->alpha,
 800                tw->x, tw->y, tw->w, tw->h,
 801                tw->Vis.win,
 802                tw->Vis.obj,
 803                tw->Vis.opaque,
 804                tw->Vis.type,
 805                tw->Vis.skip,
 806                tw->iconic,
 807                tw->Focus.win,
 808                tw->Focus.obj,
 809                tw->name);
 810      }
 811    freeWinInfoList(l);
 812    printf("--------------------------------------------------------------------------------------------------------------------------\n");
 813 }
 814
 815 void
 816 etRunner::delTimer()
 817 {
 818    if (!worker.timer) return;
 819
 820    ecore_timer_del(worker.timer);
 821    worker.timer = NULL;
 822 }
 823
 824 void
 825 etRunner::addTimer()
 826 {
 827    delTimer();
 828
 829    worker.timer = ecore_timer_add(worker.waitTime,
 830                                   _cb_work_timeout,
 831                                   this);
 832 }
 833
 834 void
 835 etRunner::waitForDestroy()
 836 {
 837    setWaitTime(E_TEST_WORK_TIME);
 838    addTimer();
 839
 840    elm_run();
 841 }
 842
 843 Eina_Bool
 844 etRunner::initProtocols()
 845 {
 846    Eina_Iterator *globals = NULL;
 847    Ecore_Wl2_Global *global = NULL;
 848    struct wl_registry *registry = NULL;
 849
 850    registry = ecore_wl2_display_registry_get(ecore_wl2_connected_display_get(NULL));
 851    globals = ecore_wl2_display_globals_get(ecore_wl2_connected_display_get(NULL));
 852
 853    EINA_SAFETY_ON_NULL_RETURN_VAL(registry, EINA_FALSE);
 854    EINA_SAFETY_ON_NULL_RETURN_VAL(globals, EINA_FALSE);
 855
 856    EINA_ITERATOR_FOREACH(globals, global)
 857      {
 858         if (!strcmp(global->interface, "tizen_policy"))
 859           {
 860              tzPolicy = (struct tizen_policy *)
 861                 wl_registry_bind(registry,
 862                                  global->id,
 863                                  &tizen_policy_interface,
 864                                  (global->version > 7)? 7 : global->version);
 865           }
 866         if (!strcmp(global->interface, "tizen_surface"))
 867           {
 868              tzSurface = (struct tizen_surface *)
 869                 wl_registry_bind(registry,
 870                                  global->id,
 871                                  &tizen_surface_interface,
 872                                  (global->version > 1)? 1 : global->version);
 873           }
 874      }
 875
 876    EINA_SAFETY_ON_NULL_RETURN_VAL(tzPolicy, EINA_FALSE);
 877    EINA_SAFETY_ON_NULL_RETURN_VAL(tzSurface, EINA_FALSE);
 878
 879    return EINA_TRUE;
 880 }
 881
 882 /* callbacks - method */
 883 static void
 884 _cb_method_win_info_get(void *data,
 885                         const Eldbus_Message *msg,
 886                         Eldbus_Pending *p)
 887 {
 888    const char *name = NULL, *text = NULL, *wname = NULL;
 889    etWin *tw = NULL;
 890    Eina_Bool res = EINA_FALSE;
 891
 892    tw = (etWin *)data;
 893
 894    res = eldbus_message_error_get(msg, &name, &text);
 895    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
 896
 897    res = eldbus_message_arguments_get
 898       (msg,
 899        E_TC_SIGN_WIN_INFO,
 900        &tw->native_win,
 901        &wname,
 902        &tw->x, &tw->y, &tw->w, &tw->h,
 903        &tw->layer,
 904        &tw->effect,
 905        &tw->Vis.win,
 906        &tw->Vis.obj,
 907        &tw->Vis.opaque,
 908        &tw->Vis.type,
 909        &tw->Vis.skip,
 910        &tw->iconic,
 911        &tw->alpha,
 912        &tw->Focus.win,
 913        &tw->Focus.obj,
 914        &tw->rot);
 915
 916    if (wname)
 917      {
 918         // change window name from char * to Eina_Stringshare
 919         if (tw->name)
 920           eina_stringshare_del(tw->name);
 921         tw->name = eina_stringshare_add(wname);
 922      }
 923
 924 finish:
 925    if ((name) || (text))
 926      {
 927         ERR("errname:%s errmsg:%s\n", name, text);
 928      }
 929
 930    elm_exit();
 931 }
 932
 933 static void
 934 _cb_method_win_info_list_get(void *data,
 935                              const Eldbus_Message *msg,
 936                              Eldbus_Pending *p)
 937 {
 938    const char *name = NULL, *text = NULL, *wname = NULL;
 939    Eldbus_Message_Iter *array = NULL, *ec = NULL;
 940    Ecore_Window target_win = 0;
 941    Window_Info_List *info_list = (Window_Info_List *)data;
 942    Eina_Bool res = EINA_FALSE, animating = EINA_FALSE;
 943
 944    if (info_list == NULL)
 945      goto finish;
 946
 947    res = eldbus_message_error_get(msg, &name, &text);
 948    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
 949
 950    res = eldbus_message_arguments_get(msg, "ua(" E_TC_SIGN_WIN_INFO ")", &target_win, &array);
 951    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
 952
 953    while (eldbus_message_iter_get_and_next(array, 'r', &ec))
 954      {
 955         etWin *tw = new etWin();
 956         if (!tw) continue;
 957
 958         res = eldbus_message_iter_arguments_get(
 959            ec,
 960            E_TC_SIGN_WIN_INFO,
 961            &tw->native_win,
 962            &wname,
 963            &tw->x, &tw->y, &tw->w, &tw->h,
 964            &tw->layer,
 965            &tw->effect,
 966            &tw->Vis.win,
 967            &tw->Vis.obj,
 968            &tw->Vis.opaque,
 969            &tw->Vis.type,
 970            &tw->Vis.skip,
 971            &tw->iconic,
 972            &tw->alpha,
 973            &tw->Focus.win,
 974            &tw->Focus.obj,
 975            &tw->rot);
 976
 977         if (wname)
 978           {
 979              // change name to eina_stringshare
 980              if (tw->name)
 981                {
 982                   WRN("Failed to get win info\n");
 983                   delete tw;
 984                   continue;
 985                }
 986              tw->name = eina_stringshare_add(wname);
 987           }
 988
 989         if (tw->effect)
 990           animating = EINA_TRUE;
 991
 992         if (!res)
 993           {
 994              WRN("Failed to get win info\n");
 995              delete tw;
 996              continue;
 997           }
 998
 999         info_list->list = eina_list_append(info_list->list, tw);
1000      }
1001
1002    if (animating)
1003      info_list->retry = EINA_TRUE;
1004
1005 finish:
1006    if ((name) || (text))
1007      {
1008         ERR("errname:%s errmsg:%s\n", name, text);
1009      }
1010
1011    elm_exit();
1012 }
1013
1014 static void
1015 _cb_method_window_register(void *data,
1016                            const Eldbus_Message *msg,
1017                            Eldbus_Pending *p)
1018 {
1019    const char *name = NULL, *text = NULL;
1020    Eina_Bool res = EINA_FALSE;
1021    Eina_Bool *accepted = (Eina_Bool *)data;
1022
1023    *accepted = EINA_FALSE;
1024
1025    res = eldbus_message_error_get(msg, &name, &text);
1026    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1027
1028    res = eldbus_message_arguments_get(msg, "b", accepted);
1029
1030 finish:
1031    if ((name) || (text))
1032      {
1033         ERR("errname: %s errmsg: %s\n", name, text);
1034      }
1035
1036    elm_exit();
1037 }
1038
1039 static void
1040 _cb_method_zone_rotation_change(void *data,
1041                                 const Eldbus_Message *msg,
1042                                 Eldbus_Pending *p)
1043 {
1044    const char *name = NULL, *text = NULL;
1045    Eina_Bool res = EINA_FALSE;
1046    Eina_Bool *allowed = (Eina_Bool *)data;
1047
1048    *allowed = EINA_FALSE;
1049
1050    res = eldbus_message_error_get(msg, &name, &text);
1051    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1052
1053    res = eldbus_message_arguments_get(msg, "b", allowed);
1054    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1055    EINA_SAFETY_ON_FALSE_GOTO(*allowed, finish);
1056
1057 finish:
1058    if ((name) || (text))
1059      {
1060         ERR("errname: %s errmsg: %s\n", name, text);
1061      }
1062
1063    elm_exit();
1064 }
1065
1066 static void
1067 _cb_signal_vis_changed(void *data,
1068                        const Eldbus_Message *msg)
1069 {
1070    etRunner *runner = (etRunner *)data;
1071    const char *name = NULL, *text = NULL;
1072    Eina_Bool res = EINA_FALSE;
1073    int vis = 0;
1074    Ecore_Window id;
1075
1076    res = eldbus_message_error_get(msg, &name, &text);
1077    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1078
1079    res = eldbus_message_arguments_get(msg, "ub", &id, &vis);
1080    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1081
1082    /* TODO */
1083    if (((E_TC_EVENT_TYPE_VIS_ON  == runner->ev.request) && (vis)) ||
1084        ((E_TC_EVENT_TYPE_VIS_OFF == runner->ev.request) && (!vis)) ||
1085        (E_TC_EVENT_TYPE_VIS_CHANGED == runner->ev.request))
1086      {
1087         runner->ev.response = runner->ev.request;
1088         elm_exit();
1089      }
1090
1091 finish:
1092    if ((name) || (text))
1093      {
1094         ERR("errname:%s errmsg:%s\n", name, text);
1095      }
1096 }
1097
1098 static void
1099 _cb_signal_stack_changed(void *data,
1100                          const Eldbus_Message *msg)
1101 {
1102    etRunner *runner = (etRunner *)data;
1103    const char *name = NULL, *text = NULL;
1104    Eina_Bool res = EINA_FALSE;
1105
1106    res = eldbus_message_error_get(msg, &name, &text);
1107    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1108
1109    /* TODO */
1110    if ((E_TC_EVENT_TYPE_STACK_RAISE <= runner->ev.request) &&
1111        (E_TC_EVENT_TYPE_STACK_BELOW >= runner->ev.request))
1112      {
1113         runner->ev.response = runner->ev.request;
1114         elm_exit();
1115      }
1116
1117 finish:
1118    if ((name) || (text))
1119      {
1120         ERR("errname:%s errmsg:%s\n", name, text);
1121      }
1122 }
1123
1124 static void
1125 _cb_signal_win_rot_changed(void *data,
1126                            const Eldbus_Message *msg)
1127 {
1128    etRunner *runner = (etRunner *)data;
1129    const char *name = NULL, *text = NULL;
1130    Eina_Bool res = EINA_FALSE;
1131    int angle = 0;
1132    Ecore_Window id;
1133
1134    res = eldbus_message_error_get(msg, &name, &text);
1135    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1136
1137    /* TODO unused 'window id' and 'angle' */
1138    res = eldbus_message_arguments_get(msg, "ui", &id, &angle);
1139    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1140
1141    runner->ev.response = runner->ev.request;
1142    elm_exit();
1143
1144 finish:
1145    if ((name) || (text))
1146      {
1147         ERR("errname:%s errmsg:%s\n", name, text);
1148      }
1149 }
1150
1151 static void
1152 _cb_signal_focus_changed(void *data,
1153                          const Eldbus_Message *msg)
1154 {
1155    etRunner *runner = (etRunner *)data;
1156    const char *name = NULL, *text = NULL;
1157    Eina_Bool res = EINA_FALSE;
1158
1159    res = eldbus_message_error_get(msg, &name, &text);
1160    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1161
1162    if (E_TC_EVENT_TYPE_FOCUS_CHANGED == runner->ev.request)
1163      {
1164         runner->ev.response = runner->ev.request;
1165         elm_exit();
1166      }
1167
1168 finish:
1169    if ((name) || (text))
1170      {
1171         ERR("errname:%s errmsg:%s\n", name, text);
1172      }
1173 }
1174
1175 static Eina_Bool
1176 _cb_work_timeout(void *data)
1177 {
1178    etRunner *ev_loop = (etRunner *)data;
1179    ev_loop->finishWork();
1180    return ECORE_CALLBACK_CANCEL;
1181 }
1182
1183 static Eina_Bool
1184 _ev_wait_timeout(void *data)
1185 {
1186    etRunner *runner = (etRunner *)data;
1187
1188    runner->ev.expire_timer = NULL;
1189    runner->ev.response = E_TC_EVENT_TYPE_TIMEOUT;
1190
1191    ERR("ev:%d\n", runner->ev.request);
1192
1193    elm_exit();
1194
1195    return ECORE_CALLBACK_DONE;
1196 }