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