src/efl_util.c

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