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