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