src/efl_util.c

   1 /*
   2  * Copyright (c) 2011-2017 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #define LOG_TAG "TIZEN_N_EFL_UTIL"
  18
  19 #include <efl_util.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <xf86drm.h>
  28 #include <tbm_bufmgr.h>
  29 #include <tbm_surface.h>
  30 #include <tbm_surface_internal.h>
  31 #include <Elementary.h>
  32 #include <Ecore_Evas.h>
  33 #include <pthread.h>
  34
  35 #include <Ecore_Wl2.h>
  36 #include <wayland-client.h>
  37 #include <wayland-tbm-client.h>
  38 #include <tizen-extension-client-protocol.h>
  39 #include <screenshooter-client-protocol.h>
  40
  41 #include <efl_util_screenshot_extension.h>
  42
  43 #include <dlog.h>
  44 #ifdef LOG_TAG
  45 #undef LOG_TAG
  46 #endif
  47
  48 #define LOG_TAG "TIZEN_N_EFL_UTIL"
  49 #define EFL_UTIL_INPUT_GENERATOR_DEFAULT_TIME_OUT 1000
  50 #define EFL_UTIL_INPUT_GENERATOR_DEFAULT_DISPATCH_TIME_OUT 10
  51 #define EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER 10
  52
  53 typedef struct _Efl_Util_Wl_Surface_Lv_Info
  54 {
  55    void *surface; /* wl_surface */
  56    int level;
  57    Eina_Bool wait_for_done;
  58    uint32_t state;
  59 } Efl_Util_Wl_Surface_Lv_Info;
  60
  61 typedef struct _Efl_Util_Wl_Surface_Scr_Mode_Info
  62 {
  63    void *surface; /* wl_surface */
  64    unsigned int mode;
  65    Eina_Bool wait_for_done;
  66    uint32_t state;
  67 } Efl_Util_Wl_Surface_Scr_Mode_Info;
  68
  69 typedef struct _Efl_Util_Wl_Surface_Brightness_Info
  70 {
  71    void *surface; /* wl_surface */
  72    int brightness;
  73    Eina_Bool wait_for_done;
  74    uint32_t state;
  75 } Efl_Util_Wl_Surface_Brightness_Info;
  76
  77 typedef struct _Efl_Util_Wl_Output_Info
  78 {
  79     struct wl_output *output;
  80     int offset_x, offset_y, width, height;
  81 } Efl_Util_Wl_Output_Info;
  82
  83 typedef struct _Efl_Util_Gesture_Common_Grab_Data
  84 {
  85    int type;
  86 } Efl_Util_Gesture_Common_Grab_Data;
  87
  88 typedef struct _Efl_Util_Gesture_Edge_Swipe_Grab_Data
  89 {
  90    Efl_Util_Gesture_Common_Grab_Data base;
  91
  92    unsigned int fingers;
  93    efl_util_gesture_edge_e edge;
  94    efl_util_gesture_edge_size_e edge_size;
  95    unsigned int start_point;
  96    unsigned int end_point;
  97 } Efl_Util_Gesture_Edge_Swipe_Grab_Data;
  98
  99 typedef struct _Efl_Util_Gesture_Edge_Drag_Grab_Data
 100 {
 101    Efl_Util_Gesture_Common_Grab_Data base;
 102
 103    unsigned int fingers;
 104    efl_util_gesture_edge_e edge;
 105    efl_util_gesture_edge_size_e edge_size;
 106    unsigned int start_point;
 107    unsigned int end_point;
 108 } Efl_Util_Gesture_Edge_Drag_Grab_Data;
 109
 110 typedef struct _Efl_Util_Gesture_Tap_Grab_Data
 111 {
 112    Efl_Util_Gesture_Common_Grab_Data base;
 113
 114    unsigned int fingers;
 115    unsigned int repeats;
 116 } Efl_Util_Gesture_Tap_Grab_Data;
 117
 118 typedef struct _Efl_Util_Gesture_Palm_Cover_Grab_Data
 119 {
 120    Efl_Util_Gesture_Common_Grab_Data base;
 121 } Efl_Util_Gesture_Palm_Cover_Grab_Data;
 122
 123 typedef struct _Efl_Util_Device_Info
 124 {
 125    struct tizen_input_device *device;
 126    Ecore_Device_Class clas;
 127    Eina_Stringshare *name;
 128 } Efl_Util_Device_Info;
 129
 130 typedef struct _E_Devicemgr_Inputgen_Touch_Axis
 131 {
 132    double radius_x;
 133    double radius_y;
 134    double pressure;
 135    double angle;
 136    double palm;
 137 } E_Devicemgr_Inputgen_Touch_Axis;
 138
 139 typedef struct _Efl_Util_Data
 140 {
 141    /* wayland related stuffs */
 142    struct
 143    {
 144       Eina_Bool init;
 145       Ecore_Wl2_Display *wl2_display;
 146       struct wl_display *dpy;
 147       struct wl_event_queue *queue;
 148
 149       struct
 150       {
 151          unsigned int id;
 152          struct tizen_policy *proto;
 153          Eina_Hash *hash_noti_lv;
 154          Eina_Hash *hash_scr_mode;
 155       } policy;
 156       struct
 157       {
 158          struct wl_event_queue *queue;
 159          struct screenshooter *screenshooter;
 160          struct tizen_screenshooter *tz_screenshooter;
 161          struct wayland_tbm_client *tbm_client;
 162          Eina_List *output_list;
 163          uint32_t noti;
 164       } shot;
 165       struct
 166       {
 167          struct tizen_input_device_manager *devicemgr;
 168          int request_notified;
 169          Eina_List *devices;
 170          Eina_List *wait_devices;
 171          struct wl_event_source *wait_timer;
 172          int max_touch_count;
 173          int request_touch_count;
 174       } devmgr;
 175       struct wl_seat *seat;
 176       struct
 177       {
 178          unsigned int id;
 179          struct tizen_display_policy *proto;
 180          Eina_Hash *hash_brightness;
 181       } display_policy;
 182    } wl;
 183 } Efl_Util_Data;
 184
 185 typedef struct _Efl_Util_Data_Default_Queue
 186 {
 187    /* wayland related stuffs */
 188    struct
 189    {
 190       Eina_Bool init;
 191       Ecore_Wl2_Display *wl2_display;
 192       struct wl_display *dpy;
 193
 194       struct
 195       {
 196          unsigned int id;
 197          struct tizen_gesture *proto;
 198          int request_notified;
 199          int event_init;
 200       } gesture;
 201    } wl;
 202 } Efl_Util_Data_Default_Queue;
 203
 204
 205 static Efl_Util_Data _eflutil =
 206 {
 207    {
 208       EINA_FALSE,
 209       NULL, NULL, NULL,
 210       { 0, NULL, NULL, NULL }, /* tizen_policy protocol */
 211       { NULL, NULL, NULL, NULL, NULL, 0 }, /* screenshooter protocol */
 212       { NULL, -1, NULL, NULL, NULL, 0, 0 }, /* tizen_input_device_manager protocol */
 213       NULL, /* wl_seat protocol */
 214       { 0, NULL, NULL } /* display_policy protocol */
 215    },
 216 };
 217
 218 static Efl_Util_Data_Default_Queue _eflutil_defaultqueue =
 219 {
 220    {
 221       EINA_FALSE,
 222       NULL, NULL,
 223       { 0, NULL, -1, 0 } /* gesture protocol */
 224    },
 225 };
 226
 227
 228 static Eina_Bool               _wl_init(void);
 229 static Eina_Bool               _wl_init_default_queue(void);
 230 static void                    _cb_wl_reg_global(void *data, struct wl_registry *reg, unsigned int name, const char *interface, unsigned int version);
 231 static void                    _cb_wl_reg_global_remove(void *data, struct wl_registry *reg, unsigned int name);
 232 static void                    _cb_wl_default_queue_reg_global(void *data, struct wl_registry *reg, unsigned int name, const char *interface, unsigned int version);
 233 static void                    _cb_wl_default_queue_reg_global_remove(void *data, struct wl_registry *reg, unsigned int name);
 234 static void                    _cb_wl_reg_screenshooter_global(void *data, struct wl_registry *reg, unsigned int name, const char *interface, unsigned int version);
 235 static void                    _cb_wl_reg_screenshooter_global_remove(void *data, struct wl_registry *reg, unsigned int name);
 236 static void                    _cb_wl_tz_policy_conformant(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface, uint32_t is_conformant);
 237 static void                    _cb_wl_tz_policy_conformant_area(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface, uint32_t conformant_part, uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h);
 238 static void                    _cb_wl_tz_policy_notification_done(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface, int32_t level, uint32_t state);
 239 static void                    _cb_wl_tz_policy_transient_for_done(void *data, struct tizen_policy *tizen_policy, uint32_t child_id);
 240 static void                    _cb_wl_tz_policy_scr_mode_done(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface, uint32_t mode, uint32_t state);
 241 static void                    _cb_wl_tz_policy_iconify_state_changed(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, uint32_t iconified, uint32_t force);
 242 static void                    _cb_wl_tz_policy_supported_aux_hints(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, struct wl_array *hints, uint32_t num_hints);
 243 static void                    _cb_wl_tz_policy_allowed_aux_hint(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, int id);
 244 static void                    _cb_wl_tz_policy_aux_message(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, const char *key, const char *val, struct wl_array *options);
 245 static void                    _cb_wl_conformant_region(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface, uint32_t conformant_part, uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h, uint32_t serial);
 246
 247 static void                    _cb_wl_tz_display_policy_brightness_done(void *data, struct tizen_display_policy *tizen_display_policy, struct wl_surface *surface_resource, int32_t brightness, uint32_t state);
 248
 249 static void                    _cb_device_info(void *data, struct tizen_input_device *tizen_input_device EINA_UNUSED, const char *name, uint32_t clas, uint32_t subclas EINA_UNUSED, struct wl_array *axes EINA_UNUSED);
 250 static void                    _cb_event_device(void *data EINA_UNUSED, struct tizen_input_device *tizen_input_device EINA_UNUSED, unsigned int serial EINA_UNUSED, const char *name EINA_UNUSED, uint32_t time EINA_UNUSED);
 251 static void                    _cb_axis(void *data EINA_UNUSED, struct tizen_input_device *tizen_input_device EINA_UNUSED, uint32_t axis_type EINA_UNUSED, wl_fixed_t value EINA_UNUSED);
 252
 253 static void                    _cb_device_add(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED, uint32_t serial  EINA_UNUSED, const char *identifier  EINA_UNUSED, struct tizen_input_device *device  EINA_UNUSED, struct wl_seat *seat EINA_UNUSED);
 254 static void                    _cb_device_remove(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED, uint32_t serial EINA_UNUSED, const char *identifier  EINA_UNUSED, struct tizen_input_device *device EINA_UNUSED, struct wl_seat *seat EINA_UNUSED);
 255 static void                    _cb_error(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED, uint32_t errorcode);
 256 static void                    _cb_block_expired(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED);
 257 static void                    _cb_max_touch_count(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED, uint32_t serial EINA_UNUSED, int32_t max_count EINA_UNUSED, struct wl_seat *seat EINA_UNUSED);
 258
 259 static void                    _cb_gesture_edge_swipe_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t fingers EINA_UNUSED, uint32_t edge EINA_UNUSED, uint32_t edge_size EINA_UNUSED, uint32_t start_point EINA_UNUSED, uint32_t end_point EINA_UNUSED, uint32_t error);
 260 static void                    _cb_gesture_edge_swipe(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t mode, uint32_t fingers, int sx, int sy, uint32_t edge);
 261 static void                    _cb_gesture_edge_drag_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t fingers EINA_UNUSED, uint32_t edge EINA_UNUSED, uint32_t edge_size EINA_UNUSED, uint32_t start_point EINA_UNUSED, uint32_t end_point EINA_UNUSED, uint32_t error);
 262 static void                    _cb_gesture_edge_drag(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t mode, uint32_t fingers, int cx, int cy, uint32_t edge);
 263 static void                    _cb_gesture_tap_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t fingers EINA_UNUSED, uint32_t repeats EINA_UNUSED, uint32_t error);
 264 static void                    _cb_gesture_tap(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t mode, uint32_t fingers, uint32_t repeats);
 265 static void                    _cb_gesture_palm_cover_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, struct wl_surface *surface EINA_UNUSED, uint32_t error);
 266 static void                    _cb_gesture_palm_cover(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, struct wl_surface *surface EINA_UNUSED, uint32_t mode, uint32_t duration, int cx, int cy, uint32_t size, wl_fixed_t pressure);
 267 static void                    _cb_gesture_activate_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, struct wl_surface *surface EINA_UNUSED, uint32_t type EINA_UNUSED, uint32_t active EINA_UNUSED, uint32_t error);
 268
 269
 270 static const struct wl_registry_listener _wl_reg_listener =
 271 {
 272    _cb_wl_reg_global,
 273    _cb_wl_reg_global_remove
 274 };
 275
 276 static const struct wl_registry_listener _wl_reg_screenshooter_listener =
 277 {
 278    _cb_wl_reg_screenshooter_global,
 279    _cb_wl_reg_screenshooter_global_remove
 280 };
 281
 282 struct tizen_policy_listener _wl_tz_policy_listener =
 283 {
 284    _cb_wl_tz_policy_conformant,
 285    _cb_wl_tz_policy_conformant_area,
 286    _cb_wl_tz_policy_notification_done,
 287    _cb_wl_tz_policy_transient_for_done,
 288    _cb_wl_tz_policy_scr_mode_done,
 289    _cb_wl_tz_policy_iconify_state_changed,
 290    _cb_wl_tz_policy_supported_aux_hints,
 291    _cb_wl_tz_policy_allowed_aux_hint,
 292    _cb_wl_tz_policy_aux_message,
 293    _cb_wl_conformant_region,
 294 };
 295
 296 static const struct tizen_input_device_listener _wl_tz_input_device_listener =
 297 {
 298    _cb_device_info,
 299    _cb_event_device,
 300    _cb_axis,
 301 };
 302
 303 struct tizen_input_device_manager_listener _wl_tz_devmgr_listener =
 304 {
 305    _cb_device_add,
 306    _cb_device_remove,
 307    _cb_error,
 308    _cb_block_expired,
 309    _cb_max_touch_count
 310 };
 311
 312 struct tizen_display_policy_listener _wl_tz_display_policy_listener =
 313 {
 314    _cb_wl_tz_display_policy_brightness_done,
 315 };
 316
 317 static const struct wl_registry_listener _wl_default_queue_reg_listener =
 318 {
 319    _cb_wl_default_queue_reg_global,
 320    _cb_wl_default_queue_reg_global_remove
 321 };
 322
 323 struct tizen_gesture_listener _wl_tz_gesture_listener =
 324 {
 325    _cb_gesture_edge_swipe_notify,
 326    _cb_gesture_edge_swipe,
 327    _cb_gesture_edge_drag_notify,
 328    _cb_gesture_edge_drag,
 329    _cb_gesture_tap_notify,
 330    _cb_gesture_tap,
 331    _cb_gesture_palm_cover_notify,
 332    _cb_gesture_palm_cover,
 333    _cb_gesture_activate_notify
 334 };
 335
 336 static Eina_Bool
 337 _wl_init(void)
 338 {
 339    struct wl_display *display_wrapper = NULL;
 340    struct wl_registry *reg = NULL;
 341
 342    if (_eflutil.wl.init) return EINA_TRUE;
 343
 344    ecore_wl2_init();
 345
 346    _eflutil.wl.wl2_display = ecore_wl2_display_connect(NULL);
 347    EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.wl2_display, fail);
 348    _eflutil.wl.dpy = ecore_wl2_display_get(_eflutil.wl.wl2_display);
 349    EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.dpy, fail);
 350
 351    display_wrapper = wl_proxy_create_wrapper(_eflutil.wl.dpy);
 352    EINA_SAFETY_ON_NULL_GOTO(display_wrapper, fail);
 353
 354    _eflutil.wl.queue = wl_display_create_queue(_eflutil.wl.dpy);
 355    EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.queue, fail);
 356
 357    wl_proxy_set_queue((struct wl_proxy *)display_wrapper, _eflutil.wl.queue);
 358
 359    reg = wl_display_get_registry(display_wrapper);
 360    wl_proxy_wrapper_destroy(display_wrapper);
 361    display_wrapper = NULL;
 362    EINA_SAFETY_ON_NULL_GOTO(reg, fail);
 363
 364    wl_registry_add_listener(reg, &_wl_reg_listener, NULL);
 365
 366    _eflutil.wl.init = EINA_TRUE;
 367
 368    return EINA_TRUE;
 369 fail:
 370    if (display_wrapper)
 371      wl_proxy_wrapper_destroy(display_wrapper);
 372
 373    if (_eflutil.wl.queue)
 374      {
 375         wl_event_queue_destroy(_eflutil.wl.queue);
 376         _eflutil.wl.queue = NULL;
 377      }
 378
 379    ecore_wl2_shutdown();
 380    return EINA_FALSE;
 381 }
 382
 383 static Eina_Bool
 384 _wl_init_default_queue(void)
 385 {
 386    struct wl_display *display_wrapper = NULL;
 387    struct wl_registry *reg = NULL;
 388
 389    if (_eflutil_defaultqueue.wl.init) return EINA_TRUE;
 390
 391    if (ecore_wl2_init() <= 0) return EINA_FALSE;
 392
 393    _eflutil_defaultqueue.wl.wl2_display = ecore_wl2_connected_display_get(NULL);
 394    EINA_SAFETY_ON_NULL_GOTO(_eflutil_defaultqueue.wl.wl2_display, fail);
 395    _eflutil_defaultqueue.wl.dpy = ecore_wl2_display_get(_eflutil_defaultqueue.wl.wl2_display);
 396    EINA_SAFETY_ON_NULL_GOTO(_eflutil_defaultqueue.wl.dpy, fail);
 397
 398    display_wrapper = wl_proxy_create_wrapper(_eflutil_defaultqueue.wl.dpy);
 399    EINA_SAFETY_ON_NULL_GOTO(display_wrapper, fail);
 400
 401    reg = wl_display_get_registry(display_wrapper);
 402    wl_proxy_wrapper_destroy(display_wrapper);
 403    display_wrapper = NULL;
 404    EINA_SAFETY_ON_NULL_GOTO(reg, fail);
 405
 406    wl_registry_add_listener(reg, &_wl_default_queue_reg_listener, NULL);
 407
 408    _eflutil_defaultqueue.wl.init = EINA_TRUE;
 409
 410    return EINA_TRUE;
 411 fail:
 412
 413    ecore_wl2_shutdown();
 414    return EINA_FALSE;
 415 }
 416
 417 static void
 418 _cb_wl_output_geometry(void *data, struct wl_output *wl_output, int x, int y,
 419                        int physical_width, int physical_height, int subpixel,
 420                        const char *make, const char *model, int transform)
 421 {
 422    Efl_Util_Wl_Output_Info *output = wl_output_get_user_data(wl_output);
 423    if (wl_output == output->output)
 424      {
 425         output->offset_x = x;
 426         output->offset_y = y;
 427      }
 428 }
 429
 430 static void
 431 _cb_wl_output_mode(void *data, struct wl_output *wl_output, uint32_t flags,
 432                    int width, int height, int refresh)
 433 {
 434    Efl_Util_Wl_Output_Info *output = wl_output_get_user_data(wl_output);
 435    if (wl_output == output->output && (flags & WL_OUTPUT_MODE_CURRENT))
 436      {
 437         output->width = width;
 438         output->height = height;
 439      }
 440 }
 441
 442 static void
 443 _cb_wl_output_done(void *data, struct wl_output *wl_output)
 444 {
 445 }
 446
 447 static void
 448 _cb_wl_output_scale(void *data, struct wl_output *wl_output, int32_t factor)
 449 {
 450 }
 451
 452 static const struct wl_output_listener output_listener =
 453 {
 454     _cb_wl_output_geometry,
 455     _cb_wl_output_mode,
 456     _cb_wl_output_done,
 457     _cb_wl_output_scale
 458 };
 459
 460 static void
 461 _cb_wl_screenshot_done(void *data, struct screenshooter *screenshooter)
 462 {
 463    Eina_Bool *shot_done = (Eina_Bool*)data;
 464    if (shot_done)
 465      *shot_done = EINA_TRUE;
 466 }
 467
 468 static const struct screenshooter_listener screenshooter_listener =
 469 {
 470     _cb_wl_screenshot_done
 471 };
 472
 473 static void
 474 _cb_tz_screenshot_format(void *data, struct tizen_screenshooter *tz_screenshooter, uint32_t format)
 475 {
 476 }
 477
 478 static void
 479 _cb_tz_screenshot_noti(void *data, struct tizen_screenshooter *tz_screenshooter, uint32_t noti)
 480 {
 481    _eflutil.wl.shot.noti = noti;
 482 }
 483
 484 static const struct tizen_screenshooter_listener tz_screenshooter_listener =
 485 {
 486     _cb_tz_screenshot_format,
 487     _cb_tz_screenshot_noti
 488 };
 489
 490 static void
 491 _cb_seat_capabilities(void *data, struct wl_seat *seat, enum wl_seat_capability caps)
 492 {
 493 }
 494
 495 static void
 496 _cb_seat_name(void *data, struct wl_seat *seat EINA_UNUSED, const char *name)
 497 {
 498 }
 499
 500 static const struct wl_seat_listener _seat_listener =
 501 {
 502    _cb_seat_capabilities,
 503    _cb_seat_name,
 504 };
 505
 506 static void
 507 _cb_wl_reg_global(void *data,
 508                   struct wl_registry *reg,
 509                   unsigned int id,
 510                   const char *interface,
 511                   unsigned int version)
 512 {
 513    if (!strcmp(interface, "tizen_policy"))
 514      {
 515         struct tizen_policy *proto;
 516         proto = wl_registry_bind(reg,
 517                                   id,
 518                                   &tizen_policy_interface,
 519                                   7);
 520         if (!proto) return;
 521
 522         tizen_policy_add_listener(proto,
 523                                   &_wl_tz_policy_listener,
 524                                   NULL);
 525
 526         _eflutil.wl.policy.hash_noti_lv = eina_hash_pointer_new(free);
 527         _eflutil.wl.policy.hash_scr_mode = eina_hash_pointer_new(free);
 528         _eflutil.wl.policy.proto = proto;
 529         _eflutil.wl.policy.id = id;
 530      }
 531    else if (strcmp(interface, "wl_output") == 0)
 532      {
 533         Efl_Util_Wl_Output_Info *output = calloc(1, sizeof(Efl_Util_Wl_Output_Info));
 534         EINA_SAFETY_ON_NULL_RETURN(output);
 535
 536         _eflutil.wl.shot.output_list = eina_list_append(_eflutil.wl.shot.output_list, output);
 537
 538         output->output = wl_registry_bind(reg, id, &wl_output_interface, version);
 539         wl_output_add_listener(output->output, &output_listener, output);
 540      }
 541    else if(strcmp(interface, "wl_seat") == 0)
 542      {
 543         _eflutil.wl.seat = wl_registry_bind(reg, id, &wl_seat_interface, version);
 544         wl_seat_add_listener(_eflutil.wl.seat, &_seat_listener, NULL);
 545      }
 546    else if (strcmp(interface, "tizen_input_device_manager") == 0)
 547      {
 548         _eflutil.wl.devmgr.devicemgr = wl_registry_bind(reg, id, &tizen_input_device_manager_interface, version);
 549         tizen_input_device_manager_add_listener(_eflutil.wl.devmgr.devicemgr, &_wl_tz_devmgr_listener, NULL);
 550      }
 551    else if (!strcmp(interface, "tizen_display_policy"))
 552      {
 553         _eflutil.wl.display_policy.proto = wl_registry_bind(reg, id, &tizen_display_policy_interface, version);
 554         if (!_eflutil.wl.display_policy.proto) return;
 555
 556         tizen_display_policy_add_listener(_eflutil.wl.display_policy.proto,
 557                                           &_wl_tz_display_policy_listener,
 558                                           NULL);
 559
 560         _eflutil.wl.display_policy.hash_brightness = eina_hash_pointer_new(free);
 561         _eflutil.wl.display_policy.id = id;
 562      }
 563 }
 564 /* LCOV_EXCL_START */
 565 static void
 566 _cb_wl_reg_global_remove(void *data,
 567                          struct wl_registry *reg,
 568                          unsigned int id)
 569 {
 570    /* unset each global id number to 0 since global id is started
 571     * from number 1 on server side display structure
 572     */
 573    if (id == _eflutil.wl.policy.id)
 574      {
 575         _eflutil.wl.policy.id = 0;
 576         _eflutil.wl.policy.proto = NULL;
 577         eina_hash_free(_eflutil.wl.policy.hash_noti_lv);
 578         eina_hash_free(_eflutil.wl.policy.hash_scr_mode);
 579      }
 580    else if (id == _eflutil.wl.display_policy.id)
 581      {
 582         _eflutil.wl.display_policy.id = 0;
 583         _eflutil.wl.display_policy.proto = NULL;
 584         eina_hash_free(_eflutil.wl.display_policy.hash_brightness);
 585      }
 586 }
 587 /* LCOV_EXCL_STOP */
 588
 589 static void
 590 _cb_wl_default_queue_reg_global(void *data,
 591                                 struct wl_registry *reg,
 592                                 unsigned int id,
 593                                 const char *interface,
 594                                 unsigned int version)
 595 {
 596    if (strcmp(interface, "tizen_gesture") == 0)
 597      {
 598         _eflutil_defaultqueue.wl.gesture.id = id;
 599         _eflutil_defaultqueue.wl.gesture.proto = wl_registry_bind(reg, id, &tizen_gesture_interface, version);
 600         tizen_gesture_add_listener(_eflutil_defaultqueue.wl.gesture.proto, &_wl_tz_gesture_listener, NULL);
 601      }
 602 }
 603 /* LCOV_EXCL_START */
 604 static void
 605 _cb_wl_default_queue_reg_global_remove(void *data,
 606                                        struct wl_registry *reg,
 607                                        unsigned int id)
 608 {
 609    if (id == _eflutil_defaultqueue.wl.gesture.id)
 610      {
 611         _eflutil_defaultqueue.wl.gesture.id = 0;
 612         _eflutil_defaultqueue.wl.gesture.proto = NULL;
 613      }
 614 }
 615 /* LCOV_EXCL_STOP */
 616
 617
 618 static void
 619 _cb_wl_reg_screenshooter_global(void *data,
 620                   struct wl_registry *reg,
 621                   unsigned int name,
 622                   const char *interface,
 623                   unsigned int version)
 624 {
 625    if (strcmp(interface, "screenshooter") == 0)
 626      {
 627         _eflutil.wl.shot.screenshooter = wl_registry_bind(reg, name, &screenshooter_interface, version);
 628         screenshooter_add_listener(_eflutil.wl.shot.screenshooter, &screenshooter_listener, NULL);
 629      }
 630    else if (strcmp(interface, "tizen_screenshooter") == 0)
 631      {
 632         _eflutil.wl.shot.tz_screenshooter = wl_registry_bind(reg, name, &tizen_screenshooter_interface, version);
 633         tizen_screenshooter_add_listener(_eflutil.wl.shot.tz_screenshooter, &tz_screenshooter_listener, NULL);
 634
 635         wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
 636      }
 637 }
 638
 639 /* LCOV_EXCL_START */
 640 static void
 641 _cb_wl_reg_screenshooter_global_remove(void *data,
 642                          struct wl_registry *reg,
 643                          unsigned int name)
 644 {
 645 }
 646
 647 static void
 648 _cb_wl_tz_policy_conformant(void *data, struct tizen_policy *tizen_policy,
 649                             struct wl_surface *surface, uint32_t is_conformant)
 650 {
 651 }
 652
 653 static void
 654 _cb_wl_tz_policy_conformant_area(void *data, struct tizen_policy *tizen_policy,
 655                                  struct wl_surface *surface, uint32_t conformant_part,
 656                                  uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h)
 657 {
 658 }
 659 /* LCOV_EXCL_STOP */
 660
 661 static void
 662 _cb_wl_tz_policy_notification_done(void *data,
 663                                    struct tizen_policy *tizen_policy,
 664                                    struct wl_surface *surface,
 665                                    int32_t level,
 666                                    uint32_t state)
 667 {
 668    Efl_Util_Wl_Surface_Lv_Info *lv_info;
 669
 670    lv_info = eina_hash_find(_eflutil.wl.policy.hash_noti_lv, &surface);
 671    if (lv_info)
 672      {
 673         lv_info->level = level;
 674         lv_info->wait_for_done = EINA_FALSE;
 675         lv_info->state = state;
 676      }
 677 }
 678
 679 /* LCOV_EXCL_START */
 680 static void
 681 _cb_wl_tz_policy_transient_for_done(void *data, struct tizen_policy *tizen_policy, uint32_t child_id)
 682 {
 683 }
 684 /* LCOV_EXCL_STOP */
 685
 686 static void
 687 _cb_wl_tz_policy_scr_mode_done(void *data,
 688                                struct tizen_policy *tizen_policy,
 689                                struct wl_surface *surface,
 690                                uint32_t mode,
 691                                uint32_t state)
 692 {
 693    Efl_Util_Wl_Surface_Scr_Mode_Info *scr_mode_info;
 694
 695    scr_mode_info = eina_hash_find(_eflutil.wl.policy.hash_scr_mode, &surface);
 696    if (scr_mode_info)
 697      {
 698         scr_mode_info->mode = mode;
 699         scr_mode_info->wait_for_done = EINA_FALSE;
 700         scr_mode_info->state = state;
 701      }
 702 }
 703
 704 /* LCOV_EXCL_START */
 705 static void                    _cb_wl_tz_policy_iconify_state_changed(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, uint32_t iconified, uint32_t force)
 706 {
 707 }
 708
 709 static void                    _cb_wl_tz_policy_supported_aux_hints(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, struct wl_array *hints, uint32_t num_hints)
 710 {
 711 }
 712
 713 static void                    _cb_wl_tz_policy_allowed_aux_hint(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, int id)
 714 {
 715 }
 716
 717 static void                    _cb_wl_tz_policy_aux_message(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, const char *key, const char *val, struct wl_array *options)
 718 {
 719 }
 720 static void                    _cb_wl_conformant_region(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface, uint32_t conformant_part, uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h, uint32_t serial)
 721 {
 722 }
 723 /* LCOV_EXCL_STOP */
 724
 725 static void
 726 _cb_wl_tz_display_policy_brightness_done(void *data,
 727                                  struct tizen_display_policy *tizen_display_policy,
 728                                  struct wl_surface *surface,
 729                                  int32_t brightness,
 730                                  uint32_t state)
 731 {
 732    Efl_Util_Wl_Surface_Brightness_Info *brightness_info;
 733
 734    brightness_info = eina_hash_find(_eflutil.wl.display_policy.hash_brightness, &surface);
 735    if (brightness_info)
 736      {
 737         brightness_info->brightness = brightness;
 738         brightness_info->wait_for_done = EINA_FALSE;
 739         brightness_info->state = state;
 740      }
 741 }
 742
 743 static void
 744 _cb_window_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
 745 {
 746    Efl_Util_Wl_Surface_Lv_Info *lv_info;
 747
 748    lv_info = data;
 749    if (EINA_UNLIKELY(!lv_info))
 750      return;
 751
 752    eina_hash_del(_eflutil.wl.policy.hash_noti_lv, &lv_info->surface, lv_info);
 753 }
 754
 755 API int
 756 efl_util_set_notification_window_level(Evas_Object *window,
 757                                        efl_util_notification_level_e level)
 758 {
 759    Eina_Bool res;
 760
 761    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
 762    EINA_SAFETY_ON_FALSE_RETURN_VAL((level >= EFL_UTIL_NOTIFICATION_LEVEL_NONE) &&
 763                                    (level <= EFL_UTIL_NOTIFICATION_LEVEL_TOP),
 764                                    EFL_UTIL_ERROR_INVALID_PARAMETER);
 765
 766    Elm_Win_Type type;
 767    Ecore_Wl2_Window *wlwin;
 768    struct wl_surface *surface;
 769    Efl_Util_Wl_Surface_Lv_Info *lv_info;
 770    Ecore_Wl2_Window_Type wl_type;
 771
 772    res = _wl_init();
 773    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER);
 774
 775    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
 776    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
 777
 778    type = elm_win_type_get(window);
 779    if (type != ELM_WIN_NOTIFICATION)
 780      {
 781         wl_type = ecore_wl2_window_type_get(wlwin);
 782         EINA_SAFETY_ON_FALSE_RETURN_VAL((wl_type == ECORE_WL2_WINDOW_TYPE_NOTIFICATION),
 783                                         EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
 784      }
 785
 786    while (!_eflutil.wl.policy.proto)
 787      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
 788
 789    surface = ecore_wl2_window_surface_get(wlwin);
 790    EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
 791                                   EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
 792
 793    lv_info = eina_hash_find(_eflutil.wl.policy.hash_noti_lv, &surface);
 794    if (!lv_info)
 795      {
 796         lv_info = calloc(1, sizeof(Efl_Util_Wl_Surface_Lv_Info));
 797         EINA_SAFETY_ON_NULL_RETURN_VAL(lv_info, EFL_UTIL_ERROR_OUT_OF_MEMORY);
 798
 799         lv_info->surface = surface;
 800         lv_info->level = (int)level;
 801         lv_info->wait_for_done = EINA_TRUE;
 802         lv_info->state = TIZEN_POLICY_ERROR_STATE_NONE;
 803         eina_hash_add(_eflutil.wl.policy.hash_noti_lv,
 804                       &surface,
 805                       lv_info);
 806
 807         evas_object_event_callback_add(window, EVAS_CALLBACK_DEL,
 808                                        _cb_window_del, lv_info);
 809      }
 810    else
 811      {
 812         lv_info->level = (int)level;
 813         lv_info->wait_for_done = EINA_TRUE;
 814         lv_info->state = TIZEN_POLICY_ERROR_STATE_NONE;
 815      }
 816
 817
 818    tizen_policy_set_notification_level(_eflutil.wl.policy.proto,
 819                                        surface, (int)level);
 820
 821    if (lv_info->wait_for_done)
 822      {
 823         int count = 0;
 824         while (lv_info->wait_for_done && (count < 3))
 825           {
 826              ecore_wl2_display_flush(_eflutil.wl.wl2_display);
 827              wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
 828              count++;
 829           }
 830
 831         if (lv_info->wait_for_done)
 832           {
 833              return EFL_UTIL_ERROR_INVALID_PARAMETER;
 834           }
 835         else
 836           {
 837              if (lv_info->state == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
 838                {
 839                   return EFL_UTIL_ERROR_PERMISSION_DENIED;
 840                }
 841           }
 842      }
 843
 844    return EFL_UTIL_ERROR_NONE;
 845 }
 846
 847 API int
 848 efl_util_get_notification_window_level(Evas_Object *window,
 849                                        efl_util_notification_level_e *level)
 850 {
 851    Eina_Bool res;
 852
 853    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
 854    EINA_SAFETY_ON_NULL_RETURN_VAL(level, EFL_UTIL_ERROR_INVALID_PARAMETER);
 855
 856    Elm_Win_Type type;
 857    Ecore_Wl2_Window *wlwin;
 858    struct wl_surface *surface;
 859    Efl_Util_Wl_Surface_Lv_Info *lv_info;
 860    Ecore_Wl2_Window_Type wl_type;
 861
 862    res = _wl_init();
 863    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER);
 864
 865    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
 866    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
 867
 868    type = elm_win_type_get(window);
 869    if (type != ELM_WIN_NOTIFICATION)
 870      {
 871         wl_type = ecore_wl2_window_type_get(wlwin);
 872         EINA_SAFETY_ON_FALSE_RETURN_VAL((wl_type == ECORE_WL2_WINDOW_TYPE_NOTIFICATION),
 873                                         EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
 874      }
 875
 876    while (!_eflutil.wl.policy.proto)
 877      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
 878
 879    surface = ecore_wl2_window_surface_get(wlwin);
 880    EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
 881                                   EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
 882
 883    lv_info = eina_hash_find(_eflutil.wl.policy.hash_noti_lv, &surface);
 884    if (lv_info)
 885      {
 886         if (lv_info->wait_for_done)
 887           {
 888              int count = 0;
 889              while ((lv_info->wait_for_done) && (count < 3))
 890                {
 891                   ecore_wl2_display_flush(_eflutil.wl.wl2_display);
 892                   wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
 893                   count++;
 894                }
 895
 896              if (lv_info->wait_for_done)
 897                {
 898                   *level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT;
 899                   return EFL_UTIL_ERROR_INVALID_PARAMETER;
 900                }
 901           }
 902
 903         switch (lv_info->level)
 904           {
 905            case TIZEN_POLICY_LEVEL_NONE:    *level = EFL_UTIL_NOTIFICATION_LEVEL_NONE;    break;
 906            case TIZEN_POLICY_LEVEL_DEFAULT: *level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT; break;
 907            case TIZEN_POLICY_LEVEL_MEDIUM:  *level = EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM;  break;
 908            case TIZEN_POLICY_LEVEL_HIGH:    *level = EFL_UTIL_NOTIFICATION_LEVEL_HIGH;    break;
 909            case TIZEN_POLICY_LEVEL_TOP:     *level = EFL_UTIL_NOTIFICATION_LEVEL_TOP;     break;
 910            default:                         *level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT;
 911             return EFL_UTIL_ERROR_INVALID_PARAMETER;
 912           }
 913         return EFL_UTIL_ERROR_NONE;
 914      }
 915    else
 916      *level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT;
 917
 918    return EFL_UTIL_ERROR_NONE;
 919 }
 920
 921 API int
 922 efl_util_set_window_opaque_state(Evas_Object *window,
 923                                  int opaque)
 924 {
 925    Eina_Bool res;
 926
 927    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
 928    EINA_SAFETY_ON_FALSE_RETURN_VAL(((opaque >= 0) && (opaque <= 1)),
 929                                    EFL_UTIL_ERROR_INVALID_PARAMETER);
 930
 931    Ecore_Wl2_Window *wlwin;
 932    struct wl_surface *surface;
 933
 934    if (!_eflutil.wl.policy.proto)
 935      {
 936         int ret = 0;
 937
 938         res = _wl_init();
 939         EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER);
 940
 941         while (!_eflutil.wl.policy.proto && ret != -1)
 942           ret = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
 943
 944         EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.policy.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
 945      }
 946
 947    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
 948    if (!wlwin)
 949       return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE;
 950
 951    surface  = ecore_wl2_window_surface_get(wlwin);
 952    if (!surface)
 953       return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE;
 954
 955    tizen_policy_set_opaque_state(_eflutil.wl.policy.proto, surface, opaque);
 956
 957    return EFL_UTIL_ERROR_NONE;
 958 }
 959
 960 API int
 961 efl_util_set_window_screen_mode(Evas_Object *window,
 962                                 efl_util_screen_mode_e mode)
 963 {
 964    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
 965    EINA_SAFETY_ON_FALSE_RETURN_VAL(((mode >= EFL_UTIL_SCREEN_MODE_DEFAULT) &&
 966                                     (mode <= EFL_UTIL_SCREEN_MODE_ALWAYS_ON)),
 967                                    EFL_UTIL_ERROR_INVALID_PARAMETER);
 968
 969    Ecore_Wl2_Window *wlwin;
 970    struct wl_surface *surface;
 971    Efl_Util_Wl_Surface_Scr_Mode_Info *scr_mode_info;
 972    Eina_Bool res;
 973
 974    res = _wl_init();
 975    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER);
 976
 977    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
 978    if (wlwin)
 979      {
 980         while (!_eflutil.wl.policy.proto)
 981           wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
 982
 983         surface = ecore_wl2_window_surface_get(wlwin);
 984         EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
 985                                        EFL_UTIL_ERROR_INVALID_PARAMETER);
 986
 987         scr_mode_info = eina_hash_find(_eflutil.wl.policy.hash_scr_mode, &surface);
 988         if (!scr_mode_info)
 989           {
 990              scr_mode_info = calloc(1, sizeof(Efl_Util_Wl_Surface_Scr_Mode_Info));
 991              EINA_SAFETY_ON_NULL_RETURN_VAL(scr_mode_info, EFL_UTIL_ERROR_OUT_OF_MEMORY);
 992
 993              scr_mode_info->surface = surface;
 994              scr_mode_info->mode = (unsigned int)mode;
 995              scr_mode_info->wait_for_done = EINA_TRUE;
 996              scr_mode_info->state = TIZEN_POLICY_ERROR_STATE_NONE;
 997
 998              eina_hash_add(_eflutil.wl.policy.hash_scr_mode,
 999                            &surface,
1000                            scr_mode_info);
1001           }
1002         else
1003           {
1004              scr_mode_info->mode = (unsigned int)mode;
1005              scr_mode_info->wait_for_done = EINA_TRUE;
1006              scr_mode_info->state = TIZEN_POLICY_ERROR_STATE_NONE;
1007           }
1008
1009         tizen_policy_set_window_screen_mode(_eflutil.wl.policy.proto,
1010                                             surface, (unsigned int)mode);
1011         if (scr_mode_info->wait_for_done)
1012           {
1013              int count = 0;
1014              while (scr_mode_info->wait_for_done && (count < 3))
1015                {
1016                   ecore_wl2_display_flush(_eflutil.wl.wl2_display);
1017                   wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1018                   count++;
1019                }
1020
1021              if (scr_mode_info->wait_for_done)
1022                {
1023                   return EFL_UTIL_ERROR_INVALID_PARAMETER;
1024                }
1025              else
1026                {
1027                   if (scr_mode_info->state == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
1028                     {
1029                        return EFL_UTIL_ERROR_PERMISSION_DENIED;
1030                     }
1031                }
1032           }
1033
1034         return EFL_UTIL_ERROR_NONE;
1035      }
1036    else
1037      return EFL_UTIL_ERROR_INVALID_PARAMETER;
1038 }
1039
1040 API int
1041 efl_util_get_window_screen_mode(Evas_Object *window,
1042                                 efl_util_screen_mode_e *mode)
1043 {
1044    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
1045    EINA_SAFETY_ON_NULL_RETURN_VAL(mode, EFL_UTIL_ERROR_INVALID_PARAMETER);
1046
1047    Ecore_Wl2_Window *wlwin;
1048    struct wl_surface *surface;
1049    Efl_Util_Wl_Surface_Scr_Mode_Info *scr_mode_info;
1050    Eina_Bool res;
1051
1052    res = _wl_init();
1053    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER);
1054
1055    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
1056    if (wlwin)
1057      {
1058         while (!_eflutil.wl.policy.proto)
1059           wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1060
1061         surface = ecore_wl2_window_surface_get(wlwin);
1062         EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
1063                                        EFL_UTIL_ERROR_INVALID_PARAMETER);
1064
1065         scr_mode_info = eina_hash_find(_eflutil.wl.policy.hash_scr_mode, &surface);
1066         if (scr_mode_info)
1067           {
1068              if (scr_mode_info->wait_for_done)
1069                {
1070                   while (scr_mode_info->wait_for_done)
1071                     {
1072                        ecore_wl2_display_flush(_eflutil.wl.wl2_display);
1073                        wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1074                     }
1075                }
1076
1077              switch (scr_mode_info->mode)
1078                {
1079                 case TIZEN_POLICY_MODE_DEFAULT:   *mode = EFL_UTIL_SCREEN_MODE_DEFAULT;   break;
1080                 case TIZEN_POLICY_MODE_ALWAYS_ON: *mode = EFL_UTIL_SCREEN_MODE_ALWAYS_ON; break;
1081                 default:                          *mode = EFL_UTIL_SCREEN_MODE_DEFAULT;
1082                   return EFL_UTIL_ERROR_INVALID_PARAMETER;
1083                }
1084              return EFL_UTIL_ERROR_NONE;
1085           }
1086         else
1087           {
1088              *mode = EFL_UTIL_SCREEN_MODE_DEFAULT;
1089              return EFL_UTIL_ERROR_INVALID_PARAMETER;
1090           }
1091      }
1092    else
1093      return EFL_UTIL_ERROR_INVALID_PARAMETER;
1094 }
1095
1096 API int
1097 efl_util_set_window_brightness(Evas_Object *window, int brightness)
1098 {
1099    Ecore_Wl2_Window *wlwin;
1100    struct wl_surface *surface;
1101    Efl_Util_Wl_Surface_Brightness_Info *brightness_info;
1102    Eina_Bool res;
1103
1104    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
1105    EINA_SAFETY_ON_FALSE_RETURN_VAL(brightness <= 100, EFL_UTIL_ERROR_INVALID_PARAMETER);
1106
1107    res = _wl_init();
1108    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER);
1109
1110    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
1111    if (wlwin)
1112      {
1113         while (!_eflutil.wl.display_policy.proto)
1114           wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1115
1116         surface = ecore_wl2_window_surface_get(wlwin);
1117         EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
1118                                        EFL_UTIL_ERROR_INVALID_PARAMETER);
1119
1120         brightness_info = eina_hash_find(_eflutil.wl.display_policy.hash_brightness, &surface);
1121         if (!brightness_info)
1122           {
1123              brightness_info = calloc(1, sizeof(Efl_Util_Wl_Surface_Brightness_Info));
1124              EINA_SAFETY_ON_NULL_RETURN_VAL(brightness_info, EFL_UTIL_ERROR_OUT_OF_MEMORY);
1125
1126              brightness_info->surface = surface;
1127              brightness_info->brightness = brightness;
1128              brightness_info->wait_for_done = EINA_TRUE;
1129              brightness_info->state = TIZEN_DISPLAY_POLICY_ERROR_STATE_NONE;
1130
1131              eina_hash_add(_eflutil.wl.display_policy.hash_brightness,
1132                            &surface,
1133                            brightness_info);
1134            }
1135          else
1136            {
1137               brightness_info->brightness = brightness;
1138               brightness_info->wait_for_done = EINA_TRUE;
1139               brightness_info->state = TIZEN_DISPLAY_POLICY_ERROR_STATE_NONE;
1140            }
1141
1142          tizen_display_policy_set_window_brightness(_eflutil.wl.display_policy.proto,
1143                                                     surface, brightness);
1144          if (brightness_info->wait_for_done)
1145            {
1146               int count = 0;
1147               while (brightness_info->wait_for_done && (count < 3))
1148                 {
1149                    ecore_wl2_display_flush(_eflutil.wl.wl2_display);
1150                    wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1151                    count++;
1152                 }
1153
1154               if (brightness_info->wait_for_done)
1155                 {
1156                    return EFL_UTIL_ERROR_INVALID_PARAMETER;
1157                 }
1158               else
1159                 {
1160                    if (brightness_info->state == TIZEN_DISPLAY_POLICY_ERROR_STATE_PERMISSION_DENIED)
1161                      {
1162                         return EFL_UTIL_ERROR_PERMISSION_DENIED;
1163                      }
1164                 }
1165            }
1166         return EFL_UTIL_ERROR_NONE;
1167      }
1168    else
1169      return EFL_UTIL_ERROR_INVALID_PARAMETER;
1170 }
1171
1172 API int
1173 efl_util_get_window_brightness(Evas_Object *window, int *brightness)
1174 {
1175    Ecore_Wl2_Window *wlwin;
1176    struct wl_surface *surface;
1177    Efl_Util_Wl_Surface_Brightness_Info *brightness_info;
1178    Eina_Bool res;
1179
1180    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
1181    EINA_SAFETY_ON_NULL_RETURN_VAL(brightness, EFL_UTIL_ERROR_INVALID_PARAMETER);
1182
1183    res = _wl_init();
1184    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER);
1185
1186    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
1187    if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
1188
1189    while (!_eflutil.wl.display_policy.proto)
1190      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1191
1192    surface = ecore_wl2_window_surface_get(wlwin);
1193    EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
1194                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
1195
1196    brightness_info = eina_hash_find(_eflutil.wl.display_policy.hash_brightness, &surface);
1197    if (brightness_info)
1198      {
1199         if (brightness_info->wait_for_done)
1200           {
1201              while (brightness_info->wait_for_done)
1202                {
1203                   ecore_wl2_display_flush(_eflutil.wl.wl2_display);
1204                   wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1205                }
1206           }
1207          *brightness = brightness_info->brightness;
1208      }
1209    else
1210      *brightness = -1;
1211
1212    return EFL_UTIL_ERROR_NONE;
1213 }
1214
1215
1216 struct _efl_util_inputgen_h
1217 {
1218    unsigned int init_type;
1219    char name[32];
1220    E_Devicemgr_Inputgen_Touch_Axis *axis_info;
1221 };
1222
1223 static Eina_Bool
1224 _efl_util_input_check_wait_device_full(void)
1225 {
1226    Eina_List *l, *ll, *l_next;
1227    Efl_Util_Device_Info *dev, *wait_dev;
1228    int wait_cnt = 0;
1229
1230    wait_cnt = eina_list_count(_eflutil.wl.devmgr.wait_devices);
1231    if (wait_cnt <= 0) return EINA_TRUE;
1232
1233    EINA_LIST_FOREACH(_eflutil.wl.devmgr.devices, l, dev)
1234      {
1235         EINA_LIST_FOREACH_SAFE(_eflutil.wl.devmgr.wait_devices, ll, l_next, wait_dev)
1236           {
1237              if ((dev->clas == wait_dev->clas) &&
1238                  (!strncmp(dev->name, wait_dev->name, eina_stringshare_strlen(wait_dev->name))))
1239                {
1240                   eina_stringshare_del(wait_dev->name);
1241                   _eflutil.wl.devmgr.wait_devices = eina_list_remove_list(_eflutil.wl.devmgr.wait_devices, ll);
1242                   free(wait_dev);
1243
1244                   wait_cnt--;
1245                   if (wait_cnt <= 0) return EINA_TRUE;
1246
1247                   break;
1248                }
1249           }
1250      }
1251
1252    return EINA_FALSE;
1253 }
1254
1255 static Eina_Bool
1256 _efl_util_input_check_wait_device(const char *name, unsigned int type)
1257 {
1258    Eina_List *l, *l_next;
1259    Efl_Util_Device_Info *wait_dev;
1260    int wait_cnt = 0;
1261
1262    wait_cnt = eina_list_count(_eflutil.wl.devmgr.wait_devices);
1263    if (wait_cnt <= 0) return EINA_TRUE;
1264
1265    EINA_LIST_FOREACH_SAFE(_eflutil.wl.devmgr.wait_devices, l, l_next, wait_dev)
1266      {
1267         if ((type == wait_dev->clas) &&
1268             (!strncmp(name, wait_dev->name, eina_stringshare_strlen(wait_dev->name))))
1269           {
1270              eina_stringshare_del(wait_dev->name);
1271              _eflutil.wl.devmgr.wait_devices = eina_list_remove_list(_eflutil.wl.devmgr.wait_devices, l);
1272              free(wait_dev);
1273
1274              wait_cnt--;
1275              if (wait_cnt <= 0) return EINA_TRUE;
1276
1277              break;
1278           }
1279      }
1280
1281    return EINA_FALSE;
1282 }
1283
1284 static void
1285 _cb_device_info(void *data, struct tizen_input_device *tizen_input_device EINA_UNUSED, const char *name, uint32_t clas, uint32_t subclas EINA_UNUSED, struct wl_array *axes EINA_UNUSED)
1286 {
1287    Efl_Util_Device_Info *dev;
1288
1289    if (!(dev = data)) return;
1290    dev->clas = (Ecore_Device_Class)clas;
1291    dev->name = eina_stringshare_add(name);
1292
1293    if (_eflutil.wl.devmgr.wait_timer &&
1294        _efl_util_input_check_wait_device(name, clas))
1295      {
1296         wl_event_source_remove(_eflutil.wl.devmgr.wait_timer);
1297         _eflutil.wl.devmgr.wait_timer = NULL;
1298      }
1299 }
1300
1301 /* LCOV_EXCL_START */
1302 static void
1303 _cb_event_device(void *data EINA_UNUSED, struct tizen_input_device *tizen_input_device EINA_UNUSED, unsigned int serial EINA_UNUSED, const char *name EINA_UNUSED, uint32_t time EINA_UNUSED)
1304 {
1305    ;
1306 }
1307
1308 static void
1309 _cb_axis(void *data EINA_UNUSED, struct tizen_input_device *tizen_input_device EINA_UNUSED, uint32_t axis_type EINA_UNUSED, wl_fixed_t value EINA_UNUSED)
1310 {
1311    ;
1312 }
1313 /* LCOV_EXCL_STOP */
1314
1315 static void
1316 _cb_device_add(void *data EINA_UNUSED,
1317                struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED,
1318                uint32_t serial EINA_UNUSED,
1319                const char *identifier EINA_UNUSED,
1320                struct tizen_input_device *device,
1321                struct wl_seat *seat EINA_UNUSED)
1322 {
1323    Efl_Util_Device_Info *dev;
1324
1325    EINA_SAFETY_ON_NULL_RETURN(device);
1326
1327    dev = (Efl_Util_Device_Info *)calloc(1, sizeof(Efl_Util_Device_Info));
1328    EINA_SAFETY_ON_NULL_RETURN(dev);
1329
1330    dev->device = device;
1331    tizen_input_device_add_listener(device, &_wl_tz_input_device_listener, dev);
1332
1333    _eflutil.wl.devmgr.devices = eina_list_append(_eflutil.wl.devmgr.devices, dev);
1334 }
1335
1336 static void
1337 _cb_device_remove(void *data EINA_UNUSED,
1338                struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED,
1339                uint32_t serial  EINA_UNUSED,
1340                const char *identifier  EINA_UNUSED,
1341                struct tizen_input_device *device,
1342                struct wl_seat *seat  EINA_UNUSED)
1343 {
1344    Eina_List *l, *l_next;
1345    Efl_Util_Device_Info *dev;
1346
1347    EINA_LIST_FOREACH_SAFE(_eflutil.wl.devmgr.devices, l, l_next, dev)
1348      {
1349         if (dev->device == device)
1350           {
1351              if (dev->name) eina_stringshare_del(dev->name);
1352              tizen_input_device_release(dev->device);
1353
1354              _eflutil.wl.devmgr.devices = eina_list_remove_list(_eflutil.wl.devmgr.devices, l);
1355              free(dev);
1356
1357              break;
1358           }
1359      }
1360 }
1361
1362 static void
1363 _cb_error(void *data EINA_UNUSED,
1364           struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED,
1365           uint32_t errorcode)
1366 {
1367    _eflutil.wl.devmgr.request_notified = errorcode;
1368 }
1369
1370 /* LCOV_EXCL_START */
1371 static void
1372 _cb_block_expired(void *data EINA_UNUSED,
1373                   struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED)
1374 {
1375    ;
1376 }
1377 /* LCOV_EXCL_STOP */
1378
1379 static void
1380 _cb_max_touch_count(void *data EINA_UNUSED,
1381                     struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED,
1382                     uint32_t serial EINA_UNUSED,
1383                     int32_t max_count,
1384                     struct wl_seat *seat EINA_UNUSED)
1385 {
1386    _eflutil.wl.devmgr.max_touch_count = max_count;
1387 }
1388
1389 static efl_util_error_e
1390 _efl_util_input_convert_input_generator_error(int ret)
1391 {
1392    switch (ret)
1393      {
1394         case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE:
1395            return EFL_UTIL_ERROR_NONE;
1396         case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_PERMISSION:
1397            return EFL_UTIL_ERROR_PERMISSION_DENIED;
1398         case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_SYSTEM_RESOURCES:
1399            return EFL_UTIL_ERROR_OUT_OF_MEMORY;
1400         case TIZEN_INPUT_DEVICE_MANAGER_ERROR_INVALID_PARAMETER:
1401            return EFL_UTIL_ERROR_INVALID_PARAMETER;
1402         case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NOT_ALLOWED:
1403            return EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE;
1404         default :
1405            return EFL_UTIL_ERROR_NONE;
1406      }
1407 }
1408
1409 /* LCOV_EXCL_START */
1410 static int
1411 _timer_wait(void *data)
1412 {
1413    Efl_Util_Device_Info *dev;
1414
1415    _eflutil.wl.devmgr.request_notified = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_SYSTEM_RESOURCES;
1416
1417    if (eina_list_count(_eflutil.wl.devmgr.wait_devices) > 0)
1418      {
1419         EINA_LIST_FREE(_eflutil.wl.devmgr.wait_devices, dev)
1420           {
1421              eina_stringshare_del(dev->name);
1422              dev->name = NULL;
1423           }
1424      }
1425
1426    wl_event_source_remove(_eflutil.wl.devmgr.wait_timer);
1427    _eflutil.wl.devmgr.wait_timer = NULL;
1428
1429    return 1;
1430 }
1431 /* LCOV_EXCL_STOP */
1432
1433 static void
1434 _efl_util_input_initialize_wait_device(void)
1435 {
1436    struct wl_event_loop *loop;
1437    int ret = -1;
1438
1439    if (_efl_util_input_check_wait_device_full()) return;
1440
1441    loop = wl_event_loop_create();
1442    _eflutil.wl.devmgr.wait_timer = wl_event_loop_add_timer(loop, _timer_wait, NULL);
1443    if (_eflutil.wl.devmgr.wait_timer)
1444      {
1445         ret = wl_event_source_timer_update(_eflutil.wl.devmgr.wait_timer,
1446                                            EFL_UTIL_INPUT_GENERATOR_DEFAULT_TIME_OUT);
1447         if (ret != 0)
1448           {
1449              _timer_wait(NULL);
1450              return;
1451           }
1452      }
1453
1454    while (_eflutil.wl.devmgr.wait_timer)
1455      {
1456         wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1457         ret = wl_event_loop_dispatch(loop, EFL_UTIL_INPUT_GENERATOR_DEFAULT_DISPATCH_TIME_OUT);
1458         if (ret != 0) _timer_wait(NULL);
1459      }
1460 }
1461
1462 static void
1463 _efl_util_input_initialize_append_device(const char *name, Ecore_Device_Class clas)
1464 {
1465    Efl_Util_Device_Info *dev;
1466
1467    dev = (Efl_Util_Device_Info *)calloc(1, sizeof(Efl_Util_Device_Info));
1468    EINA_SAFETY_ON_NULL_RETURN(dev);
1469
1470    dev->name = eina_stringshare_add(name);
1471    dev->clas = clas;
1472
1473    _eflutil.wl.devmgr.wait_devices = eina_list_append(_eflutil.wl.devmgr.wait_devices, dev);
1474 }
1475
1476 static void
1477 _efl_util_input_initialize_add_wait_device(const char *name, unsigned int dev_type)
1478 {
1479    EINA_SAFETY_ON_NULL_RETURN(name);
1480
1481    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
1482      _efl_util_input_initialize_append_device(name, ECORE_DEVICE_CLASS_TOUCH);
1483
1484    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
1485      _efl_util_input_initialize_append_device(name, ECORE_DEVICE_CLASS_KEYBOARD);
1486
1487    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
1488      _efl_util_input_initialize_append_device(name, ECORE_DEVICE_CLASS_MOUSE);
1489 }
1490
1491 API efl_util_inputgen_h
1492 efl_util_input_initialize_generator(unsigned int dev_type)
1493 {
1494    int ret = EFL_UTIL_ERROR_NONE;
1495    efl_util_inputgen_h inputgen_h = NULL;
1496    unsigned int clas = 0x0;
1497
1498    if (!dev_type ||
1499         dev_type & ~(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN
1500                     | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD
1501                     | EFL_UTIL_INPUT_DEVTYPE_POINTER))
1502      {
1503         set_last_result(EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1504         goto out;
1505      }
1506
1507    inputgen_h = (efl_util_inputgen_h)calloc(1, sizeof(struct _efl_util_inputgen_h));
1508    if (!inputgen_h)
1509      {
1510         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
1511         goto out;
1512      }
1513
1514    inputgen_h->init_type |= dev_type;
1515
1516    ret = _wl_init();
1517    if (ret == (int)EINA_FALSE)
1518      {
1519         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
1520         goto out;
1521      }
1522
1523    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
1524      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN;
1525    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
1526      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD;
1527    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
1528      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE;
1529
1530    while (!_eflutil.wl.devmgr.devicemgr)
1531      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1532
1533    tizen_input_device_manager_init_generator(_eflutil.wl.devmgr.devicemgr, clas);
1534
1535    while (_eflutil.wl.devmgr.request_notified == -1)
1536      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1537
1538    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1539    _eflutil.wl.devmgr.request_notified = -1;
1540
1541    set_last_result(ret);
1542    if (ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE)
1543      goto out;
1544
1545    return inputgen_h;
1546
1547 out:
1548    if (inputgen_h)
1549      {
1550         free(inputgen_h);
1551         inputgen_h = NULL;
1552      }
1553    return NULL;
1554 }
1555
1556 API efl_util_inputgen_h
1557 efl_util_input_initialize_generator_with_name(unsigned int dev_type, const char *name)
1558 {
1559    int ret = EFL_UTIL_ERROR_NONE;
1560    efl_util_inputgen_h inputgen_h = NULL;
1561    unsigned int clas = 0x0;
1562
1563    if (!dev_type ||
1564         dev_type & ~(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN
1565                     | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD
1566                     | EFL_UTIL_INPUT_DEVTYPE_POINTER))
1567      {
1568         set_last_result(EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1569         goto out;
1570      }
1571
1572    inputgen_h = (efl_util_inputgen_h)calloc(1, sizeof(struct _efl_util_inputgen_h));
1573    if (!inputgen_h)
1574      {
1575         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
1576         goto out;
1577      }
1578
1579    inputgen_h->init_type |= dev_type;
1580    strncpy(inputgen_h->name, name, 31);
1581
1582    ret = _wl_init();
1583    if (ret == (int)EINA_FALSE)
1584      {
1585         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
1586         goto out;
1587      }
1588
1589    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
1590      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN;
1591    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
1592      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD;
1593    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
1594      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE;
1595
1596    while (!_eflutil.wl.devmgr.devicemgr)
1597      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1598
1599    tizen_input_device_manager_init_generator_with_name(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name);
1600
1601    while (_eflutil.wl.devmgr.request_notified == -1)
1602      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1603
1604    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1605    _eflutil.wl.devmgr.request_notified = -1;
1606
1607    set_last_result(ret);
1608    if (ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE)
1609      goto out;
1610
1611    return inputgen_h;
1612
1613 out:
1614    if (inputgen_h)
1615      {
1616         free(inputgen_h);
1617         inputgen_h = NULL;
1618      }
1619    return NULL;
1620 }
1621
1622 API efl_util_inputgen_h
1623 efl_util_input_initialize_generator_with_sync(unsigned int dev_type, const char *name)
1624 {
1625    int ret = EFL_UTIL_ERROR_NONE;
1626    efl_util_inputgen_h inputgen_h = NULL;
1627    unsigned int clas = 0x0;
1628
1629    if (!dev_type ||
1630         dev_type & ~(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN
1631                     | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD
1632                     | EFL_UTIL_INPUT_DEVTYPE_POINTER))
1633      {
1634         set_last_result(EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1635         goto out;
1636      }
1637
1638    inputgen_h = (efl_util_inputgen_h)calloc(1, sizeof(struct _efl_util_inputgen_h));
1639    if (!inputgen_h)
1640      {
1641         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
1642         goto out;
1643      }
1644
1645    inputgen_h->init_type |= dev_type;
1646    if (name) strncpy(inputgen_h->name, name, 31);
1647    else strncpy(inputgen_h->name, "Input Generator", 31);
1648
1649    ret = _wl_init();
1650    if (ret == (int)EINA_FALSE)
1651      {
1652         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
1653         goto out;
1654      }
1655
1656    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
1657      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN;
1658    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
1659      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD;
1660    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
1661      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE;
1662
1663    while (!_eflutil.wl.devmgr.devicemgr)
1664      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1665
1666    tizen_input_device_manager_init_generator_with_name(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name);
1667
1668    while (_eflutil.wl.devmgr.request_notified == -1)
1669      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1670
1671    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1672    _eflutil.wl.devmgr.request_notified = -1;
1673
1674    if (ret == EFL_UTIL_ERROR_NONE)
1675      {
1676         _efl_util_input_initialize_add_wait_device(inputgen_h->name, dev_type);
1677         _efl_util_input_initialize_wait_device();
1678         if (_eflutil.wl.devmgr.request_notified != -1)
1679           {
1680              ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1681              _eflutil.wl.devmgr.request_notified = -1;
1682           }
1683      }
1684
1685    set_last_result(ret);
1686    if (ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE)
1687      goto out;
1688
1689    return inputgen_h;
1690
1691 out:
1692    if (inputgen_h)
1693      {
1694         free(inputgen_h);
1695         inputgen_h = NULL;
1696      }
1697    return NULL;
1698 }
1699
1700 API int
1701 efl_util_input_set_touch_count(int max_count)
1702 {
1703    int ret = EFL_UTIL_ERROR_NONE;
1704
1705    ret = _wl_init();
1706    if (ret == (int)EINA_FALSE)
1707      {
1708         return EFL_UTIL_ERROR_INVALID_PARAMETER;
1709      }
1710
1711    while (!_eflutil.wl.devmgr.devicemgr)
1712      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1713
1714    if (_eflutil.wl.devmgr.max_touch_count >= max_count)
1715      return EFL_UTIL_ERROR_NONE;
1716
1717    tizen_input_device_manager_set_touch_count(_eflutil.wl.devmgr.devicemgr, max_count);
1718
1719    while (_eflutil.wl.devmgr.request_notified == -1)
1720      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1721
1722    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1723    _eflutil.wl.devmgr.request_notified = -1;
1724
1725    if (ret == EFL_UTIL_ERROR_NONE)
1726      {
1727         _eflutil.wl.devmgr.request_touch_count = max_count;
1728      }
1729
1730    return ret;
1731 }
1732
1733 API int
1734 efl_util_input_deinitialize_generator(efl_util_inputgen_h inputgen_h)
1735 {
1736    int ret = EFL_UTIL_ERROR_NONE;
1737    unsigned int clas = 0x0;
1738    EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1739
1740    if (inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
1741      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN;
1742    if (inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
1743      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD;
1744    if (inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
1745      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE;
1746
1747    if (inputgen_h->axis_info)
1748      free(inputgen_h->axis_info);
1749
1750    free(inputgen_h);
1751    inputgen_h = NULL;
1752
1753    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1754
1755    tizen_input_device_manager_deinit_generator(_eflutil.wl.devmgr.devicemgr, clas);
1756
1757    while (_eflutil.wl.devmgr.request_notified == -1)
1758      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1759
1760    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1761    _eflutil.wl.devmgr.request_notified = -1;
1762
1763    return ret;
1764 }
1765
1766 API int
1767 efl_util_input_generate_key(efl_util_inputgen_h inputgen_h, const char *key_name, int pressed)
1768 {
1769    int ret = EFL_UTIL_ERROR_NONE;
1770
1771    EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1772    EINA_SAFETY_ON_NULL_RETURN_VAL(key_name, EFL_UTIL_ERROR_INVALID_PARAMETER);
1773    EINA_SAFETY_ON_FALSE_RETURN_VAL(pressed == 0 || pressed == 1, EFL_UTIL_ERROR_INVALID_PARAMETER);
1774    EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1775
1776    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1777
1778    tizen_input_device_manager_generate_key(_eflutil.wl.devmgr.devicemgr, key_name, pressed);
1779
1780    while (_eflutil.wl.devmgr.request_notified == -1)
1781      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1782
1783    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1784    _eflutil.wl.devmgr.request_notified = -1;
1785
1786    return ret;
1787 }
1788
1789 API int
1790 efl_util_input_generate_touch(efl_util_inputgen_h inputgen_h, int idx,
1791                               efl_util_input_touch_type_e touch_type, int x, int y)
1792 {
1793    int ret;
1794    enum tizen_input_device_manager_pointer_event_type type;
1795
1796    EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1797    EINA_SAFETY_ON_FALSE_RETURN_VAL(idx >= 0, EFL_UTIL_ERROR_INVALID_PARAMETER);
1798    EINA_SAFETY_ON_FALSE_RETURN_VAL((x > 0 && y > 0), EFL_UTIL_ERROR_INVALID_PARAMETER);
1799    EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1800
1801    if (idx >= _eflutil.wl.devmgr.max_touch_count)
1802      return EFL_UTIL_ERROR_INVALID_PARAMETER;
1803
1804    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1805
1806    switch(touch_type)
1807      {
1808         case EFL_UTIL_INPUT_TOUCH_BEGIN:
1809            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_BEGIN;
1810            break;
1811         case EFL_UTIL_INPUT_TOUCH_UPDATE:
1812            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_UPDATE;
1813            break;
1814         case EFL_UTIL_INPUT_TOUCH_END:
1815            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_END;
1816            break;
1817         default:
1818            return EFL_UTIL_ERROR_INVALID_PARAMETER;
1819      }
1820
1821    tizen_input_device_manager_generate_touch(_eflutil.wl.devmgr.devicemgr, type, x, y, idx);
1822
1823    while (_eflutil.wl.devmgr.request_notified == -1)
1824      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1825
1826    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1827    _eflutil.wl.devmgr.request_notified = -1;
1828
1829    return ret;
1830 }
1831
1832 static int
1833 _efl_util_input_generate_touch_axis_send(unsigned int type, double value)
1834 {
1835    int ret;
1836
1837    tizen_input_device_manager_generate_axis(_eflutil.wl.devmgr.devicemgr, type, wl_fixed_from_double(value));
1838
1839    while (_eflutil.wl.devmgr.request_notified == -1)
1840      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1841
1842    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1843    _eflutil.wl.devmgr.request_notified = -1;
1844
1845    return ret;
1846 }
1847
1848 static void
1849 _efl_util_input_generate_touch_axis_cleanup(efl_util_inputgen_h inputgen_h, int idx)
1850 {
1851    int i;
1852    if (idx >= 0)
1853      {
1854         inputgen_h->axis_info[idx].radius_x = 1.0;
1855         inputgen_h->axis_info[idx].radius_y = 1.0;
1856         inputgen_h->axis_info[idx].pressure = 1.0;
1857         inputgen_h->axis_info[idx].angle = 0.0;
1858         inputgen_h->axis_info[idx].palm = 0.0;
1859      }
1860    else
1861      {
1862         for (i = 0; i < EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER; i++)
1863           {
1864              inputgen_h->axis_info[i].radius_x = 1.0;
1865              inputgen_h->axis_info[i].radius_y = 1.0;
1866              inputgen_h->axis_info[i].pressure = 1.0;
1867              inputgen_h->axis_info[i].angle = 0.0;
1868              inputgen_h->axis_info[i].palm = 0.0;
1869           }
1870      }
1871 }
1872
1873 static int
1874 _efl_util_input_generate_touch_axis_process(efl_util_inputgen_h inputgen_h, int idx, double radius_x,
1875                                             double radius_y, double pressure, double angle, double palm)
1876 {
1877    int ret = EFL_UTIL_ERROR_NONE;
1878
1879    if (!inputgen_h->axis_info)
1880      {
1881         inputgen_h->axis_info = calloc(EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER,
1882                                        sizeof(E_Devicemgr_Inputgen_Touch_Axis));
1883         _efl_util_input_generate_touch_axis_cleanup(inputgen_h, -1);
1884      }
1885
1886    if (inputgen_h->axis_info[idx].radius_x != radius_x)
1887      {
1888         ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_RADIUS_X, radius_x);
1889         if (ret != EFL_UTIL_ERROR_NONE) return ret;
1890         inputgen_h->axis_info[idx].radius_x = radius_x;
1891      }
1892    if (inputgen_h->axis_info[idx].radius_y != radius_y)
1893      {
1894         ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_RADIUS_Y, radius_y);
1895         if (ret != EFL_UTIL_ERROR_NONE) return ret;
1896         inputgen_h->axis_info[idx].radius_y = radius_y;
1897      }
1898    if (inputgen_h->axis_info[idx].pressure != pressure)
1899      {
1900         ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_PRESSURE, pressure);
1901         if (ret != EFL_UTIL_ERROR_NONE) return ret;
1902         inputgen_h->axis_info[idx].pressure = pressure;
1903      }
1904    if (inputgen_h->axis_info[idx].angle != angle)
1905      {
1906         ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_ANGLE, angle);
1907         if (ret != EFL_UTIL_ERROR_NONE) return ret;
1908         inputgen_h->axis_info[idx].angle = angle;
1909      }
1910    if (inputgen_h->axis_info[idx].palm != palm)
1911      {
1912         ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_PALM, palm);
1913         if (ret != EFL_UTIL_ERROR_NONE) return ret;
1914         inputgen_h->axis_info[idx].palm = palm;
1915      }
1916
1917    return ret;
1918 }
1919
1920 API int
1921 efl_util_input_generate_touch_axis(efl_util_inputgen_h inputgen_h, int idx,
1922                                    efl_util_input_touch_type_e touch_type, int x, int y,
1923                                    double radius_x, double radius_y,
1924                                    double pressure, double angle, double palm)
1925 {
1926    int ret, version;
1927    enum tizen_input_device_manager_pointer_event_type type;
1928
1929    EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1930    EINA_SAFETY_ON_FALSE_RETURN_VAL(idx >= 0, EFL_UTIL_ERROR_INVALID_PARAMETER);
1931    EINA_SAFETY_ON_FALSE_RETURN_VAL((x >= 0 && y >= 0), EFL_UTIL_ERROR_INVALID_PARAMETER);
1932    EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1933    EINA_SAFETY_ON_FALSE_RETURN_VAL((radius_x >= 0.0 && radius_y >= 0.0), EFL_UTIL_ERROR_INVALID_PARAMETER);
1934    EINA_SAFETY_ON_FALSE_RETURN_VAL((pressure >= 0.0 && palm >= 0.0), EFL_UTIL_ERROR_INVALID_PARAMETER);
1935
1936    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1937    version = tizen_input_device_manager_get_version(_eflutil.wl.devmgr.devicemgr);
1938    EINA_SAFETY_ON_FALSE_RETURN_VAL((version >= 3), EFL_UTIL_ERROR_NOT_SUPPORTED);
1939
1940    switch(touch_type)
1941      {
1942         case EFL_UTIL_INPUT_TOUCH_BEGIN:
1943            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_BEGIN;
1944            break;
1945         case EFL_UTIL_INPUT_TOUCH_UPDATE:
1946            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_UPDATE;
1947            break;
1948         case EFL_UTIL_INPUT_TOUCH_END:
1949            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_END;
1950            break;
1951         default:
1952            return EFL_UTIL_ERROR_INVALID_PARAMETER;
1953      }
1954
1955    if (touch_type != EFL_UTIL_INPUT_TOUCH_END)
1956      _efl_util_input_generate_touch_axis_process(inputgen_h, idx, radius_x, radius_y, pressure, angle, palm);
1957    else
1958      _efl_util_input_generate_touch_axis_cleanup(inputgen_h, idx);
1959
1960    tizen_input_device_manager_generate_touch(_eflutil.wl.devmgr.devicemgr, type, x, y, idx);
1961
1962    while (_eflutil.wl.devmgr.request_notified == -1)
1963      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1964
1965    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1966    _eflutil.wl.devmgr.request_notified = -1;
1967
1968    return ret;
1969 }
1970
1971
1972 API int
1973 efl_util_input_generate_pointer(efl_util_inputgen_h inputgen_h, int buttons, efl_util_input_pointer_type_e pointer_type, int x, int y)
1974 {
1975    int ret;
1976    enum tizen_input_device_manager_pointer_event_type type;
1977
1978    EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1979    EINA_SAFETY_ON_FALSE_RETURN_VAL(buttons > 0, EFL_UTIL_ERROR_INVALID_PARAMETER);
1980    EINA_SAFETY_ON_FALSE_RETURN_VAL((x >= 0 && y >= 0), EFL_UTIL_ERROR_INVALID_PARAMETER);
1981    EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1982
1983    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1984
1985    switch(pointer_type)
1986      {
1987         case EFL_UTIL_INPUT_POINTER_BUTTON_DOWN:
1988            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_BEGIN;
1989            break;
1990         case EFL_UTIL_INPUT_POINTER_MOVE:
1991            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_UPDATE;
1992            break;
1993         case EFL_UTIL_INPUT_POINTER_BUTTON_UP:
1994            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_END;
1995            break;
1996         default:
1997            return EFL_UTIL_ERROR_INVALID_PARAMETER;
1998      }
1999
2000    tizen_input_device_manager_generate_pointer(_eflutil.wl.devmgr.devicemgr, type, x, y, buttons);
2001
2002    while (_eflutil.wl.devmgr.request_notified == -1)
2003      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2004
2005    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
2006    _eflutil.wl.devmgr.request_notified = -1;
2007
2008    return ret;
2009 }
2010
2011 API int
2012 efl_util_input_generate_wheel(efl_util_inputgen_h inputgen_h, efl_util_input_pointer_wheel_type_e wheel_type, int value)
2013 {
2014    int ret, version;
2015    enum tizen_input_device_manager_pointer_event_type type;
2016
2017    EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
2018    EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
2019
2020    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
2021    version = tizen_input_device_manager_get_version(_eflutil.wl.devmgr.devicemgr);
2022    EINA_SAFETY_ON_FALSE_RETURN_VAL((version >= 3), EFL_UTIL_ERROR_NOT_SUPPORTED);
2023
2024    switch(wheel_type)
2025      {
2026         case EFL_UTIL_INPUT_POINTER_WHEEL_VERT:
2027            type = TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_WHEEL;
2028            break;
2029         case EFL_UTIL_INPUT_POINTER_WHEEL_HORZ:
2030            type = TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_HWHEEL;
2031            break;
2032         default:
2033            return EFL_UTIL_ERROR_INVALID_PARAMETER;
2034      }
2035
2036    tizen_input_device_manager_generate_axis(_eflutil.wl.devmgr.devicemgr, type, wl_fixed_from_int(value));
2037
2038    while (_eflutil.wl.devmgr.request_notified == -1)
2039      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2040
2041    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
2042    _eflutil.wl.devmgr.request_notified = -1;
2043
2044    return ret;
2045 }
2046
2047
2048
2049 struct _efl_util_screenshot_h
2050 {
2051    int width;
2052    int height;
2053
2054    Eina_Bool shot_done;
2055
2056    /* tbm bufmgr */
2057    tbm_bufmgr bufmgr;
2058
2059    Eina_Bool auto_rotation;
2060 };
2061
2062 /* scrrenshot handle */
2063 static efl_util_screenshot_h g_screenshot;
2064 static Eina_Bool shot_mutex_init;
2065 static pthread_mutex_t shot_lock;
2066
2067 static Eina_Bool
2068 _screenshot_mutex_init(void)
2069 {
2070    if (shot_mutex_init)
2071      return EINA_TRUE;
2072
2073    if (pthread_mutex_init(&shot_lock, NULL))
2074      {
2075         fprintf(stderr, "[screenshot] fail: mutex init"); /*LCOV_EXCL_LINE*/
2076         return EINA_FALSE; /*LCOV_EXCL_LINE*/
2077      }
2078
2079    shot_mutex_init = EINA_TRUE;
2080
2081    return EINA_TRUE;
2082 }
2083
2084 static Eina_Bool
2085 _screenshot_mutex_destory(void)
2086 {
2087    if (!shot_mutex_init)
2088      return EINA_TRUE;
2089
2090    if (pthread_mutex_destroy(&shot_lock))
2091      {
2092         fprintf(stderr, "[screenshot] fail: mutex destory"); /*LCOV_EXCL_LINE*/
2093         return EINA_FALSE; /*LCOV_EXCL_LINE*/
2094      }
2095
2096    shot_mutex_init = EINA_FALSE;
2097
2098    return EINA_TRUE;
2099 }
2100
2101 void
2102 _screenshot_mutex_lock(void)
2103 {
2104    if (!_screenshot_mutex_init())
2105      return;
2106
2107    pthread_mutex_lock(&shot_lock);
2108 }
2109
2110 void
2111 _screenshot_mutex_unlock(void)
2112 {
2113    pthread_mutex_unlock(&shot_lock);
2114 }
2115
2116 API efl_util_screenshot_h
2117 efl_util_screenshot_initialize(int width, int height)
2118 {
2119    efl_util_screenshot_h screenshot = NULL;
2120    struct wl_display *display_wrapper = NULL;
2121    struct wl_registry *reg = NULL;
2122    int ret = 0;
2123
2124    if (width <= 0 || height <= 0)
2125      {
2126         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2127         return NULL;
2128      }
2129
2130    _screenshot_mutex_lock();
2131
2132    if (!g_screenshot)
2133      {
2134         screenshot = calloc(1, sizeof(struct _efl_util_screenshot_h));
2135         EINA_SAFETY_ON_NULL_GOTO(screenshot, fail_memory);
2136      }
2137
2138    if (!_eflutil.wl.shot.screenshooter)
2139      {
2140         ret = _wl_init();
2141         if (ret == (int)EINA_FALSE)
2142           {
2143              set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2144              _screenshot_mutex_unlock();
2145              if (screenshot)
2146                 free(screenshot);
2147              return NULL;
2148           }
2149         wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2150
2151         display_wrapper = wl_proxy_create_wrapper(_eflutil.wl.dpy);
2152         EINA_SAFETY_ON_NULL_GOTO(display_wrapper, fail_memory);
2153
2154         _eflutil.wl.shot.queue = wl_display_create_queue(_eflutil.wl.dpy);
2155         EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.queue, fail_memory);
2156
2157         wl_proxy_set_queue((struct wl_proxy *)display_wrapper, _eflutil.wl.shot.queue);
2158
2159         reg = wl_display_get_registry(display_wrapper);
2160         wl_proxy_wrapper_destroy(display_wrapper);
2161         display_wrapper = NULL;
2162         EINA_SAFETY_ON_NULL_GOTO(reg, fail_init);
2163
2164         wl_registry_add_listener(reg, &_wl_reg_screenshooter_listener, NULL);
2165
2166         ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
2167         EINA_SAFETY_ON_TRUE_GOTO(ret == -1, fail_init);
2168         EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.screenshooter, fail_init);
2169         EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tz_screenshooter, fail_init);
2170
2171         _eflutil.wl.shot.tbm_client = wayland_tbm_client_init(_eflutil.wl.dpy);
2172         EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tbm_client, fail_init);
2173
2174         wl_registry_destroy(reg);
2175         reg = NULL;
2176      }
2177
2178    if (_eflutil.wl.shot.noti == 0)
2179      {
2180         fprintf(stderr, "[screenshot] fail: privilege error\n"); /* LCOV_EXCL_LINE */
2181         goto fail_init;
2182      }
2183
2184    if (g_screenshot)
2185      {
2186         if (g_screenshot->width != width || g_screenshot->height != height)
2187           {
2188              g_screenshot->width = width;
2189              g_screenshot->height = height;
2190           }
2191         set_last_result(EFL_UTIL_ERROR_NONE);
2192
2193         _screenshot_mutex_unlock();
2194
2195         return g_screenshot;
2196      }
2197
2198    screenshot->width = width;
2199    screenshot->height = height;
2200    screenshot->auto_rotation = EINA_TRUE;
2201
2202    screenshot->bufmgr = wayland_tbm_client_get_bufmgr(_eflutil.wl.shot.tbm_client);
2203    EINA_SAFETY_ON_NULL_GOTO(screenshot->bufmgr, fail_init);
2204
2205    g_screenshot = screenshot;
2206    set_last_result(EFL_UTIL_ERROR_NONE);
2207
2208    screenshooter_set_user_data(_eflutil.wl.shot.screenshooter, &screenshot->shot_done);
2209
2210    _screenshot_mutex_unlock();
2211
2212    return g_screenshot;
2213
2214 /* LCOV_EXCL_START */
2215 fail_memory:
2216    if (display_wrapper)
2217      wl_proxy_wrapper_destroy(display_wrapper);
2218    set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
2219    if (screenshot)
2220      free(screenshot);
2221    _screenshot_mutex_unlock();
2222    return NULL;
2223
2224 fail_init:
2225    if (reg)
2226      wl_registry_destroy(reg);
2227    if (screenshot)
2228      {
2229         _screenshot_mutex_unlock();
2230         efl_util_screenshot_deinitialize(screenshot);
2231      }
2232    if (_eflutil.wl.shot.noti == 0)
2233      set_last_result(EFL_UTIL_ERROR_PERMISSION_DENIED);
2234    else
2235      set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL);
2236    return NULL;
2237 /* LCOV_EXCL_STOP */
2238 }
2239
2240 API int
2241 efl_util_screenshot_deinitialize(efl_util_screenshot_h screenshot)
2242 {
2243    _screenshot_mutex_lock();
2244
2245    if (!screenshot)
2246      {
2247         _screenshot_mutex_unlock();
2248         _screenshot_mutex_destory();
2249         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2250      }
2251
2252    free(screenshot);
2253    g_screenshot = NULL;
2254
2255    if (_eflutil.wl.shot.tbm_client)
2256      {
2257         wayland_tbm_client_deinit(_eflutil.wl.shot.tbm_client);
2258         _eflutil.wl.shot.tbm_client = NULL;
2259      }
2260
2261    if (_eflutil.wl.shot.screenshooter)
2262      {
2263         screenshooter_destroy(_eflutil.wl.shot.screenshooter);
2264         _eflutil.wl.shot.screenshooter = NULL;
2265      }
2266    if (_eflutil.wl.shot.tz_screenshooter)
2267      {
2268         tizen_screenshooter_destroy(_eflutil.wl.shot.tz_screenshooter);
2269         _eflutil.wl.shot.tz_screenshooter = NULL;
2270      }
2271
2272    if (_eflutil.wl.shot.queue)
2273      {
2274         wl_event_queue_destroy(_eflutil.wl.shot.queue);
2275         _eflutil.wl.shot.queue = NULL;
2276      }
2277
2278    _screenshot_mutex_unlock();
2279    _screenshot_mutex_destory();
2280
2281    return EFL_UTIL_ERROR_NONE;
2282 }
2283
2284
2285 API tbm_surface_h
2286 efl_util_screenshot_take_tbm_surface(efl_util_screenshot_h screenshot)
2287 {
2288    tbm_surface_h t_surface = NULL;
2289    struct wl_buffer *buffer = NULL;
2290    Efl_Util_Wl_Output_Info *output;
2291    int ret = 0;
2292
2293    _screenshot_mutex_lock();
2294
2295    if (!screenshot || (screenshot != g_screenshot))
2296      {
2297         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2298         _screenshot_mutex_unlock();
2299         return NULL;
2300      }
2301
2302    output = eina_list_nth(_eflutil.wl.shot.output_list, 0);
2303    if (!output)
2304      {
2305         fprintf(stderr, "[screenshot] fail: no output for screenshot\n"); /* LCOV_EXCL_LINE */
2306         goto fail;
2307      }
2308
2309    t_surface = tbm_surface_create(screenshot->width, screenshot->height, TBM_FORMAT_XRGB8888);
2310    if (!t_surface)
2311      {
2312         fprintf(stderr, "[screenshot] fail: tbm_surface_create\n"); /* LCOV_EXCL_LINE */
2313         goto fail;
2314      }
2315
2316    buffer = wayland_tbm_client_create_buffer(_eflutil.wl.shot.tbm_client, t_surface);
2317    if (!buffer)
2318      {
2319         fprintf(stderr, "[screenshot] fail: create wl_buffer for screenshot\n"); /* LCOV_EXCL_LINE */
2320         goto fail;
2321      }
2322
2323    screenshooter_shoot(_eflutil.wl.shot.screenshooter, output->output, buffer);
2324
2325    screenshot->shot_done = EINA_FALSE;
2326    while (!screenshot->shot_done && ret != -1)
2327      ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
2328
2329    if (ret == -1)
2330      {
2331         fprintf(stderr, "[screenshot] fail: screenshooter_shoot\n"); /* LCOV_EXCL_LINE */
2332         goto fail;
2333      }
2334
2335    wayland_tbm_client_destroy_buffer(_eflutil.wl.shot.tbm_client, buffer);
2336
2337    /* reset shot_done for next screenshot */
2338    screenshot->shot_done = EINA_FALSE;
2339
2340    set_last_result(EFL_UTIL_ERROR_NONE);
2341
2342    _screenshot_mutex_unlock();
2343
2344    return t_surface;
2345
2346 fail:
2347    if (t_surface)
2348      tbm_surface_destroy(t_surface);
2349    if (buffer)
2350      wayland_tbm_client_destroy_buffer(_eflutil.wl.shot.tbm_client, buffer);
2351
2352    set_last_result(EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL);
2353
2354    _screenshot_mutex_unlock();
2355
2356    return NULL;
2357 }
2358
2359 API int
2360 efl_util_screenshot_set_auto_rotation(efl_util_screenshot_h screenshot, int set)
2361 {
2362    if (!screenshot || (screenshot != g_screenshot))
2363      return EFL_UTIL_ERROR_INVALID_PARAMETER;
2364
2365    if (!(set == 0 || set == 1))
2366      return EFL_UTIL_ERROR_INVALID_PARAMETER;
2367
2368    if (set)
2369      g_screenshot->auto_rotation = EINA_TRUE;
2370    else
2371      g_screenshot->auto_rotation = EINA_FALSE;
2372
2373    tizen_screenshooter_set_oneshot_auto_rotation(_eflutil.wl.shot.tz_screenshooter, g_screenshot->auto_rotation);
2374
2375    return EFL_UTIL_ERROR_NONE;
2376 }
2377
2378 API int
2379 efl_util_screenshot_get_auto_rotation(efl_util_screenshot_h screenshot, int *set)
2380 {
2381    if (!screenshot || (screenshot != g_screenshot) || !set)
2382      return EFL_UTIL_ERROR_INVALID_PARAMETER;
2383
2384    *set = g_screenshot->auto_rotation;
2385
2386    return EFL_UTIL_ERROR_NONE;
2387 }
2388
2389 struct _efl_util_gesture_h
2390 {
2391    Eina_Bool init;
2392 };
2393
2394 API int EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = 0;
2395 API int EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = 0;
2396 API int EFL_UTIL_EVENT_GESTURE_TAP = 0;
2397 API int EFL_UTIL_EVENT_GESTURE_PALM_COVER = 0;
2398
2399 /* LCOV_EXCL_START */
2400 static void
2401 _cb_gesture_edge_swipe_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t fingers EINA_UNUSED, uint32_t edge EINA_UNUSED, uint32_t edge_size EINA_UNUSED, uint32_t start_point EINA_UNUSED, uint32_t end_point EINA_UNUSED, uint32_t error)
2402 {
2403    _eflutil_defaultqueue.wl.gesture.request_notified = error;
2404 }
2405
2406 static void
2407 _cb_gesture_edge_swipe(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t mode, uint32_t fingers, int sx, int sy, uint32_t edge)
2408 {
2409    efl_util_event_gesture_edge_swipe_s *ev = NULL;
2410
2411    ev = (efl_util_event_gesture_edge_swipe_s *)calloc(1, sizeof(*ev));
2412    if (!ev) return;
2413
2414    ev->mode = mode;
2415
2416    ev->fingers = fingers;
2417    ev->sx = sx;
2418    ev->sy = sy;
2419    ev->edge = edge;
2420
2421    ecore_event_add(EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE, ev, NULL, NULL);
2422 }
2423
2424 static void
2425 _cb_gesture_edge_drag_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t fingers EINA_UNUSED, uint32_t edge EINA_UNUSED, uint32_t edge_size EINA_UNUSED, uint32_t start_point EINA_UNUSED, uint32_t end_point EINA_UNUSED, uint32_t error)
2426 {
2427    _eflutil_defaultqueue.wl.gesture.request_notified = error;
2428 }
2429
2430 static void
2431 _cb_gesture_edge_drag(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t mode, uint32_t fingers, int cx, int cy, uint32_t edge)
2432 {
2433    efl_util_event_gesture_edge_drag_s *ev = NULL;
2434
2435    ev = (efl_util_event_gesture_edge_drag_s *)calloc(1, sizeof(*ev));
2436    if (!ev) return;
2437
2438    ev->mode = mode;
2439
2440    ev->fingers = fingers;
2441    ev->cx = cx;
2442    ev->cy = cy;
2443    ev->edge = edge;
2444
2445    ecore_event_add(EFL_UTIL_EVENT_GESTURE_EDGE_DRAG, ev, NULL, NULL);
2446 }
2447
2448 static void
2449 _cb_gesture_tap_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t fingers EINA_UNUSED, uint32_t repeat EINA_UNUSED, uint32_t error)
2450 {
2451    _eflutil_defaultqueue.wl.gesture.request_notified = error;
2452 }
2453
2454 static void
2455 _cb_gesture_tap(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t mode, uint32_t fingers, uint32_t repeats)
2456 {
2457    efl_util_event_gesture_tap_s *ev = NULL;
2458
2459    ev = (efl_util_event_gesture_tap_s *)calloc(1, sizeof(*ev));
2460    if (!ev) return;
2461
2462    ev->mode = mode;
2463
2464    ev->fingers = fingers;
2465    ev->repeats = repeats;
2466
2467    ecore_event_add(EFL_UTIL_EVENT_GESTURE_TAP, ev, NULL, NULL);
2468 }
2469 /* LCOV_EXCL_STOP */
2470
2471 static void
2472 _cb_gesture_palm_cover_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, struct wl_surface *surface EINA_UNUSED, uint32_t error)
2473 {
2474    _eflutil_defaultqueue.wl.gesture.request_notified = error;
2475 }
2476
2477 /* LCOV_EXCL_START */
2478 static void
2479 _cb_gesture_palm_cover(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, struct wl_surface *surface, uint32_t mode, uint32_t duration, int cx, int cy, uint32_t size, wl_fixed_t pressure)
2480 {
2481    efl_util_event_gesture_palm_cover_s *ev = NULL;
2482
2483    ev = (efl_util_event_gesture_palm_cover_s *)calloc(1, sizeof(*ev));
2484    if (!ev) return;
2485
2486    ev->mode = mode;
2487
2488    ev->duration = duration;
2489    ev->cx = cx;
2490    ev->cy = cy;
2491    ev->size = size;
2492    ev->pressure = wl_fixed_to_int(pressure);
2493
2494    ecore_event_add(EFL_UTIL_EVENT_GESTURE_PALM_COVER, ev, NULL, NULL);
2495 }
2496 /* LCOV_EXCL_STOP */
2497
2498 static void
2499 _cb_gesture_activate_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, struct wl_surface *surface EINA_UNUSED, uint32_t type EINA_UNUSED, uint32_t active EINA_UNUSED, uint32_t error)
2500 {
2501    _eflutil_defaultqueue.wl.gesture.request_notified = error;
2502 }
2503
2504 static efl_util_error_e
2505 _efl_util_gesture_convert_error(int ret)
2506 {
2507    switch (ret)
2508      {
2509         case TIZEN_GESTURE_ERROR_NONE:
2510            return EFL_UTIL_ERROR_NONE;
2511         case TIZEN_GESTURE_ERROR_INVALID_DATA:
2512            return EFL_UTIL_ERROR_INVALID_PARAMETER;
2513         case TIZEN_GESTURE_ERROR_NO_PERMISSION:
2514            return EFL_UTIL_ERROR_PERMISSION_DENIED;
2515         case TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES:
2516            return EFL_UTIL_ERROR_OUT_OF_MEMORY;
2517         case TIZEN_GESTURE_ERROR_GRABBED_ALREADY:
2518            return EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE;
2519         case TIZEN_GESTURE_ERROR_NOT_SUPPORTED:
2520            return EFL_UTIL_ERROR_NOT_SUPPORTED;
2521         default :
2522            return EFL_UTIL_ERROR_NONE;
2523      }
2524 }
2525
2526 /* LCOV_EXCL_START */
2527 static int
2528 _efl_util_gesture_grab_edge_swipe(efl_util_gesture_data data)
2529 {
2530    int ret = EFL_UTIL_ERROR_NONE;
2531    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2532    Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = NULL;
2533    unsigned int fingers = 0;
2534    unsigned int edge = 0;
2535    unsigned int edge_size = 0;
2536    unsigned int start_point = 0;
2537    unsigned int end_point = 0;
2538
2539    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2540
2541    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2542    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2543    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_SWIPE,
2544                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2545
2546    edge_swipe_data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)data;
2547
2548    fingers = edge_swipe_data->fingers;
2549    edge = edge_swipe_data->edge;
2550    edge_size = edge_swipe_data->edge_size;
2551    start_point = edge_swipe_data->start_point;
2552    end_point = edge_swipe_data->end_point;
2553
2554    tizen_gesture_grab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2555
2556    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2557      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2558
2559    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2560    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2561
2562    return ret;
2563 }
2564
2565 static int
2566 _efl_util_gesture_ungrab_edge_swipe(efl_util_gesture_data data)
2567 {
2568    int ret = EFL_UTIL_ERROR_NONE;
2569    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2570    Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = NULL;
2571    unsigned int fingers = 0;
2572    unsigned int edge = 0;
2573    unsigned int edge_size = 0;
2574    unsigned int start_point = 0;
2575    unsigned int end_point = 0;
2576
2577    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2578
2579    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2580    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2581    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_SWIPE,
2582                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2583
2584    edge_swipe_data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)data;
2585
2586    fingers = edge_swipe_data->fingers;
2587    edge = edge_swipe_data->edge;
2588    edge_size = edge_swipe_data->edge_size;
2589    start_point = edge_swipe_data->start_point;
2590    end_point = edge_swipe_data->end_point;
2591
2592    tizen_gesture_ungrab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2593
2594    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2595      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2596
2597    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2598    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2599
2600    return ret;
2601 }
2602
2603 static int
2604 _efl_util_gesture_grab_edge_drag(efl_util_gesture_data data)
2605 {
2606    int ret = EFL_UTIL_ERROR_NONE;
2607    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2608    Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = NULL;
2609    unsigned int fingers = 0;
2610    unsigned int edge = 0;
2611    unsigned int edge_size = 0;
2612    unsigned int start_point = 0;
2613    unsigned int end_point = 0;
2614
2615    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2616
2617    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2618    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2619    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_DRAG,
2620                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2621
2622    edge_drag_data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)data;
2623
2624    fingers = edge_drag_data->fingers;
2625    edge = edge_drag_data->edge;
2626    edge_size = edge_drag_data->edge_size;
2627    start_point = edge_drag_data->start_point;
2628    end_point = edge_drag_data->end_point;
2629
2630    tizen_gesture_grab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2631
2632    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2633      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2634
2635    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2636    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2637
2638    return ret;
2639 }
2640
2641 static int
2642 _efl_util_gesture_ungrab_edge_drag(efl_util_gesture_data data)
2643 {
2644    int ret = EFL_UTIL_ERROR_NONE;
2645    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2646    Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = NULL;
2647    unsigned int fingers = 0;
2648    unsigned int edge = 0;
2649    unsigned int edge_size = 0;
2650    unsigned int start_point = 0;
2651    unsigned int end_point = 0;
2652
2653    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2654
2655    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2656    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2657    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_DRAG,
2658                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2659
2660    edge_drag_data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)data;
2661
2662    fingers = edge_drag_data->fingers;
2663    edge = edge_drag_data->edge;
2664    edge_size = edge_drag_data->edge_size;
2665    start_point = edge_drag_data->start_point;
2666    end_point = edge_drag_data->end_point;
2667
2668    tizen_gesture_ungrab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2669
2670    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2671      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2672
2673    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2674    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2675
2676    return ret;
2677 }
2678
2679
2680 static int
2681 _efl_util_gesture_grab_tap(efl_util_gesture_data data)
2682 {
2683    int ret = EFL_UTIL_ERROR_NONE;
2684    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2685    Efl_Util_Gesture_Tap_Grab_Data *tap_data = NULL;
2686    unsigned int fingers = 0;
2687    unsigned int repeats = 0;
2688
2689    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2690
2691    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2692    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2693    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_TAP,
2694                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2695
2696    tap_data = (Efl_Util_Gesture_Tap_Grab_Data *)data;
2697
2698    fingers = tap_data->fingers;
2699    repeats = tap_data->repeats;
2700
2701    tizen_gesture_grab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats);
2702
2703    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2704      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2705
2706    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2707    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2708
2709    return ret;
2710 }
2711
2712 static int
2713 _efl_util_gesture_ungrab_tap(efl_util_gesture_data data)
2714 {
2715    int ret = EFL_UTIL_ERROR_NONE;
2716    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2717    Efl_Util_Gesture_Tap_Grab_Data *tap_data = NULL;
2718    unsigned int fingers = 0;
2719    unsigned int repeats = 0;
2720
2721    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2722
2723    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2724    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2725    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_TAP,
2726                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2727
2728    tap_data = (Efl_Util_Gesture_Tap_Grab_Data *)data;
2729
2730    fingers = tap_data->fingers;
2731    repeats = tap_data->repeats;
2732
2733    tizen_gesture_ungrab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats);
2734
2735    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2736      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2737
2738    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2739    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2740
2741    return ret;
2742 }
2743
2744 static int
2745 _efl_util_gesture_grab_palm_cover(efl_util_gesture_data data)
2746 {
2747    int ret = EFL_UTIL_ERROR_NONE;
2748    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2749
2750    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2751
2752    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2753    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2754    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_PALM_COVER,
2755                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2756
2757    tizen_gesture_grab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto);
2758
2759    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2760      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2761
2762    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2763    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2764
2765    return ret;
2766 }
2767
2768 static int
2769 _efl_util_gesture_ungrab_palm_cover(efl_util_gesture_data data)
2770 {
2771    int ret = EFL_UTIL_ERROR_NONE;
2772    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2773
2774    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2775
2776    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2777    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2778    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_PALM_COVER,
2779                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2780
2781    tizen_gesture_ungrab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto);
2782
2783    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2784      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2785
2786    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2787    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2788
2789    return ret;
2790 }
2791 /* LCOV_EXCL_STOP */
2792
2793 API efl_util_gesture_h
2794 efl_util_gesture_initialize(void)
2795 {
2796    efl_util_gesture_h gesture_h = NULL;
2797
2798    gesture_h = (efl_util_gesture_h)calloc(1, sizeof(struct _efl_util_gesture_h));
2799    if (!gesture_h)
2800      {
2801         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
2802         goto out; /* LCOV_EXCL_LINE */
2803      }
2804
2805    if (_wl_init_default_queue() == (int)EINA_FALSE)
2806      {
2807         set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED); /* LCOV_EXCL_LINE */
2808         goto out; /* LCOV_EXCL_LINE */
2809      }
2810
2811    while (!_eflutil_defaultqueue.wl.gesture.proto)
2812      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); /* LCOV_EXCL_LINE */
2813
2814    if (_eflutil_defaultqueue.wl.gesture.event_init <= 0)
2815      {
2816         if (ecore_event_init() <= 0)
2817           {
2818              set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED); /* LCOV_EXCL_LINE */
2819              goto out; /* LCOV_EXCL_LINE */
2820           }
2821         EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = ecore_event_type_new();
2822         EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = ecore_event_type_new();
2823         EFL_UTIL_EVENT_GESTURE_TAP = ecore_event_type_new();
2824         EFL_UTIL_EVENT_GESTURE_PALM_COVER = ecore_event_type_new();
2825      }
2826    _eflutil_defaultqueue.wl.gesture.event_init++;
2827    gesture_h->init = EINA_TRUE;
2828
2829    set_last_result(EFL_UTIL_ERROR_NONE);
2830    return gesture_h;
2831
2832 out:
2833 /* LCOV_EXCL_START */
2834    if (gesture_h)
2835      {
2836         free(gesture_h);
2837         gesture_h = NULL;
2838      }
2839    return gesture_h;
2840 /* LCOV_EXCL_STOP */
2841 }
2842
2843 API int
2844 efl_util_gesture_deinitialize(efl_util_gesture_h gesture_h)
2845 {
2846    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
2847    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
2848
2849    free(gesture_h);
2850    gesture_h = NULL;
2851
2852    _eflutil_defaultqueue.wl.gesture.event_init--;
2853
2854    if (_eflutil_defaultqueue.wl.gesture.event_init <= 0)
2855      {
2856         _eflutil_defaultqueue.wl.gesture.event_init = 0;
2857         ecore_event_shutdown();
2858         EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = 0;
2859         EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = 0;
2860         EFL_UTIL_EVENT_GESTURE_TAP = 0;
2861         EFL_UTIL_EVENT_GESTURE_PALM_COVER = 0;
2862      }
2863
2864    return EFL_UTIL_ERROR_NONE;
2865 }
2866
2867 API efl_util_gesture_data
2868 efl_util_gesture_edge_swipe_new(efl_util_gesture_h gesture_h, unsigned int fingers, efl_util_gesture_edge_e edge)
2869 {
2870    Efl_Util_Gesture_Edge_Swipe_Grab_Data *data;
2871
2872    if (!gesture_h || gesture_h->init == EINA_FALSE)
2873      {
2874         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2875         return NULL;
2876      }
2877
2878    if (edge <= EFL_UTIL_GESTURE_EDGE_NONE || edge > EFL_UTIL_GESTURE_EDGE_LEFT)
2879      {
2880         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2881         return NULL;
2882      }
2883
2884    data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Edge_Swipe_Grab_Data));
2885    if (!data)
2886      {
2887         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
2888         return NULL; /* LCOV_EXCL_LINE */
2889      }
2890
2891    data->base.type = TIZEN_GESTURE_TYPE_EDGE_SWIPE;
2892    data->fingers = fingers;
2893    data->edge = edge;
2894    data->edge_size = EFL_UTIL_GESTURE_EDGE_SIZE_FULL;
2895
2896    set_last_result(EFL_UTIL_ERROR_NONE);
2897
2898    return (void *)data;
2899 }
2900
2901 API int
2902 efl_util_gesture_edge_swipe_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
2903 {
2904    if (!gesture_h || gesture_h->init == EINA_FALSE)
2905      {
2906         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2907      }
2908
2909    if (!data)
2910      {
2911         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2912      }
2913
2914    free(data);
2915    data = NULL;
2916
2917    return EFL_UTIL_ERROR_NONE;
2918 }
2919
2920 API int
2921 efl_util_gesture_edge_swipe_size_set(efl_util_gesture_data data, efl_util_gesture_edge_size_e edge_size, unsigned int start_point, unsigned int end_point)
2922 {
2923    Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = data;
2924
2925    EINA_SAFETY_ON_NULL_RETURN_VAL(edge_swipe_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2926    EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_swipe_data->base.type == TIZEN_GESTURE_TYPE_EDGE_SWIPE,
2927                                    EFL_UTIL_ERROR_INVALID_PARAMETER);
2928    EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_size == EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL,
2929                                    EFL_UTIL_ERROR_INVALID_PARAMETER);
2930    EINA_SAFETY_ON_FALSE_RETURN_VAL(end_point > start_point, EFL_UTIL_ERROR_INVALID_PARAMETER);
2931
2932    edge_swipe_data->edge_size = edge_size;
2933    edge_swipe_data->start_point = start_point;
2934    edge_swipe_data->end_point = end_point;
2935
2936    return EFL_UTIL_ERROR_NONE;
2937 }
2938
2939 API efl_util_gesture_data
2940 efl_util_gesture_edge_drag_new(efl_util_gesture_h gesture_h, unsigned int fingers, efl_util_gesture_edge_e edge)
2941 {
2942    Efl_Util_Gesture_Edge_Drag_Grab_Data *data;
2943
2944    if (!gesture_h || gesture_h->init == EINA_FALSE)
2945      {
2946         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2947         return NULL;
2948      }
2949
2950    if (edge <= EFL_UTIL_GESTURE_EDGE_NONE || edge > EFL_UTIL_GESTURE_EDGE_LEFT)
2951      {
2952         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2953         return NULL;
2954      }
2955
2956    data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Edge_Drag_Grab_Data));
2957    if (!data)
2958      {
2959         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
2960         return NULL; /* LCOV_EXCL_LINE */
2961      }
2962
2963    data->base.type = TIZEN_GESTURE_TYPE_EDGE_DRAG;
2964    data->fingers = fingers;
2965    data->edge = edge;
2966    data->edge_size = EFL_UTIL_GESTURE_EDGE_SIZE_FULL;
2967
2968    set_last_result(EFL_UTIL_ERROR_NONE);
2969
2970    return (void *)data;
2971 }
2972
2973 API int
2974 efl_util_gesture_edge_drag_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
2975 {
2976    if (!gesture_h || gesture_h->init == EINA_FALSE)
2977      {
2978         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2979      }
2980
2981    if (!data)
2982      {
2983         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2984      }
2985
2986    free(data);
2987    data = NULL;
2988
2989    return EFL_UTIL_ERROR_NONE;
2990 }
2991
2992 API int
2993 efl_util_gesture_edge_drag_size_set(efl_util_gesture_data data, efl_util_gesture_edge_size_e edge_size, unsigned int start_point, unsigned int end_point)
2994 {
2995    Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = data;
2996
2997    EINA_SAFETY_ON_NULL_RETURN_VAL(edge_drag_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2998    EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_drag_data->base.type == TIZEN_GESTURE_TYPE_EDGE_DRAG,
2999                                    EFL_UTIL_ERROR_INVALID_PARAMETER);
3000    EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_size == EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL,
3001                                    EFL_UTIL_ERROR_INVALID_PARAMETER);
3002    EINA_SAFETY_ON_FALSE_RETURN_VAL(end_point > start_point, EFL_UTIL_ERROR_INVALID_PARAMETER);
3003
3004    edge_drag_data->edge_size = edge_size;
3005    edge_drag_data->start_point = start_point;
3006    edge_drag_data->end_point = end_point;
3007
3008    return EFL_UTIL_ERROR_NONE;
3009 }
3010
3011 API efl_util_gesture_data
3012 efl_util_gesture_tap_new(efl_util_gesture_h gesture_h, unsigned int fingers, unsigned int repeats)
3013 {
3014    Efl_Util_Gesture_Tap_Grab_Data *data;
3015
3016    if (!gesture_h || gesture_h->init == EINA_FALSE)
3017      {
3018         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
3019         return NULL;
3020      }
3021
3022    if (fingers <= 1 || repeats <= 1)
3023      {
3024         set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED);
3025         return NULL;
3026      }
3027
3028    data = (Efl_Util_Gesture_Tap_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Tap_Grab_Data));
3029    if (!data)
3030      {
3031         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
3032         return NULL; /* LCOV_EXCL_LINE */
3033      }
3034
3035    data->base.type = TIZEN_GESTURE_TYPE_TAP;
3036    data->fingers = fingers;
3037    data->repeats = repeats;
3038
3039    set_last_result(EFL_UTIL_ERROR_NONE);
3040
3041    return (void *)data;
3042 }
3043
3044 API int
3045 efl_util_gesture_tap_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
3046 {
3047    if (!gesture_h || gesture_h->init == EINA_FALSE)
3048      {
3049         return EFL_UTIL_ERROR_INVALID_PARAMETER;
3050      }
3051
3052    if (!data)
3053      {
3054         return EFL_UTIL_ERROR_INVALID_PARAMETER;
3055      }
3056
3057    free(data);
3058    data = NULL;
3059
3060    return EFL_UTIL_ERROR_NONE;
3061 }
3062
3063 API efl_util_gesture_data
3064 efl_util_gesture_palm_cover_new(efl_util_gesture_h gesture_h)
3065 {
3066    Efl_Util_Gesture_Palm_Cover_Grab_Data *data;
3067
3068    if (!gesture_h || gesture_h->init == EINA_FALSE)
3069      {
3070         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
3071         return NULL;
3072      }
3073
3074    data = (Efl_Util_Gesture_Palm_Cover_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Palm_Cover_Grab_Data));
3075    if (!data)
3076      {
3077         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
3078         return NULL; /* LCOV_EXCL_LINE */
3079      }
3080
3081    data->base.type = TIZEN_GESTURE_TYPE_PALM_COVER;
3082
3083    set_last_result(EFL_UTIL_ERROR_NONE);
3084
3085    return (void *)data;
3086 }
3087
3088 API int
3089 efl_util_gesture_palm_cover_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
3090 {
3091    if (!gesture_h || gesture_h->init == EINA_FALSE)
3092      {
3093         return EFL_UTIL_ERROR_INVALID_PARAMETER;
3094      }
3095
3096    if (!data)
3097      {
3098         return EFL_UTIL_ERROR_INVALID_PARAMETER;
3099      }
3100
3101    free(data);
3102    data = NULL;
3103
3104    return EFL_UTIL_ERROR_NONE;
3105 }
3106
3107 /* LCOV_EXCL_START */
3108 API int
3109 efl_util_gesture_grab(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
3110 {
3111    int ret = EFL_UTIL_ERROR_NONE;
3112    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
3113
3114    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
3115
3116    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3117    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3118    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
3119
3120    switch (base_data->type)
3121      {
3122         case TIZEN_GESTURE_TYPE_EDGE_SWIPE:
3123            ret = _efl_util_gesture_grab_edge_swipe(data);
3124            break;
3125         case TIZEN_GESTURE_TYPE_EDGE_DRAG:
3126            ret = _efl_util_gesture_grab_edge_drag(data);
3127            break;
3128         case TIZEN_GESTURE_TYPE_TAP:
3129            ret = _efl_util_gesture_grab_tap(data);
3130            break;
3131         case TIZEN_GESTURE_TYPE_PALM_COVER:
3132            ret = _efl_util_gesture_grab_palm_cover(data);
3133            break;
3134         default:
3135            return EFL_UTIL_ERROR_INVALID_PARAMETER;
3136      }
3137
3138    return ret;
3139 }
3140
3141 API int
3142 efl_util_gesture_ungrab(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
3143 {
3144    int ret = EFL_UTIL_ERROR_NONE;
3145    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
3146
3147    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
3148
3149    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3150    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3151    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
3152
3153    switch (base_data->type)
3154      {
3155         case TIZEN_GESTURE_TYPE_EDGE_SWIPE:
3156            ret = _efl_util_gesture_ungrab_edge_swipe(data);
3157            break;
3158         case TIZEN_GESTURE_TYPE_EDGE_DRAG:
3159            ret = _efl_util_gesture_ungrab_edge_drag(data);
3160            break;
3161         case TIZEN_GESTURE_TYPE_TAP:
3162            ret = _efl_util_gesture_ungrab_tap(data);
3163            break;
3164         case TIZEN_GESTURE_TYPE_PALM_COVER:
3165            ret = _efl_util_gesture_ungrab_palm_cover(data);
3166            break;
3167         default:
3168            return EFL_UTIL_ERROR_INVALID_PARAMETER;
3169      }
3170
3171    return ret;
3172 }
3173 /* LCOV_EXCL_STOP */
3174
3175 API int
3176 efl_util_gesture_select(efl_util_gesture_h gesture_h, Evas_Object *window, efl_util_gesture_data data)
3177 {
3178    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
3179    Ecore_Wl2_Window *wlwin;
3180    struct wl_surface *surface;
3181    int ret;
3182
3183    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
3184
3185    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3186    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3187    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
3188    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
3189
3190    if (base_data->type != TIZEN_GESTURE_TYPE_PALM_COVER)
3191      return EFL_UTIL_ERROR_NOT_SUPPORTED;
3192
3193    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
3194    if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
3195
3196    surface = ecore_wl2_window_surface_get(wlwin);
3197    EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
3198                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
3199
3200    tizen_gesture_select_palm_cover(_eflutil_defaultqueue.wl.gesture.proto, surface);
3201
3202    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
3203      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
3204
3205    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
3206    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
3207
3208    return ret;
3209 }
3210
3211 API int
3212 efl_util_gesture_deselect(efl_util_gesture_h gesture_h, Evas_Object *window, efl_util_gesture_data data)
3213 {
3214    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
3215    Ecore_Wl2_Window *wlwin;
3216    struct wl_surface *surface;
3217    int ret;
3218
3219    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
3220
3221    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3222    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3223    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
3224    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
3225
3226    if (base_data->type != TIZEN_GESTURE_TYPE_PALM_COVER)
3227      return EFL_UTIL_ERROR_NOT_SUPPORTED;
3228
3229    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
3230    if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
3231
3232    surface = ecore_wl2_window_surface_get(wlwin);
3233    EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
3234                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
3235
3236    tizen_gesture_deselect_palm_cover(_eflutil_defaultqueue.wl.gesture.proto, surface);
3237
3238    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
3239      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
3240
3241    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
3242    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
3243
3244    return ret;
3245 }
3246
3247 /* LCOV_EXCL_START */
3248 API int
3249 efl_util_gesture_activate_set(efl_util_gesture_h gesture_h, unsigned int type, Eina_Bool active)
3250 {
3251    int ret;
3252
3253    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3254    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3255    EINA_SAFETY_ON_TRUE_RETURN_VAL(type == EFL_UTIL_GESTURE_TYPE_NONE, EFL_UTIL_ERROR_INVALID_PARAMETER);
3256
3257    tizen_gesture_activate_set(_eflutil_defaultqueue.wl.gesture.proto, NULL, type, active);
3258
3259    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
3260      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
3261
3262    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
3263    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
3264
3265    return ret;
3266 }
3267 /* LCOV_EXCL_STOP */
3268
3269 API int
3270 efl_util_gesture_activate_set_on_window(efl_util_gesture_h gesture_h, Evas_Object *window, unsigned int type, Eina_Bool active)
3271 {
3272    Ecore_Wl2_Window *wlwin;
3273    struct wl_surface *surface;
3274    int ret;
3275
3276    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3277    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3278    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
3279    EINA_SAFETY_ON_TRUE_RETURN_VAL(type == EFL_UTIL_GESTURE_TYPE_NONE, EFL_UTIL_ERROR_INVALID_PARAMETER);
3280
3281    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
3282    if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
3283
3284    surface = ecore_wl2_window_surface_get(wlwin);
3285    EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
3286                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
3287
3288    tizen_gesture_activate_set(_eflutil_defaultqueue.wl.gesture.proto, surface, type, active);
3289
3290    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
3291      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
3292
3293    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
3294    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
3295
3296    return ret;
3297 }