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