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