src/bin/e_test_helper.c

   1 #include "e_test_helper_intern.h"
   2 #include "e_policy_wl_intern.h"
   3 #include "e_comp_canvas_intern.h"
   4 #include "e_comp_intern.h"
   5 #include "e_devicemgr_intern.h"
   6 #include "e_pixmap_intern.h"
   7 #include "e_policy_intern.h"
   8 #include "e_client_intern.h"
   9 #include "e_comp_object_intern.h"
  10 #include "e_dbus_conn_intern.h"
  11 #include "e_info_server_intern.h"
  12 #include "e_utils_intern.h"
  13 #include "e_hints_intern.h"
  14
  15 #define BUS "org.enlightenment.wm"
  16 #define PATH "/org/enlightenment/wm"
  17 #define IFACE "org.enlightenment.wm.Test"
  18
  19 #define E_TH_SIGN_WIN_INFO  "usiiiiibbbiibibbbi"
  20 #define E_TC_TIMEOUT 10.0
  21
  22 typedef struct _Test_Helper_Reg_Win
  23 {
  24    Ecore_Window win;
  25    E_Client *ec;
  26    int vis;
  27    Eina_Bool render_send;
  28 } Test_Helper_Reg_Win;
  29
  30
  31 typedef struct _Test_Helper_Data
  32 {
  33    Eldbus_Connection *conn;
  34    Eldbus_Service_Interface *iface;
  35    Ecore_Event_Handler *dbus_init_done_h;
  36
  37    Eina_List *hdlrs;
  38    Eina_List *hooks;
  39    Eina_List *reg_wins;
  40
  41    Eina_Bool tc_running;
  42    Eina_Bool tc_timer_needs;
  43    Ecore_Timer *tc_timer;
  44 } Test_Helper_Data;
  45
  46 static Test_Helper_Data *th_data = NULL;
  47
  48 static Eina_Bool _e_test_helper_cb_property_get(const Eldbus_Service_Interface *iface, const char *name, Eldbus_Message_Iter *iter, const Eldbus_Message *msg, Eldbus_Message **err);
  49
  50 static Eldbus_Message *_e_test_helper_cb_testcase_start(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  51 static Eldbus_Message *_e_test_helper_cb_testcase_end(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  52 static Eldbus_Message *_e_test_helper_cb_testcase_timeout_set(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  53 static Eldbus_Message *_e_test_helper_cb_register_window(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  54 static Eldbus_Message *_e_test_helper_cb_deregister_window(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  55 static Eldbus_Message *_e_test_helper_cb_reset_register_window(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  56 static Eldbus_Message *_e_test_helper_cb_change_stack(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  57 static Eldbus_Message *_e_test_helper_cb_activate_window(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  58 static Eldbus_Message *_e_test_helper_cb_change_iconic_state(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  59 static Eldbus_Message *_e_test_helper_cb_set_transient_for(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  60 static Eldbus_Message *_e_test_helper_cb_unset_transient_for(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  61 static Eldbus_Message *_e_test_helper_cb_set_transient_for_below(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  62 static Eldbus_Message *_e_test_helper_cb_set_noti_level(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  63 static Eldbus_Message *_e_test_helper_cb_set_focus_skip(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  64 static Eldbus_Message *_e_test_helper_cb_get_client_info(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg);
  65 static Eldbus_Message *_e_test_helper_cb_get_clients(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  66 static Eldbus_Message *_e_test_helper_cb_get_noti_level(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  67 static Eldbus_Message *_e_test_helper_cb_dpms(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  68 static Eldbus_Message *_e_test_helper_cb_ev_freeze(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  69 static Eldbus_Message *_e_test_helper_cb_kill_win(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  70 static Eldbus_Message *_e_test_helper_cb_ev_mouse(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  71 static Eldbus_Message *_e_test_helper_cb_ev_key(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  72 static Eldbus_Message *_e_test_helper_cb_hwc(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  73 static Eldbus_Message *_e_test_helper_cb_zone_rot_change(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  74 static Eldbus_Message *_e_test_helper_cb_zone_rot_get(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  75 static Eldbus_Message *_e_test_helper_cb_set_render_condition(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  76 static Eldbus_Message *_e_test_helper_cb_add_supported_aux_hint(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  77 static Eldbus_Message *_e_test_helper_cb_del_supported_aux_hint(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  78 static Eldbus_Message *_e_test_helper_cb_get_aux_hint(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  79 static Eina_Bool _e_test_helper_cb_img_render(void *data EINA_UNUSED, int type EINA_UNUSED, void *event);
  80 static Eina_Bool _e_test_helper_cb_effect_start(void *data EINA_UNUSED, int type EINA_UNUSED, void *event);
  81 static Eina_Bool _e_test_helper_cb_effect_end(void *data EINA_UNUSED, int type EINA_UNUSED, void *event);
  82
  83 enum
  84 {
  85    E_TEST_HELPER_SIGNAL_CHANGE_VISIBILITY = 0,
  86    E_TEST_HELPER_SIGNAL_RESTACK,
  87    E_TEST_HELPER_SIGNAL_WINDOW_ROTATION_CHANGED,
  88    E_TEST_HELPER_SIGNAL_FOCUS_CHANGED,
  89    E_TEST_HELPER_SIGNAL_RENDER,
  90    E_TEST_HELPER_AUX_HINT_CHANGED,
  91    E_TEST_HELPER_SIGNAL_ICONIC_STATE_CHANGED,
  92 };
  93
  94 static const Eldbus_Signal signals[] = {
  95      [E_TEST_HELPER_SIGNAL_CHANGE_VISIBILITY] =
  96        {
  97           "VisibilityChanged",
  98           ELDBUS_ARGS({"ub", "window id, visibility"}),
  99           0
 100        },
 101      [E_TEST_HELPER_SIGNAL_RESTACK] =
 102        {
 103           "StackChanged",
 104           ELDBUS_ARGS({"u", "window id was restacked"}),
 105           0
 106        },
 107      [E_TEST_HELPER_SIGNAL_WINDOW_ROTATION_CHANGED] =
 108        {
 109           "WinRotationChanged",
 110           ELDBUS_ARGS({"ui", "a window id was rotated to given angle"}),
 111           0
 112        },
 113      [E_TEST_HELPER_SIGNAL_FOCUS_CHANGED] =
 114        {
 115           "FocusChanged",
 116           ELDBUS_ARGS({"ub", "window id, focus state"}),
 117           0
 118        },
 119      [E_TEST_HELPER_SIGNAL_RENDER] =
 120        {
 121           "RenderRun",
 122           ELDBUS_ARGS({"u", "window id for tracing rendering"}),
 123           0
 124        },
 125      [E_TEST_HELPER_AUX_HINT_CHANGED] =
 126        {
 127           "AuxHintChanged",
 128           ELDBUS_ARGS({"uuss", "window id, aux_hint id, aux_hint key, aux_hint value"}),
 129           0
 130        },
 131      [E_TEST_HELPER_SIGNAL_ICONIC_STATE_CHANGED] =
 132        {
 133           "IconicStateChanged",
 134           ELDBUS_ARGS({"ubb", "window id, iconic state"}),
 135           0
 136        },
 137        { }
 138 };
 139
 140 static const Eldbus_Method methods[] ={
 141        {
 142           "StartTestCase",
 143           NULL,
 144           ELDBUS_ARGS({"b", "accept or not"}),
 145           _e_test_helper_cb_testcase_start, 0
 146        },
 147        {
 148           "EndTestCase",
 149           NULL,
 150           ELDBUS_ARGS({"b", "accept or not"}),
 151           _e_test_helper_cb_testcase_end, 0
 152        },
 153        {
 154           "SetTestTimeout",
 155           ELDBUS_ARGS({"bu", "needs timer and time in millisecond"}),
 156           ELDBUS_ARGS({"b", "accept or not"}),
 157           _e_test_helper_cb_testcase_timeout_set, 0
 158        },
 159        {
 160           "RegisterWindow",
 161           ELDBUS_ARGS({"u", "window id to be registered"}),
 162           ELDBUS_ARGS({"b", "accept or not"}),
 163           _e_test_helper_cb_register_window, 0
 164        },
 165        {
 166           "DeregisterWindow",
 167           ELDBUS_ARGS({"u", "window id to be deregistered"}),
 168           ELDBUS_ARGS({"b", "accept or not"}),
 169           _e_test_helper_cb_deregister_window, 0
 170        },
 171        {
 172           "ResetRegisterWindow",
 173           NULL,
 174           ELDBUS_ARGS({"b", "accept or not"}),
 175           _e_test_helper_cb_reset_register_window, 0
 176        },
 177        {
 178           "SetWindowStack",
 179           ELDBUS_ARGS({"uui", "window id to restack, above or below, stacking type"}),
 180           NULL,
 181           _e_test_helper_cb_change_stack, 0
 182        },
 183        {
 184           "SetWindowActivate",
 185           ELDBUS_ARGS({"u", "window id to activate"}),
 186           NULL,
 187           _e_test_helper_cb_activate_window, 0
 188        },
 189        {
 190           "SetWindowIconify",
 191           ELDBUS_ARGS({"ub", "window id to change iconic state, iconify or uniconify"}),
 192           NULL,
 193           _e_test_helper_cb_change_iconic_state, 0
 194        },
 195        {
 196           "SetWindowTransientFor",
 197           ELDBUS_ARGS({"uu", "child window id to set transient_for, parent window id to set transient_for"}),
 198           ELDBUS_ARGS({"b", "accept or not"}),
 199           _e_test_helper_cb_set_transient_for, 0
 200        },
 201        {
 202           "UnsetWindowTransientFor",
 203           ELDBUS_ARGS({"u", "child window id to set transient_for"}),
 204           ELDBUS_ARGS({"b", "accept or not"}),
 205           _e_test_helper_cb_unset_transient_for, 0
 206        },
 207        {
 208           "SetWindowTransientForBelow",
 209           ELDBUS_ARGS({"uub", "child window id to set transient_for, parent window id to set transient_for, set or unset"}),
 210           ELDBUS_ARGS({"b", "accept or not"}),
 211           _e_test_helper_cb_set_transient_for_below, 0
 212        },
 213        {
 214           "SetWindowNotiLevel",
 215           ELDBUS_ARGS({"ui", "window id to set notification level, notification level"}),
 216           NULL,
 217           _e_test_helper_cb_set_noti_level, 0
 218        },
 219        {
 220           "SetWindowFocusSkip",
 221           ELDBUS_ARGS({"ub", "window id to set focus skip, skip set or skip unset"}),
 222           NULL,
 223           _e_test_helper_cb_set_focus_skip, 0
 224        },
 225        {
 226           "GetWinInfo",
 227           ELDBUS_ARGS({"u", "window id"}),
 228           ELDBUS_ARGS({E_TH_SIGN_WIN_INFO, "information of ec"}),
 229           _e_test_helper_cb_get_client_info, 0
 230        },
 231        {
 232           "GetWinsInfo",
 233           NULL,
 234           ELDBUS_ARGS({"ua("E_TH_SIGN_WIN_INFO")", "array of ec"}),
 235           _e_test_helper_cb_get_clients, 0
 236        },
 237        {
 238           "GetWindowNotiLevel",
 239           ELDBUS_ARGS({"u", "window id to get notification level"}),
 240           ELDBUS_ARGS({"i", "notification level"}),
 241           _e_test_helper_cb_get_noti_level, 0
 242        },
 243        {
 244           "DPMS",
 245           ELDBUS_ARGS({"u", "DPMS 0=off or 1=on"}),
 246           ELDBUS_ARGS({"b", "accept or not"}),
 247           _e_test_helper_cb_dpms, 0
 248        },
 249        {
 250           "EventFreeze",
 251           ELDBUS_ARGS({"u", "0=events will start to be processed or 1=freeze input events processing"}),
 252           ELDBUS_ARGS({"b", "accept or not"}),
 253           _e_test_helper_cb_ev_freeze, 0
 254        },
 255        {
 256           "RequestKillWin",
 257           ELDBUS_ARGS({"s", "window name to kill"}),
 258           NULL,
 259           _e_test_helper_cb_kill_win, 0
 260        },
 261        {
 262           "EventMouse",
 263           ELDBUS_ARGS({"uii", "type 0=down 1=move 2=up, x position, y position"}),
 264           ELDBUS_ARGS({"b", "accept or not"}),
 265           _e_test_helper_cb_ev_mouse, 0
 266        },
 267        {
 268           "EventKey",
 269           ELDBUS_ARGS({"us", "type 0=down 1=up, key name"}),
 270           ELDBUS_ARGS({"b", "accept or not"}),
 271           _e_test_helper_cb_ev_key, 0
 272        },
 273        {
 274           "HWC",
 275           ELDBUS_ARGS({"u", "0=off or 1=on"}),
 276           ELDBUS_ARGS({"b", "accept or not"}),
 277           _e_test_helper_cb_hwc, 0
 278        },
 279        {
 280           "GetCurrentZoneRotation",
 281           NULL,
 282           ELDBUS_ARGS({"i", "a angle of current zone"}),
 283           _e_test_helper_cb_zone_rot_get, 0,
 284        },
 285        {
 286           "ChangeZoneRotation",
 287           ELDBUS_ARGS({"i", "(0, 90, 180, 270) = specific angle, -1 = unknown state"}),
 288           ELDBUS_ARGS({"b", "accept or not"}),
 289           _e_test_helper_cb_zone_rot_change, 0,
 290        },
 291        {
 292           "RenderTrace",
 293           ELDBUS_ARGS({"us", "window id and type of rendering to trace"}),
 294           ELDBUS_ARGS({"b", "accept or not"}),
 295           _e_test_helper_cb_set_render_condition, 0,
 296        },
 297        {
 298           "AddSupportedAuxHint",
 299           ELDBUS_ARGS({"s", "Aux hint string to add supported aux hint"}),
 300           ELDBUS_ARGS({"b", "accept or not"}),
 301           _e_test_helper_cb_add_supported_aux_hint, 0,
 302        },
 303        {
 304           "DelSupportedAuxHint",
 305           ELDBUS_ARGS({"s", "Aux hint string to del supported aux hint"}),
 306           ELDBUS_ARGS({"b", "accept or not"}),
 307           _e_test_helper_cb_del_supported_aux_hint, 0,
 308        },
 309        {
 310           "GetAuxHint",
 311           ELDBUS_ARGS({"us", "window id and Aux hint string to get aux hint data"}),
 312           ELDBUS_ARGS({"iss", "id, name, value"}),
 313           _e_test_helper_cb_get_aux_hint, 0,
 314        },
 315        { }
 316 };
 317
 318 static const Eldbus_Property properties[] = {
 319        { "Registrant", "au", NULL, NULL, 0 },
 320        { }
 321 };
 322
 323 static const Eldbus_Service_Interface_Desc iface_desc = {
 324      IFACE, methods, signals, properties, _e_test_helper_cb_property_get, NULL
 325 };
 326
 327 static void
 328 _e_test_helper_registrant_clear(void)
 329 {
 330    Test_Helper_Reg_Win *reg_win = NULL;
 331
 332    EINA_SAFETY_ON_NULL_RETURN(th_data);
 333    EINA_SAFETY_ON_NULL_RETURN(th_data->reg_wins);
 334
 335    EINA_LIST_FREE(th_data->reg_wins, reg_win)
 336      {
 337         if (reg_win->ec && reg_win->ec->frame)
 338           e_comp_object_render_trace_set(reg_win->ec->frame, EINA_FALSE);
 339      }
 340 }
 341
 342 static Eina_Bool
 343 _e_test_helper_registrant_remove(Ecore_Window target_win)
 344 {
 345    Test_Helper_Reg_Win *reg_win = NULL;
 346    Eina_List *l = NULL, *ll = NULL;
 347    Eina_Bool res = EINA_FALSE;
 348
 349    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, EINA_FALSE);
 350    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data->reg_wins, EINA_FALSE);
 351
 352    EINA_LIST_FOREACH_SAFE(th_data->reg_wins, l, ll, reg_win)
 353      {
 354         if (reg_win->win == target_win)
 355           {
 356              if (reg_win->ec && reg_win->ec->frame)
 357                e_comp_object_render_trace_set(reg_win->ec->frame, EINA_FALSE);
 358              th_data->reg_wins = eina_list_remove(th_data->reg_wins, reg_win);
 359              res = EINA_TRUE;
 360           }
 361      }
 362
 363    return res;
 364 }
 365
 366 static void
 367 _e_test_helper_message_append_client(Eldbus_Message_Iter *iter, E_Client *ec)
 368 {
 369    eldbus_message_iter_arguments_append
 370       (iter, E_TH_SIGN_WIN_INFO,
 371        e_pixmap_res_id_get(ec->pixmap),
 372        e_client_util_name_get(ec) ?: "NO NAME",
 373
 374        /* geometry */
 375        ec->x, ec->y, ec->w, ec->h,
 376
 377        /* layer */
 378        evas_object_layer_get(ec->frame),
 379
 380        /* effect */
 381        evas_object_data_get(ec->frame, "effect_running"),
 382
 383        /* visibility & iconify */
 384        ec->visible,
 385        evas_object_visible_get(ec->frame),
 386        ec->visibility.opaque,
 387        e_client_visibility_get(ec),
 388        ec->visibility.skip,
 389        ec->iconic ? (e_client_is_iconified_by_client(ec) ? 2 : 1) : 0,
 390
 391        /* color depth */
 392        ec->argb,
 393
 394        /* focus */
 395        ec->focused,
 396        evas_object_focus_get(ec->frame),
 397
 398        /* rotation */
 399        ec->e.state.rot.ang.curr);
 400 }
 401
 402 static Eina_Bool
 403 _e_test_helper_cb_dbus_init_done(void *data EINA_UNUSED, int type, void *event)
 404 {
 405    E_DBus_Conn_Init_Done_Event *e = event;
 406
 407    if ((e->status == E_DBUS_CONN_INIT_SUCCESS) && (e->conn_type == ELDBUS_CONNECTION_TYPE_SYSTEM))
 408      {
 409         th_data->conn = e_dbus_conn_connection_ref(ELDBUS_CONNECTION_TYPE_SYSTEM);
 410
 411         if (th_data->conn)
 412           th_data->iface = eldbus_service_interface_register(th_data->conn, PATH, &iface_desc);
 413      }
 414
 415    ecore_event_handler_del(th_data->dbus_init_done_h);
 416    th_data->dbus_init_done_h = NULL;
 417
 418    return ECORE_CALLBACK_PASS_ON;
 419 }
 420
 421 static void
 422 _e_test_helper_message_append_client_info_by_window_id(Eldbus_Message_Iter *iter, Ecore_Window win)
 423 {
 424    E_Client *ec;
 425
 426    ec = e_pixmap_find_client_by_res_id(win);
 427    if (!ec)
 428      return;
 429
 430    _e_test_helper_message_append_client(iter, ec);
 431 }
 432
 433 static void
 434 _e_test_helper_message_append_clients(Eldbus_Message_Iter *iter)
 435 {
 436    Eldbus_Message_Iter *array_of_ec;
 437    E_Client *ec;
 438    Evas_Object *o;
 439    E_Comp *comp;
 440
 441    EINA_SAFETY_ON_NULL_RETURN(th_data);
 442
 443    if (!(comp = e_comp)) return;
 444
 445    eldbus_message_iter_arguments_append(iter, "a("E_TH_SIGN_WIN_INFO")", &array_of_ec);
 446
 447    // append clients.
 448    for (o = evas_object_top_get(comp->evas); o; o = evas_object_below_get(o))
 449      {
 450         Eldbus_Message_Iter* struct_of_ec;
 451
 452         ec = evas_object_data_get(o, "E_Client");
 453         if (!ec) continue;
 454         if (e_client_util_ignored_get(ec)) continue;
 455
 456         eldbus_message_iter_arguments_append(array_of_ec, "("E_TH_SIGN_WIN_INFO")", &struct_of_ec);
 457         _e_test_helper_message_append_client(struct_of_ec, ec);
 458         eldbus_message_iter_container_close(array_of_ec, struct_of_ec);
 459      }
 460
 461    eldbus_message_iter_container_close(iter, array_of_ec);
 462 }
 463
 464 static void
 465 _e_test_helper_restack(Ecore_Window win, Ecore_Window target, int above)
 466 {
 467    E_Client *ec = NULL, *tec = NULL;
 468
 469    ec = e_pixmap_find_client_by_res_id(win);
 470    tec = e_pixmap_find_client_by_res_id(target);
 471
 472    if (!ec) return;
 473
 474    if(!tec)
 475      {
 476         if (above)
 477           {
 478              if (ec->parent)
 479                e_policy_stack_transient_child_raise(ec);
 480
 481              e_client_raise(ec);
 482           }
 483         else
 484           {
 485              if (ec->parent)
 486                e_policy_stack_transient_child_lower(ec);
 487
 488              e_client_lower(ec);
 489           }
 490      }
 491    else
 492      {
 493
 494         if (above)
 495           e_client_stack_above(ec, tec);
 496         else
 497           e_client_stack_below(ec, tec);
 498      }
 499 }
 500
 501 static Eina_Bool
 502 _e_test_helper_cb_tc_timeout(void *data)
 503 {
 504    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, ECORE_CALLBACK_DONE);
 505
 506    th_data->tc_running = EINA_FALSE;
 507    _e_test_helper_registrant_clear();
 508
 509    if (th_data->tc_timer)
 510      {
 511         ecore_timer_del(th_data->tc_timer);
 512         th_data->tc_timer = NULL;
 513      }
 514
 515    return ECORE_CALLBACK_DONE;
 516 }
 517
 518 /* Signal senders */
 519 static void
 520 _e_test_helper_send_change_visibility(Ecore_Window win, Eina_Bool vis)
 521 {
 522    Eldbus_Message *signal;
 523
 524    EINA_SAFETY_ON_NULL_RETURN(th_data);
 525
 526    signal = eldbus_service_signal_new(th_data->iface,
 527                                       E_TEST_HELPER_SIGNAL_CHANGE_VISIBILITY);
 528    eldbus_message_arguments_append(signal, "ub", win, vis);
 529    eldbus_service_signal_send(th_data->iface, signal);
 530 }
 531
 532 static void
 533 _e_test_helper_send_render(Ecore_Window win)
 534 {
 535    Eldbus_Message *signal;
 536
 537    EINA_SAFETY_ON_NULL_RETURN(th_data);
 538
 539    signal = eldbus_service_signal_new(th_data->iface, E_TEST_HELPER_SIGNAL_RENDER);
 540    eldbus_message_arguments_append(signal, "u", win);
 541    eldbus_service_signal_send(th_data->iface, signal);
 542 }
 543
 544 static void
 545 _e_test_helper_send_aux_hint_change(Ecore_Window win, int hint_id, const char *hint_key, const char *hint_val)
 546 {
 547    Eldbus_Message *signal;
 548
 549    EINA_SAFETY_ON_NULL_RETURN(th_data);
 550
 551    signal = eldbus_service_signal_new(th_data->iface, E_TEST_HELPER_AUX_HINT_CHANGED);
 552    eldbus_message_arguments_append(signal, "uuss", win, hint_id, hint_key, hint_val);
 553    eldbus_service_signal_send(th_data->iface, signal);
 554 }
 555
 556 static Test_Helper_Reg_Win *
 557 _e_test_helper_find_win_on_reg_list(Ecore_Window win)
 558 {
 559    Eina_List *l = NULL;
 560    Test_Helper_Reg_Win *reg_win = NULL;
 561
 562    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, NULL);
 563    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data->reg_wins, NULL);
 564
 565    EINA_LIST_FOREACH(th_data->reg_wins, l, reg_win)
 566      {
 567         if (reg_win->win == win)
 568           return reg_win;
 569      }
 570
 571    return NULL;
 572 }
 573
 574 /* Method Handlers */
 575 static Eldbus_Message *
 576 _e_test_helper_cb_testcase_start(const Eldbus_Service_Interface *iface EINA_UNUSED,
 577                                  const Eldbus_Message *msg)
 578 {
 579    Eldbus_Message *reply;
 580    Eina_Bool res = EINA_FALSE;
 581
 582    reply = eldbus_message_method_return_new(msg);
 583
 584    if (th_data)
 585      {
 586         if (th_data->tc_timer)
 587           ecore_timer_del(th_data->tc_timer);
 588
 589         if (th_data->tc_timer_needs)
 590           th_data->tc_timer = ecore_timer_add(E_TC_TIMEOUT, _e_test_helper_cb_tc_timeout, NULL);
 591         res = th_data->tc_running = EINA_TRUE;
 592      }
 593
 594    eldbus_message_arguments_append(reply, "b", res);
 595
 596    return reply;
 597 }
 598
 599 static Eldbus_Message *
 600 _e_test_helper_cb_testcase_end(const Eldbus_Service_Interface *iface EINA_UNUSED,
 601                                const Eldbus_Message *msg)
 602 {
 603    Eldbus_Message *reply;
 604    Eina_Bool res = EINA_FALSE;
 605
 606    reply = eldbus_message_method_return_new(msg);
 607
 608    if (th_data)
 609      {
 610         if (th_data->tc_timer)
 611           {
 612              ecore_timer_del(th_data->tc_timer);
 613              th_data->tc_timer = NULL;
 614           }
 615         th_data->tc_running = EINA_FALSE;
 616         res = EINA_TRUE;
 617      }
 618
 619    eldbus_message_arguments_append(reply, "b", res);
 620
 621    return reply;
 622 }
 623
 624 static Eldbus_Message *
 625 _e_test_helper_cb_testcase_timeout_set(const Eldbus_Service_Interface *iface EINA_UNUSED,
 626                                        const Eldbus_Message *msg)
 627 {
 628    Eldbus_Message *reply;
 629    Eina_Bool res = EINA_FALSE;
 630    Eina_Bool set = EINA_TRUE;
 631    uint32_t timeout = E_TC_TIMEOUT;
 632
 633    reply = eldbus_message_method_return_new(msg);
 634
 635    if (!eldbus_message_arguments_get(msg, "bu", &set, &timeout))
 636      {
 637         ERR("Error on eldbus_message_arguments_get()\n");
 638         goto err;
 639      }
 640
 641    if (th_data)
 642      {
 643         if (set != th_data->tc_timer_needs)
 644           {
 645              th_data->tc_timer_needs = set;
 646              if (!set)
 647                ecore_timer_del(th_data->tc_timer);
 648           }
 649
 650         if (timeout > 0)
 651           {
 652              if (th_data->tc_timer)
 653                ecore_timer_del(th_data->tc_timer);
 654
 655              if (th_data->tc_timer_needs)
 656                th_data->tc_timer = ecore_timer_add(timeout, _e_test_helper_cb_tc_timeout, NULL);
 657           }
 658         res = EINA_TRUE;
 659      }
 660
 661    eldbus_message_arguments_append(reply, "b", res);
 662
 663    return reply;
 664
 665 err:
 666    eldbus_message_arguments_append(reply, "b", EINA_FALSE);
 667    return reply;
 668 }
 669
 670 static Eldbus_Message *
 671 _e_test_helper_cb_register_window(const Eldbus_Service_Interface *iface EINA_UNUSED,
 672                                   const Eldbus_Message *msg)
 673 {
 674    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 675    Ecore_Window id;
 676    Test_Helper_Reg_Win *new_win = NULL;
 677
 678    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
 679
 680    if (!eldbus_message_arguments_get(msg, "u", &id))
 681      {
 682         ERR("Error on eldbus_message_arguments_get()\n");
 683         goto err;
 684      }
 685
 686    new_win = E_NEW(Test_Helper_Reg_Win, 1);
 687    EINA_SAFETY_ON_NULL_GOTO(new_win, err);
 688
 689    new_win->win = id;
 690    new_win->ec = e_pixmap_find_client_by_res_id(id);
 691
 692    th_data->reg_wins = eina_list_append(th_data->reg_wins, new_win);
 693    eldbus_message_arguments_append(reply, "b", EINA_TRUE);
 694
 695    return reply;
 696
 697 err:
 698    eldbus_message_arguments_append(reply, "b", EINA_FALSE);
 699    return reply;
 700 }
 701
 702 static Eldbus_Message *
 703 _e_test_helper_cb_dpms(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 704 {
 705    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 706    Eina_Bool accept = EINA_FALSE;
 707    unsigned int dpms;
 708
 709    if (!eldbus_message_arguments_get(msg, "u", &dpms))
 710      {
 711         ERR("Error on eldbus_message_arguments_get()\n");
 712         return reply;
 713      }
 714
 715    /* TODO */
 716    switch (dpms)
 717      {
 718       case 0:
 719          /* dpms off */
 720          accept = EINA_TRUE;
 721          break;
 722       case 1:
 723          /* dpms on */
 724          accept = EINA_TRUE;
 725          break;
 726       default:
 727          break;
 728      }
 729
 730    eldbus_message_arguments_append(reply, "b", accept);
 731
 732    return reply;
 733 }
 734
 735 static Eldbus_Message *
 736 _e_test_helper_cb_ev_freeze(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 737 {
 738    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 739    Eina_Bool accept = EINA_TRUE;
 740    unsigned int freeze;
 741
 742    if (!eldbus_message_arguments_get(msg, "u", &freeze))
 743      {
 744         ERR("Error on eldbus_message_arguments_get()\n");
 745         return reply;
 746      }
 747
 748    switch (freeze)
 749      {
 750       case 0: e_comp_all_thaw(); break;
 751       case 1: e_comp_all_freeze(); break;
 752       default: accept = EINA_FALSE; break;
 753      }
 754
 755    eldbus_message_arguments_append(reply, "b", accept);
 756
 757    return reply;
 758 }
 759
 760 static Eldbus_Message *
 761 _e_test_helper_cb_kill_win(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 762 {
 763    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 764    E_Client *ec = NULL;
 765    Evas_Object *o = NULL;
 766    char *win_name = NULL;
 767
 768    if (!eldbus_message_arguments_get(msg, "s", &win_name))
 769      {
 770         ERR("Error on eldbus_message_arguments_get()\n");
 771         return reply;
 772      }
 773
 774    for (o = evas_object_top_get(e_comp->evas); o; o = evas_object_below_get(o))
 775      {
 776         const char *ec_name = NULL;
 777         ec = evas_object_data_get(o, "E_Client");
 778         if (!ec) continue;
 779         if (e_client_util_ignored_get(ec)) continue;
 780
 781         ec_name = e_client_util_name_get(ec) ?: "NO NAME";
 782
 783         if (e_util_strcmp(ec_name, win_name)) continue;
 784         ELOGF("E_TEST_HELPER", "Window killed by request(ec: %s)", ec, ec? ec->icccm.name : "NO NAME");
 785         e_client_act_kill_begin(ec);
 786      }
 787
 788    return reply;
 789 }
 790
 791 static Eldbus_Message *
 792 _e_test_helper_cb_ev_mouse(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 793 {
 794    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 795    Eina_Bool accept = EINA_TRUE;
 796    Ecore_Event_Mouse_Button *ev = NULL;
 797    unsigned int type;
 798    int x, y;
 799
 800    if (!eldbus_message_arguments_get(msg, "uii", &type, &x, &y))
 801      {
 802         ERR("Error on eldbus_message_arguments_get()\n");
 803         return reply;
 804      }
 805
 806    ev = E_NEW(Ecore_Event_Mouse_Button, 1);
 807    EINA_SAFETY_ON_NULL_RETURN_VAL(ev, reply);
 808
 809    ev->timestamp = (unsigned int)(ecore_time_unix_get() * (double)1000);
 810    ev->same_screen = 1;
 811    ev->x = ev->root.x = x;
 812    ev->y = ev->root.y = y;
 813    ev->buttons = 1;
 814
 815    switch (type)
 816      {
 817       case 0: ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, ev, NULL, NULL); break;
 818       case 1: ecore_event_add(ECORE_EVENT_MOUSE_MOVE, ev, NULL, NULL); break;
 819       case 2: ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_UP, ev, NULL, NULL); break;
 820       default: accept = EINA_FALSE; break;
 821      }
 822
 823    eldbus_message_arguments_append(reply, "b", accept);
 824
 825    if (!accept)
 826      E_FREE(ev);
 827
 828    return reply;
 829 }
 830
 831 static int
 832 _e_test_helper_key_event_add(char *key_name, unsigned int type)
 833 {
 834    int res;
 835    char *device_identifier = NULL;
 836
 837    EINA_SAFETY_ON_NULL_RETURN_VAL(key_name, EINA_FALSE);
 838    EINA_SAFETY_ON_NULL_RETURN_VAL(e_devicemgr, EINA_FALSE);
 839    EINA_SAFETY_ON_NULL_RETURN_VAL(e_devicemgr->last_device_kbd, EINA_FALSE);
 840
 841    device_identifier = (char *)e_devicemgr->last_device_kbd->identifier;
 842
 843    EINA_SAFETY_ON_NULL_RETURN_VAL(device_identifier, EINA_FALSE);
 844
 845    res = e_devicemgr_inputgen_key_event_add(key_name, (Eina_Bool)type, device_identifier);
 846
 847    if (res)
 848      {
 849         ERR("[E_Test_Helper] Failed on generating key event ! (key_name=%s, type=%d)\n", key_name, type);
 850         return EINA_FALSE;
 851      }
 852
 853    return EINA_TRUE;
 854 }
 855
 856 static Eldbus_Message *
 857 _e_test_helper_cb_ev_key(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 858 {
 859    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 860    Eina_Bool accept = EINA_FALSE;
 861    unsigned int type;
 862    char *key;
 863
 864    if (!eldbus_message_arguments_get(msg, "us", &type, &key))
 865      {
 866         ERR("Error on eldbus_message_arguments_get()\n");
 867         return reply;
 868      }
 869
 870    /* TODO */
 871    switch (type)
 872      {
 873       case 0:
 874          /* key down */
 875       case 1:
 876          /* key up */
 877          accept = _e_test_helper_key_event_add(key, type);
 878          break;
 879       default:
 880          break;
 881      }
 882
 883    eldbus_message_arguments_append(reply, "b", accept);
 884
 885    return reply;
 886 }
 887
 888 static Eldbus_Message *
 889 _e_test_helper_cb_hwc(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 890 {
 891    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 892    Eina_Bool r, accept = EINA_FALSE;
 893    unsigned int on;
 894
 895    r = eldbus_message_arguments_get(msg, "u", &on);
 896    EINA_SAFETY_ON_FALSE_RETURN_VAL(r, reply);
 897
 898    if (e_comp->hwc)
 899      {
 900         switch (on)
 901           {
 902            case 0: accept = EINA_TRUE; e_comp_hwc_deactive_set(EINA_TRUE); break;
 903            case 1: accept = EINA_TRUE; e_comp_hwc_deactive_set(EINA_FALSE); break;
 904            default: break;
 905           }
 906      }
 907
 908    eldbus_message_arguments_append(reply, "b", accept);
 909
 910    return reply;
 911 }
 912
 913 static void
 914 _e_test_helper_event_zone_rot_change_free(void *data EINA_UNUSED, void *event)
 915 {
 916    E_Event_Info_Rotation_Message *ev = event;
 917
 918    e_object_unref(E_OBJECT(ev->zone));
 919    free(ev);
 920 }
 921
 922
 923 static Eldbus_Message *
 924 _e_test_helper_cb_zone_rot_change(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 925 {
 926    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 927    E_Event_Info_Rotation_Message *ev;
 928    E_Zone *zone;
 929    Eina_Bool r, accept = EINA_FALSE;
 930    int rot;
 931
 932    r = eldbus_message_arguments_get(msg, "i", &rot);
 933    EINA_SAFETY_ON_FALSE_GOTO(r, end);
 934
 935    if ((rot < 0) || (rot > 270) || ((rot % 90) != 0))
 936      goto end;
 937
 938    zone = e_zone_current_get();
 939    if (!zone)
 940      goto end;
 941
 942    ev = E_NEW(E_Event_Info_Rotation_Message, 1);
 943    if (EINA_UNLIKELY(!ev))
 944      {
 945         ERR("Failed to allocate 'E_Event_Info_Rotation_Message'");
 946         goto end;
 947      }
 948
 949    e_object_ref(E_OBJECT(zone));
 950    ev->zone = zone;
 951    ev->message = E_INFO_ROTATION_MESSAGE_SET;
 952    ev->rotation = rot;
 953    ecore_event_add(E_EVENT_INFO_ROTATION_MESSAGE, ev, _e_test_helper_event_zone_rot_change_free, NULL);
 954
 955    accept = EINA_TRUE;
 956
 957 end:
 958    eldbus_message_arguments_append(reply, "b", accept);
 959
 960    return reply;
 961 }
 962
 963 static Eldbus_Message *
 964 _e_test_helper_cb_zone_rot_get(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 965 {
 966    E_Zone *zone;
 967    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 968    Eina_Bool r;
 969    int rot = -1;
 970
 971    r = eldbus_message_arguments_get(msg, "i", &rot);
 972    EINA_SAFETY_ON_FALSE_GOTO(r, end);
 973
 974    if ((rot < 0) || (rot > 270) || ((rot % 90) != 0))
 975      goto end;
 976
 977    zone = e_zone_current_get();
 978    if (!zone)
 979      goto end;
 980
 981    eldbus_message_arguments_append(reply, "b", zone->rot.curr);
 982 end:
 983    return reply;
 984 }
 985
 986 static Eldbus_Message *
 987 _e_test_helper_cb_deregister_window(const Eldbus_Service_Interface *iface EINA_UNUSED,
 988                                     const Eldbus_Message *msg)
 989 {
 990    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 991    Ecore_Window id;
 992    Eina_Bool res = EINA_FALSE;
 993
 994    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
 995
 996    if (!eldbus_message_arguments_get(msg, "u", &id))
 997      {
 998         ERR("Error on eldbus_message_arguments_get()\n");
 999         return reply;
1000      }
1001
1002    res = _e_test_helper_registrant_remove(id);
1003    eldbus_message_arguments_append(reply, "b", res);
1004
1005    return reply;
1006 }
1007
1008 static Eldbus_Message *
1009 _e_test_helper_cb_reset_register_window(const Eldbus_Service_Interface *iface EINA_UNUSED,
1010                                         const Eldbus_Message *msg)
1011 {
1012    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1013
1014    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
1015
1016    _e_test_helper_registrant_clear();
1017
1018    eldbus_message_arguments_append(reply, "b", EINA_TRUE);
1019
1020    return reply;
1021 }
1022
1023 static Eldbus_Message*
1024 _e_test_helper_cb_change_stack(const Eldbus_Service_Interface *iface EINA_UNUSED,
1025                                const Eldbus_Message *msg)
1026 {
1027    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1028    Ecore_Window win, target;
1029    int above = -1;
1030
1031    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
1032
1033    if (!eldbus_message_arguments_get(msg, "uui", &win, &target, &above))
1034      {
1035         ERR("error on eldbus_message_arguments_get()\n");
1036         return reply;
1037      }
1038
1039    if ((win) && (above != -1))
1040      _e_test_helper_restack(win, target, above);
1041
1042    return reply;
1043 }
1044
1045 static Eldbus_Message*
1046 _e_test_helper_cb_activate_window(const Eldbus_Service_Interface *iface EINA_UNUSED,
1047                                   const Eldbus_Message *msg)
1048 {
1049    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1050    Ecore_Window win = 0x0;
1051    E_Client *ec = NULL;
1052
1053    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
1054
1055    if (!eldbus_message_arguments_get(msg, "u", &win))
1056      {
1057         ERR("error on eldbus_message_arguments_get()\n");
1058         return reply;
1059      }
1060
1061    if (win)
1062      {
1063         ec = e_pixmap_find_client_by_res_id(win);
1064         e_policy_wl_activate(ec);
1065      }
1066
1067    return reply;
1068 }
1069
1070 static Eldbus_Message*
1071 _e_test_helper_cb_change_iconic_state(const Eldbus_Service_Interface *iface EINA_UNUSED,
1072                                       const Eldbus_Message *msg)
1073 {
1074    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1075    Ecore_Window win = 0x0;
1076    Eina_Bool iconic = EINA_FALSE;
1077    E_Client *ec = NULL;
1078
1079    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
1080
1081    if (!eldbus_message_arguments_get(msg, "ub", &win, &iconic))
1082      {
1083         ERR("error on eldbus_message_arguments_get()\n");
1084         return reply;
1085      }
1086
1087    if (win)
1088      {
1089         ec = e_pixmap_find_client_by_res_id(win);
1090         if (iconic)
1091           e_policy_wl_iconify(ec);
1092         else
1093           e_policy_wl_uniconify(ec);
1094      }
1095
1096    return reply;
1097 }
1098
1099 static Eldbus_Message*
1100 _e_test_helper_cb_set_transient_for(const Eldbus_Service_Interface *iface EINA_UNUSED,
1101                                     const Eldbus_Message *msg)
1102 {
1103    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1104    Ecore_Window parent = 0x0, child = 0x0;
1105    E_Client *ec = NULL, *pec = NULL;
1106    Eina_Bool accept = EINA_FALSE;
1107
1108    EINA_SAFETY_ON_NULL_GOTO(th_data, fin);
1109
1110    if (!eldbus_message_arguments_get(msg, "uu", &child, &parent))
1111      {
1112         ERR("error on eldbus_message_arguments_get()\n");
1113         goto fin;
1114      }
1115
1116    if (parent && child)
1117      {
1118         pec = e_pixmap_find_client_by_res_id(parent);
1119         EINA_SAFETY_ON_NULL_GOTO(pec, fin);
1120
1121         ec = e_pixmap_find_client_by_res_id(child);
1122         EINA_SAFETY_ON_NULL_GOTO(ec, fin);
1123
1124         e_policy_stack_transient_for_set(ec, pec);
1125         accept = EINA_TRUE;
1126      }
1127
1128 fin:
1129    eldbus_message_arguments_append(reply, "b", accept);
1130    return reply;
1131 }
1132
1133 static Eldbus_Message*
1134 _e_test_helper_cb_unset_transient_for(const Eldbus_Service_Interface *iface EINA_UNUSED,
1135                                       const Eldbus_Message *msg)
1136 {
1137    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1138    Ecore_Window child = 0x0;
1139    E_Client *ec = NULL;
1140    Eina_Bool accept = EINA_FALSE;
1141
1142    EINA_SAFETY_ON_NULL_GOTO(th_data, fin);
1143
1144    if (!eldbus_message_arguments_get(msg, "u", &child))
1145      {
1146         ERR("error on eldbus_message_arguments_get()\n");
1147         goto fin;
1148      }
1149
1150    if (child)
1151      {
1152         ec = e_pixmap_find_client_by_res_id(child);
1153         EINA_SAFETY_ON_NULL_GOTO(ec, fin);
1154
1155         e_policy_stack_transient_for_set(ec, NULL);
1156         accept = EINA_TRUE;
1157      }
1158
1159 fin:
1160    eldbus_message_arguments_append(reply, "b", accept);
1161    return reply;
1162 }
1163
1164 static Eldbus_Message*
1165 _e_test_helper_cb_set_transient_for_below(const Eldbus_Service_Interface *iface EINA_UNUSED,
1166                                           const Eldbus_Message *msg)
1167 {
1168    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1169    Ecore_Window parent = 0x0, child = 0x0;
1170    E_Client *ec = NULL, *pec = NULL;
1171    Eina_Bool set = EINA_FALSE;
1172    Eina_Bool accept = EINA_FALSE;
1173
1174    EINA_SAFETY_ON_NULL_GOTO(th_data, fin);
1175
1176    if (!eldbus_message_arguments_get(msg, "uub", &child, &parent, &set))
1177      {
1178         ERR("error on eldbus_message_arguments_get()\n");
1179         goto fin;
1180      }
1181
1182    if (parent && child)
1183      {
1184         pec = e_pixmap_find_client_by_res_id(parent);
1185         EINA_SAFETY_ON_NULL_GOTO(pec, fin);
1186
1187         ec = e_pixmap_find_client_by_res_id(child);
1188         EINA_SAFETY_ON_NULL_GOTO(ec, fin);
1189
1190         if (set)
1191           {
1192              e_policy_stack_transient_for_below_set(ec, pec, EINA_TRUE);
1193              accept = EINA_TRUE;
1194           }
1195         else
1196           {
1197              e_policy_stack_transient_for_below_set(ec, NULL, EINA_TRUE);
1198              accept = EINA_TRUE;
1199           }
1200      }
1201
1202 fin:
1203    eldbus_message_arguments_append(reply, "b", accept);
1204    return reply;
1205 }
1206
1207 static Eldbus_Message*
1208 _e_test_helper_cb_set_noti_level(const Eldbus_Service_Interface *iface EINA_UNUSED,
1209                                  const Eldbus_Message *msg)
1210 {
1211    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1212    Ecore_Window win = 0x0;
1213    int layer = 0;
1214    E_Client *ec = NULL;
1215
1216    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
1217
1218    if (!eldbus_message_arguments_get(msg, "ui", &win, &layer))
1219      {
1220         ERR("error on eldbus_message_arguments_get()\n");
1221         return reply;
1222      }
1223
1224    if (win)
1225      {
1226         ec = e_pixmap_find_client_by_res_id(win);
1227         if (!ec) return reply;
1228
1229         e_client_layer_set(ec, layer);
1230      }
1231
1232    return reply;
1233 }
1234
1235 static Eldbus_Message*
1236 _e_test_helper_cb_set_focus_skip(const Eldbus_Service_Interface *iface EINA_UNUSED,
1237                                  const Eldbus_Message *msg)
1238 {
1239    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1240    Ecore_Window win = 0x0;
1241    Eina_Bool skip_set = EINA_FALSE;
1242    E_Client *ec = NULL;
1243
1244    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
1245
1246    if (!eldbus_message_arguments_get(msg, "ub", &win, &skip_set))
1247      {
1248         ERR("error on eldbus_message_arguments_get()\n");
1249         return reply;
1250      }
1251
1252    if (win)
1253      {
1254         ec = e_pixmap_find_client_by_res_id(win);
1255         if (!ec) return reply;
1256
1257         ec->icccm.accepts_focus = ec->icccm.take_focus = !skip_set;
1258         ec->changes.accepts_focus = 1;
1259         ec->changed = 1;
1260      }
1261
1262    return reply;
1263 }
1264
1265 static Eldbus_Message *
1266 _e_test_helper_cb_get_client_info(const Eldbus_Service_Interface *iface EINA_UNUSED,
1267                                   const Eldbus_Message *msg)
1268 {
1269    Eldbus_Message *reply;
1270    Ecore_Window win;
1271
1272    reply = eldbus_message_method_return_new(msg);
1273    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
1274
1275    if (!eldbus_message_arguments_get(msg, "u", &win))
1276      {
1277         ERR("error getting window ID");
1278         return reply;
1279      }
1280
1281    _e_test_helper_message_append_client_info_by_window_id(eldbus_message_iter_get(reply), win);
1282
1283    return reply;
1284 }
1285
1286 static Eldbus_Message *
1287 _e_test_helper_cb_get_clients(const Eldbus_Service_Interface *iface EINA_UNUSED,
1288                               const Eldbus_Message *msg)
1289 {
1290    Eldbus_Message *reply;
1291
1292    reply = eldbus_message_method_return_new(msg);
1293    _e_test_helper_message_append_clients(eldbus_message_iter_get(reply));
1294
1295    return reply;
1296 }
1297
1298 static Eldbus_Message *
1299 _e_test_helper_cb_get_noti_level(const Eldbus_Service_Interface *iface EINA_UNUSED,
1300                                  const Eldbus_Message *msg)
1301 {
1302    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1303    Ecore_Window win = 0x0;
1304    E_Client *ec = NULL;
1305    int layer = -1;
1306
1307    if (!eldbus_message_arguments_get(msg, "u", &win))
1308      {
1309         ERR("error on eldbus_message_arguments_get()\n");
1310         goto fin;
1311      }
1312
1313    ec = e_pixmap_find_client_by_res_id(win);
1314    if (!ec) goto fin;
1315
1316    layer = ec->layer;
1317
1318 fin:
1319    eldbus_message_arguments_append(reply, "i", layer);
1320    return reply;
1321 }
1322
1323 static Eina_Bool
1324 _e_test_helper_cb_visibility_change(void *data EINA_UNUSED,
1325                                     int type EINA_UNUSED,
1326                                     void *event)
1327 {
1328    E_Client *ec;
1329    Ecore_Window win = 0;
1330    E_Event_Client *ev = event;
1331    Test_Helper_Reg_Win *reg_win = NULL;
1332
1333    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, ECORE_CALLBACK_PASS_ON);
1334    if (!th_data->tc_running) return ECORE_CALLBACK_PASS_ON;
1335
1336    ec = ev->ec;
1337    win = e_pixmap_res_id_get(ec->pixmap);
1338    reg_win = _e_test_helper_find_win_on_reg_list(win);
1339
1340    if (reg_win == NULL) return ECORE_CALLBACK_PASS_ON;
1341
1342    if (reg_win->vis != !e_client_visibility_get(ec))
1343      _e_test_helper_send_change_visibility(win, !e_client_visibility_get(ec));
1344
1345    reg_win->vis = !e_client_visibility_get(ec);
1346
1347    return ECORE_CALLBACK_PASS_ON;
1348 }
1349
1350 static Eina_Bool
1351 _e_test_helper_cb_client_remove(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
1352 {
1353    E_Client *ec;
1354    E_Event_Client *ev = event;
1355    Ecore_Window win = 0;
1356
1357    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, ECORE_CALLBACK_PASS_ON);
1358
1359    ec = ev->ec;
1360    if (ec && ec->pixmap)
1361      win = e_pixmap_res_id_get(ec->pixmap);
1362
1363    if (win <= 0) return ECORE_CALLBACK_PASS_ON;
1364
1365    _e_test_helper_registrant_remove(win);
1366
1367    return ECORE_CALLBACK_PASS_ON;
1368 }
1369
1370 static Eina_Bool
1371 _e_test_helper_cb_client_restack(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
1372 {
1373    E_Event_Client *ev = event;
1374    E_Client *ec;
1375    Eldbus_Message *sig;
1376    Ecore_Window win;
1377
1378    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, ECORE_CALLBACK_PASS_ON);
1379    if (!th_data->tc_running) return ECORE_CALLBACK_PASS_ON;
1380
1381    ec = ev->ec;
1382
1383    win = e_pixmap_res_id_get(ec->pixmap);
1384    if (!_e_test_helper_find_win_on_reg_list(win)) return ECORE_CALLBACK_PASS_ON;
1385
1386    if (win)
1387      {
1388         sig = eldbus_service_signal_new(th_data->iface, E_TEST_HELPER_SIGNAL_RESTACK);
1389         eldbus_message_arguments_append(sig, "u", win);
1390         eldbus_service_signal_send(th_data->iface, sig);
1391      }
1392
1393    return ECORE_CALLBACK_PASS_ON;
1394 }
1395
1396 static Eina_Bool
1397 _e_test_helper_cb_client_rotation_end(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
1398 {
1399    E_Event_Client *ev = event;
1400    E_Client *ec;
1401    Eldbus_Message *sig;
1402    Ecore_Window win;
1403    int rot;
1404
1405    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, ECORE_CALLBACK_PASS_ON);
1406    if (!th_data->tc_running) return ECORE_CALLBACK_PASS_ON;
1407
1408    ec = ev->ec;
1409
1410    win = e_pixmap_res_id_get(ec->pixmap);
1411    if (!_e_test_helper_find_win_on_reg_list(win)) return ECORE_CALLBACK_PASS_ON;
1412
1413    rot = ec->e.state.rot.ang.curr;
1414
1415    if (win)
1416      {
1417         sig = eldbus_service_signal_new(th_data->iface, E_TEST_HELPER_SIGNAL_WINDOW_ROTATION_CHANGED);
1418         eldbus_message_arguments_append(sig, "ui", win, rot);
1419         eldbus_service_signal_send(th_data->iface, sig);
1420      }
1421
1422    return ECORE_CALLBACK_PASS_ON;
1423 }
1424
1425 static Eina_Bool
1426 _e_test_helper_cb_client_focus_changed(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
1427 {
1428    E_Event_Client *ev = event;
1429    E_Client *ec = NULL;
1430    Eldbus_Message *sig = NULL;
1431    Ecore_Window win = 0;
1432
1433    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, ECORE_CALLBACK_PASS_ON);
1434    if (!th_data->tc_running) return ECORE_CALLBACK_PASS_ON;
1435
1436    ec = ev->ec;
1437
1438    win = e_pixmap_res_id_get(ec->pixmap);
1439    if (!_e_test_helper_find_win_on_reg_list(win)) return ECORE_CALLBACK_PASS_ON;
1440
1441    if (win)
1442      {
1443         sig = eldbus_service_signal_new(th_data->iface, E_TEST_HELPER_SIGNAL_FOCUS_CHANGED);
1444         eldbus_message_arguments_append(sig, "ub", win, ec->focused);
1445         eldbus_service_signal_send(th_data->iface, sig);
1446      }
1447
1448    return ECORE_CALLBACK_PASS_ON;
1449 }
1450
1451 static Eina_Bool
1452 _e_test_helper_cb_property_get(const Eldbus_Service_Interface *iface EINA_UNUSED, const char *name, Eldbus_Message_Iter *iter, const Eldbus_Message *msg EINA_UNUSED, Eldbus_Message **err EINA_UNUSED)
1453 {
1454    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, EINA_FALSE);
1455
1456    Eldbus_Message_Iter *arr_of_win = NULL;
1457    Test_Helper_Reg_Win *reg_win = NULL;
1458    Eina_List *l = NULL;
1459
1460    if (!e_util_strcmp(name, "Registrant"))
1461      {
1462         arr_of_win = eldbus_message_iter_container_new(iter, 'a', "u");
1463
1464         EINA_LIST_FOREACH(th_data->reg_wins, l, reg_win)
1465           {
1466              eldbus_message_iter_basic_append(arr_of_win, 'u', reg_win->win);
1467           }
1468         eldbus_message_iter_container_close(iter, arr_of_win);
1469      }
1470
1471    return EINA_TRUE;
1472 }
1473
1474 static Eldbus_Message *
1475 _e_test_helper_cb_set_render_condition(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
1476 {
1477    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1478    Ecore_Window win = 0x0;
1479    Eina_Bool accept = EINA_FALSE;
1480    char *cond;
1481
1482    if (!eldbus_message_arguments_get(msg, "us", &win, &cond))
1483      {
1484         ERR("error on eldbus_message_arguments_get()\n");
1485         goto fin;
1486      }
1487
1488    // a window should be registered for tracing, otherwise reply accept FALSE
1489    if (!th_data) goto fin;
1490    if (!th_data->tc_running) goto fin;
1491    if (!th_data->reg_wins) goto fin;
1492    if (!_e_test_helper_find_win_on_reg_list(win)) goto fin;
1493
1494    // tracning condition on and off depending on "cond" string.
1495    if (!e_util_strcmp(cond, "effect"))
1496      {
1497         E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_COMP_OBJECT_EFFECT_START,
1498                               _e_test_helper_cb_effect_start, NULL);
1499         E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_COMP_OBJECT_EFFECT_END,
1500                               _e_test_helper_cb_effect_end, NULL);
1501         accept = EINA_TRUE;
1502      }
1503
1504 fin:
1505    eldbus_message_arguments_append(reply, "b", accept);
1506
1507    return reply;
1508 }
1509
1510 static Eldbus_Message *
1511 _e_test_helper_cb_add_supported_aux_hint(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
1512 {
1513    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1514    Eina_Bool accept = EINA_FALSE;
1515    const Eina_List *supported_list = NULL;
1516    char *hint;
1517
1518    if (!eldbus_message_arguments_get(msg, "s", &hint))
1519      {
1520         ERR("error on eldbus_message_arguments_get()\n");
1521         goto fin;
1522      }
1523
1524    if (!th_data) goto fin;
1525    if (!th_data->tc_running) goto fin;
1526
1527    supported_list = e_hints_aux_hint_supported_add(hint);
1528
1529    if (eina_list_data_find(supported_list, hint))
1530      accept = EINA_TRUE;
1531
1532 fin:
1533    eldbus_message_arguments_append(reply, "b", accept);
1534
1535    return reply;
1536 }
1537
1538 static Eldbus_Message *
1539 _e_test_helper_cb_del_supported_aux_hint(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
1540 {
1541    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1542    Eina_Bool accept = EINA_FALSE;
1543    const Eina_List *supported_list = NULL;
1544    char *hint;
1545
1546    if (!eldbus_message_arguments_get(msg, "s", &hint))
1547      {
1548         ERR("error on eldbus_message_arguments_get()\n");
1549         goto fin;
1550      }
1551
1552    if (!th_data) goto fin;
1553    if (!th_data->tc_running) goto fin;
1554
1555    supported_list = e_hints_aux_hint_supported_del(hint);
1556
1557    if (eina_list_data_find(supported_list, hint))
1558      accept = EINA_TRUE;
1559
1560 fin:
1561    eldbus_message_arguments_append(reply, "b", accept);
1562
1563    return reply;
1564 }
1565
1566 static Eldbus_Message *
1567 _e_test_helper_cb_get_aux_hint(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
1568 {
1569    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1570    Ecore_Window win = 0x0;
1571    Test_Helper_Reg_Win *reg_win = NULL;
1572    E_Comp_Wl_Aux_Hint *ecah;
1573    E_Client *ec;
1574    Eina_List *l;
1575
1576    int id = -1;
1577    const char *hint = NULL, *val = NULL;
1578
1579    if (!eldbus_message_arguments_get(msg, "us", &win, &hint))
1580      {
1581         ERR("error on eldbus_message_arguments_get()\n");
1582         goto fin;
1583      }
1584
1585    if (!th_data) goto fin;
1586    if (!th_data->tc_running) goto fin;
1587    if (!th_data->reg_wins) goto fin;
1588    if (!(reg_win = _e_test_helper_find_win_on_reg_list(win))) goto fin;
1589    if (!(ec = reg_win->ec)) goto fin;
1590
1591    EINA_LIST_REVERSE_FOREACH(ec->comp_data->aux_hint.hints, l, ecah)
1592      {
1593         if ((!ecah->deleted) &&
1594             (!e_util_strcmp(ecah->hint, hint)))
1595           {
1596              id = ecah->id;
1597              hint = ecah->hint;
1598              val = ecah->val;
1599              break;
1600           }
1601      }
1602
1603 fin:
1604    eldbus_message_arguments_append(reply, "iss", id, hint, val);
1605
1606    return reply;
1607 }
1608
1609 static Eina_Bool
1610 _e_test_helper_cb_img_render(void *data EINA_UNUSED,
1611                              int type EINA_UNUSED,
1612                              void *event)
1613 {
1614    E_Client *ec;
1615    E_Event_Comp_Object *ev = event;
1616    Ecore_Window win = 0;
1617    Test_Helper_Reg_Win *reg_win = NULL;
1618
1619    if (!(ec = evas_object_data_get(ev->comp_object, "E_Client")))
1620      return ECORE_CALLBACK_DONE;
1621
1622    // a window should be registered for tracing
1623    if (!th_data) return ECORE_CALLBACK_DONE;
1624    if (!th_data->tc_running) return ECORE_CALLBACK_DONE;
1625    if (!th_data->reg_wins) return ECORE_CALLBACK_DONE;
1626
1627    win = e_pixmap_res_id_get(ec->pixmap);
1628    reg_win = _e_test_helper_find_win_on_reg_list(win);
1629
1630    if (reg_win && reg_win->render_send)
1631      _e_test_helper_send_render(win);
1632
1633    return ECORE_CALLBACK_DONE;
1634 }
1635
1636 static Eina_Bool
1637 _e_test_helper_cb_effect_start(void *data EINA_UNUSED,
1638                                int type EINA_UNUSED,
1639                                void *event)
1640 {
1641    E_Client *ec;
1642    E_Event_Comp_Object *ev = event;
1643    Ecore_Window win = 0;
1644    Test_Helper_Reg_Win *reg_win = NULL;
1645
1646    if (!(ec = evas_object_data_get(ev->comp_object, "E_Client")))
1647      return ECORE_CALLBACK_DONE;
1648
1649    // a window should be registered for tracing
1650    if (!th_data) return ECORE_CALLBACK_DONE;
1651    if (!th_data->tc_running) return ECORE_CALLBACK_DONE;
1652    if (!th_data->reg_wins) return ECORE_CALLBACK_DONE;
1653
1654    win = e_pixmap_res_id_get(ec->pixmap);
1655    reg_win = _e_test_helper_find_win_on_reg_list(win);
1656
1657    if (reg_win && ec && ec->frame)
1658      {
1659         reg_win->render_send = EINA_TRUE;
1660         e_comp_object_render_trace_set(ec->frame, EINA_TRUE);
1661         e_pixmap_image_refresh(ec->pixmap);
1662         e_comp_object_dirty(ec->frame);
1663      }
1664
1665    return ECORE_CALLBACK_DONE;
1666 }
1667
1668 static Eina_Bool
1669 _e_test_helper_cb_effect_end(void *data EINA_UNUSED,
1670                              int type EINA_UNUSED,
1671                              void *event)
1672 {
1673    E_Client *ec;
1674    E_Event_Comp_Object *ev = event;
1675    Ecore_Window win = 0;
1676    Test_Helper_Reg_Win *reg_win = NULL;
1677
1678    ec = evas_object_data_get(ev->comp_object, "E_Client");
1679    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, ECORE_CALLBACK_DONE);
1680
1681    // a window should be registered for tracing
1682    if (!th_data) return ECORE_CALLBACK_DONE;
1683    if (!th_data->tc_running) return ECORE_CALLBACK_DONE;
1684    if (!th_data->reg_wins) return ECORE_CALLBACK_DONE;
1685
1686    win = e_pixmap_res_id_get(ec->pixmap);
1687    reg_win = _e_test_helper_find_win_on_reg_list(win);
1688
1689    if (reg_win && ec->frame)
1690      {
1691         e_comp_object_render_trace_set(ec->frame, EINA_FALSE);
1692         reg_win->render_send = EINA_FALSE;
1693      }
1694
1695    return ECORE_CALLBACK_DONE;
1696 }
1697
1698 static void
1699 _e_test_helper_hook_cb_client_aux_hint_change(void *data EINA_UNUSED, E_Client *ec)
1700 {
1701    Ecore_Window win = 0;
1702    E_Comp_Wl_Client_Data *cdata = e_client_cdata_get(ec);
1703    Eina_List *l, *ll;
1704    E_Comp_Wl_Aux_Hint *hint;
1705
1706    EINA_SAFETY_ON_NULL_RETURN(th_data);
1707    if (!th_data->tc_running) return;
1708
1709    win = e_pixmap_res_id_get(ec->pixmap);
1710    if (!_e_test_helper_find_win_on_reg_list(win)) return;
1711
1712    if (win)
1713      {
1714         EINA_LIST_FOREACH_SAFE(cdata->aux_hint.hints, l, ll, hint)
1715           {
1716              if (hint->changed)
1717                {
1718                   _e_test_helper_send_aux_hint_change(win, hint->id, hint->hint, hint->val);
1719                }
1720           }
1721      }
1722 }
1723
1724 static Eina_Bool
1725 _e_test_helper_cb_client_iconic_state_changed(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
1726 {
1727    E_Event_Client *ev = event;
1728    E_Client *ec;
1729    Eldbus_Message *sig;
1730    Ecore_Window win;
1731
1732    if (!th_data->tc_running) return ECORE_CALLBACK_PASS_ON;
1733
1734    ec = ev->ec;
1735    if (!ec) return ECORE_CALLBACK_PASS_ON;
1736
1737    win = e_pixmap_res_id_get(ec->pixmap);
1738    if (!win) return ECORE_CALLBACK_PASS_ON;
1739
1740    if (!_e_test_helper_find_win_on_reg_list(win)) return ECORE_CALLBACK_PASS_ON;
1741
1742    sig = eldbus_service_signal_new(th_data->iface, E_TEST_HELPER_SIGNAL_ICONIC_STATE_CHANGED);
1743    eldbus_message_arguments_append(sig, "ubb", win, ec->iconic, e_client_is_iconified_by_client(ec));
1744    eldbus_service_signal_send(th_data->iface, sig);
1745
1746    return ECORE_CALLBACK_PASS_ON;
1747 }
1748
1749 /* externally accessible functions */
1750 EINTERN int
1751 e_test_helper_init(void)
1752 {
1753    Eina_Bool res = EINA_FALSE;
1754
1755    EINA_SAFETY_ON_TRUE_GOTO((e_dbus_conn_init() <= 0), err);
1756
1757    th_data = E_NEW(Test_Helper_Data, 1);
1758    EINA_SAFETY_ON_NULL_GOTO(th_data, err);
1759
1760    th_data->dbus_init_done_h = ecore_event_handler_add(E_EVENT_DBUS_CONN_INIT_DONE, _e_test_helper_cb_dbus_init_done, NULL);
1761    EINA_SAFETY_ON_NULL_GOTO(th_data->dbus_init_done_h, err);
1762
1763    res = e_dbus_conn_dbus_init(ELDBUS_CONNECTION_TYPE_SYSTEM);
1764    EINA_SAFETY_ON_FALSE_GOTO(res, err);
1765
1766    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_VISIBILITY_CHANGE,
1767                          _e_test_helper_cb_visibility_change, NULL);
1768    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_REMOVE,
1769                          _e_test_helper_cb_client_remove, NULL);
1770    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_STACK,
1771                         _e_test_helper_cb_client_restack, NULL);
1772    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_ROTATION_CHANGE_END,
1773                          _e_test_helper_cb_client_rotation_end, NULL);
1774    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_FOCUS_IN,
1775                          _e_test_helper_cb_client_focus_changed, NULL);
1776    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_FOCUS_OUT,
1777                          _e_test_helper_cb_client_focus_changed, NULL);
1778    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_COMP_OBJECT_IMG_RENDER,
1779                           _e_test_helper_cb_img_render, NULL);
1780    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_ICONIFY,
1781                           _e_test_helper_cb_client_iconic_state_changed, NULL);
1782    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_UNICONIFY,
1783                           _e_test_helper_cb_client_iconic_state_changed, NULL);
1784
1785    E_LIST_HOOK_APPEND(th_data->hooks, E_CLIENT_HOOK_AUX_HINT_CHANGE,
1786                       _e_test_helper_hook_cb_client_aux_hint_change, NULL);
1787
1788    return 1;
1789
1790 err:
1791    e_test_helper_shutdown();
1792    return 0;
1793 }
1794
1795 EINTERN int
1796 e_test_helper_shutdown(void)
1797 {
1798    if (th_data)
1799      {
1800         E_FREE_LIST(th_data->hdlrs, ecore_event_handler_del);
1801
1802         _e_test_helper_registrant_clear();
1803
1804         if (th_data->tc_timer)
1805           {
1806              ecore_timer_del(th_data->tc_timer);
1807              th_data->tc_timer = NULL;
1808           }
1809
1810         if (th_data->dbus_init_done_h)
1811           {
1812              ecore_event_handler_del(th_data->dbus_init_done_h);
1813              th_data->dbus_init_done_h = NULL;
1814           }
1815
1816         if (th_data->conn)
1817           {
1818              if (th_data->iface)
1819                eldbus_service_interface_unregister(th_data->iface);
1820
1821              e_dbus_conn_connection_unref(th_data->conn);
1822              th_data->conn = NULL;
1823           }
1824
1825         e_dbus_conn_shutdown();
1826
1827         E_FREE(th_data);
1828      }
1829
1830    return 1;
1831 }