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)
1456           {
1457              _timer_wait(NULL);
1458              return;
1459           }
1460      }
1461
1462    while (_eflutil.wl.devmgr.wait_timer)
1463      {
1464         wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1465         ret = wl_event_loop_dispatch(loop, EFL_UTIL_INPUT_GENERATOR_DEFAULT_DISPATCH_TIME_OUT);
1466         if (ret != 0) _timer_wait(NULL);
1467      }
1468 }
1469
1470 static void
1471 _efl_util_input_initialize_append_device(const char *name, Ecore_Device_Class clas)
1472 {
1473    Efl_Util_Device_Info *dev;
1474
1475    dev = (Efl_Util_Device_Info *)calloc(1, sizeof(Efl_Util_Device_Info));
1476    EINA_SAFETY_ON_NULL_RETURN(dev);
1477
1478    dev->name = eina_stringshare_add(name);
1479    dev->clas = clas;
1480
1481    _eflutil.wl.devmgr.wait_devices = eina_list_append(_eflutil.wl.devmgr.wait_devices, dev);
1482 }
1483
1484 static void
1485 _efl_util_input_initialize_add_wait_device(const char *name, unsigned int dev_type)
1486 {
1487    EINA_SAFETY_ON_NULL_RETURN(name);
1488
1489    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
1490      _efl_util_input_initialize_append_device(name, ECORE_DEVICE_CLASS_TOUCH);
1491
1492    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
1493      _efl_util_input_initialize_append_device(name, ECORE_DEVICE_CLASS_KEYBOARD);
1494
1495    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
1496      _efl_util_input_initialize_append_device(name, ECORE_DEVICE_CLASS_MOUSE);
1497 }
1498
1499 API efl_util_inputgen_h
1500 efl_util_input_initialize_generator(unsigned int dev_type)
1501 {
1502    int ret = EFL_UTIL_ERROR_NONE;
1503    efl_util_inputgen_h inputgen_h = NULL;
1504    unsigned int clas = 0x0;
1505
1506    if (!dev_type ||
1507         dev_type & ~(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN
1508                     | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD
1509                     | EFL_UTIL_INPUT_DEVTYPE_POINTER))
1510      {
1511         set_last_result(EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1512         goto out;
1513      }
1514
1515    inputgen_h = (efl_util_inputgen_h)calloc(1, sizeof(struct _efl_util_inputgen_h));
1516    if (!inputgen_h)
1517      {
1518         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
1519         goto out;
1520      }
1521
1522    inputgen_h->init_type |= dev_type;
1523
1524    ret = _wl_init();
1525    if (ret == (int)EINA_FALSE)
1526      {
1527         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
1528         goto out;
1529      }
1530
1531    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
1532      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN;
1533    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
1534      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD;
1535    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
1536      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE;
1537
1538    while (!_eflutil.wl.devmgr.devicemgr)
1539      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1540
1541    tizen_input_device_manager_init_generator(_eflutil.wl.devmgr.devicemgr, clas);
1542
1543    while (_eflutil.wl.devmgr.request_notified == -1)
1544      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1545
1546    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1547    _eflutil.wl.devmgr.request_notified = -1;
1548
1549    set_last_result(ret);
1550    if (ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE)
1551      goto out;
1552
1553    return inputgen_h;
1554
1555 out:
1556    if (inputgen_h)
1557      {
1558         free(inputgen_h);
1559         inputgen_h = NULL;
1560      }
1561    return NULL;
1562 }
1563
1564 API efl_util_inputgen_h
1565 efl_util_input_initialize_generator_with_name(unsigned int dev_type, const char *name)
1566 {
1567    int ret = EFL_UTIL_ERROR_NONE;
1568    efl_util_inputgen_h inputgen_h = NULL;
1569    unsigned int clas = 0x0;
1570
1571    if (!dev_type ||
1572         dev_type & ~(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN
1573                     | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD
1574                     | EFL_UTIL_INPUT_DEVTYPE_POINTER))
1575      {
1576         set_last_result(EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1577         goto out;
1578      }
1579
1580    inputgen_h = (efl_util_inputgen_h)calloc(1, sizeof(struct _efl_util_inputgen_h));
1581    if (!inputgen_h)
1582      {
1583         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
1584         goto out;
1585      }
1586
1587    inputgen_h->init_type |= dev_type;
1588    strncpy(inputgen_h->name, name, 31);
1589
1590    ret = _wl_init();
1591    if (ret == (int)EINA_FALSE)
1592      {
1593         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
1594         goto out;
1595      }
1596
1597    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
1598      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN;
1599    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
1600      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD;
1601    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
1602      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE;
1603
1604    while (!_eflutil.wl.devmgr.devicemgr)
1605      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1606
1607    tizen_input_device_manager_init_generator_with_name(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name);
1608
1609    while (_eflutil.wl.devmgr.request_notified == -1)
1610      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1611
1612    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1613    _eflutil.wl.devmgr.request_notified = -1;
1614
1615    set_last_result(ret);
1616    if (ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE)
1617      goto out;
1618
1619    return inputgen_h;
1620
1621 out:
1622    if (inputgen_h)
1623      {
1624         free(inputgen_h);
1625         inputgen_h = NULL;
1626      }
1627    return NULL;
1628 }
1629
1630 API efl_util_inputgen_h
1631 efl_util_input_initialize_generator_with_sync(unsigned int dev_type, const char *name)
1632 {
1633    int ret = EFL_UTIL_ERROR_NONE;
1634    efl_util_inputgen_h inputgen_h = NULL;
1635    unsigned int clas = 0x0;
1636
1637    if (!dev_type ||
1638         dev_type & ~(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN
1639                     | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD
1640                     | EFL_UTIL_INPUT_DEVTYPE_POINTER))
1641      {
1642         set_last_result(EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1643         goto out;
1644      }
1645
1646    inputgen_h = (efl_util_inputgen_h)calloc(1, sizeof(struct _efl_util_inputgen_h));
1647    if (!inputgen_h)
1648      {
1649         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
1650         goto out;
1651      }
1652
1653    inputgen_h->init_type |= dev_type;
1654    if (name) strncpy(inputgen_h->name, name, 31);
1655    else strncpy(inputgen_h->name, "Input Generator", 31);
1656
1657    ret = _wl_init();
1658    if (ret == (int)EINA_FALSE)
1659      {
1660         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
1661         goto out;
1662      }
1663
1664    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
1665      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN;
1666    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
1667      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD;
1668    if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
1669      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE;
1670
1671    while (!_eflutil.wl.devmgr.devicemgr)
1672      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1673
1674    tizen_input_device_manager_init_generator_with_name(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name);
1675
1676    while (_eflutil.wl.devmgr.request_notified == -1)
1677      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1678
1679    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1680    _eflutil.wl.devmgr.request_notified = -1;
1681
1682    if (ret == EFL_UTIL_ERROR_NONE)
1683      {
1684         _efl_util_input_initialize_add_wait_device(inputgen_h->name, dev_type);
1685         _efl_util_input_initialize_wait_device();
1686         if (_eflutil.wl.devmgr.request_notified != -1)
1687           {
1688              ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1689              _eflutil.wl.devmgr.request_notified = -1;
1690           }
1691      }
1692
1693    set_last_result(ret);
1694    if (ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE)
1695      goto out;
1696
1697    return inputgen_h;
1698
1699 out:
1700    if (inputgen_h)
1701      {
1702         free(inputgen_h);
1703         inputgen_h = NULL;
1704      }
1705    return NULL;
1706 }
1707
1708 API int
1709 efl_util_input_deinitialize_generator(efl_util_inputgen_h inputgen_h)
1710 {
1711    int ret = EFL_UTIL_ERROR_NONE;
1712    unsigned int clas = 0x0;
1713    EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1714
1715    if (inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
1716      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN;
1717    if (inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
1718      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD;
1719    if (inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
1720      clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE;
1721
1722    if (inputgen_h->axis_info)
1723      free(inputgen_h->axis_info);
1724
1725    free(inputgen_h);
1726    inputgen_h = NULL;
1727
1728    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1729
1730    tizen_input_device_manager_deinit_generator(_eflutil.wl.devmgr.devicemgr, clas);
1731
1732    while (_eflutil.wl.devmgr.request_notified == -1)
1733      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1734
1735    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1736    _eflutil.wl.devmgr.request_notified = -1;
1737
1738    return ret;
1739 }
1740
1741 API int
1742 efl_util_input_generate_key(efl_util_inputgen_h inputgen_h, const char *key_name, int pressed)
1743 {
1744    int ret = EFL_UTIL_ERROR_NONE;
1745
1746    EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1747    EINA_SAFETY_ON_NULL_RETURN_VAL(key_name, EFL_UTIL_ERROR_INVALID_PARAMETER);
1748    EINA_SAFETY_ON_FALSE_RETURN_VAL(pressed == 0 || pressed == 1, EFL_UTIL_ERROR_INVALID_PARAMETER);
1749    EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1750
1751    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1752
1753    tizen_input_device_manager_generate_key(_eflutil.wl.devmgr.devicemgr, key_name, pressed);
1754
1755    while (_eflutil.wl.devmgr.request_notified == -1)
1756      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1757
1758    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1759    _eflutil.wl.devmgr.request_notified = -1;
1760
1761    return ret;
1762 }
1763
1764 API int
1765 efl_util_input_generate_touch(efl_util_inputgen_h inputgen_h, int idx,
1766                               efl_util_input_touch_type_e touch_type, int x, int y)
1767 {
1768    int ret;
1769    enum tizen_input_device_manager_pointer_event_type type;
1770
1771    EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1772    EINA_SAFETY_ON_FALSE_RETURN_VAL(idx >= 0, EFL_UTIL_ERROR_INVALID_PARAMETER);
1773    EINA_SAFETY_ON_FALSE_RETURN_VAL((x > 0 && y > 0), EFL_UTIL_ERROR_INVALID_PARAMETER);
1774    EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1775
1776    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1777
1778    switch(touch_type)
1779      {
1780         case EFL_UTIL_INPUT_TOUCH_BEGIN:
1781            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_BEGIN;
1782            break;
1783         case EFL_UTIL_INPUT_TOUCH_UPDATE:
1784            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_UPDATE;
1785            break;
1786         case EFL_UTIL_INPUT_TOUCH_END:
1787            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_END;
1788            break;
1789         default:
1790            return EFL_UTIL_ERROR_INVALID_PARAMETER;
1791      }
1792
1793    tizen_input_device_manager_generate_touch(_eflutil.wl.devmgr.devicemgr, type, x, y, idx);
1794
1795    while (_eflutil.wl.devmgr.request_notified == -1)
1796      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1797
1798    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1799    _eflutil.wl.devmgr.request_notified = -1;
1800
1801    return ret;
1802 }
1803
1804 static int
1805 _efl_util_input_generate_touch_axis_send(unsigned int type, double value)
1806 {
1807    int ret;
1808
1809    tizen_input_device_manager_generate_axis(_eflutil.wl.devmgr.devicemgr, type, wl_fixed_from_double(value));
1810
1811    while (_eflutil.wl.devmgr.request_notified == -1)
1812      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1813
1814    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1815    _eflutil.wl.devmgr.request_notified = -1;
1816
1817    return ret;
1818 }
1819
1820 static void
1821 _efl_util_input_generate_touch_axis_cleanup(efl_util_inputgen_h inputgen_h, int idx)
1822 {
1823    int i;
1824    if (idx >= 0)
1825      {
1826         inputgen_h->axis_info[idx].radius_x = 1.0;
1827         inputgen_h->axis_info[idx].radius_y = 1.0;
1828         inputgen_h->axis_info[idx].pressure = 1.0;
1829         inputgen_h->axis_info[idx].angle = 0.0;
1830         inputgen_h->axis_info[idx].palm = 0.0;
1831      }
1832    else
1833      {
1834         for (i = 0; i < EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER; i++)
1835           {
1836              inputgen_h->axis_info[i].radius_x = 1.0;
1837              inputgen_h->axis_info[i].radius_y = 1.0;
1838              inputgen_h->axis_info[i].pressure = 1.0;
1839              inputgen_h->axis_info[i].angle = 0.0;
1840              inputgen_h->axis_info[i].palm = 0.0;
1841           }
1842      }
1843 }
1844
1845 static int
1846 _efl_util_input_generate_touch_axis_process(efl_util_inputgen_h inputgen_h, int idx, double radius_x,
1847                                             double radius_y, double pressure, double angle, double palm)
1848 {
1849    int ret = EFL_UTIL_ERROR_NONE;
1850
1851    if (!inputgen_h->axis_info)
1852      {
1853         inputgen_h->axis_info = calloc(EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER,
1854                                        sizeof(E_Devicemgr_Inputgen_Touch_Axis));
1855         _efl_util_input_generate_touch_axis_cleanup(inputgen_h, -1);
1856      }
1857
1858    if (inputgen_h->axis_info[idx].radius_x != radius_x)
1859      {
1860         ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_RADIUS_X, radius_x);
1861         if (ret != EFL_UTIL_ERROR_NONE) return ret;
1862         inputgen_h->axis_info[idx].radius_x = radius_x;
1863      }
1864    if (inputgen_h->axis_info[idx].radius_y != radius_y)
1865      {
1866         ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_RADIUS_Y, radius_y);
1867         if (ret != EFL_UTIL_ERROR_NONE) return ret;
1868         inputgen_h->axis_info[idx].radius_y = radius_y;
1869      }
1870    if (inputgen_h->axis_info[idx].pressure != pressure)
1871      {
1872         ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_PRESSURE, pressure);
1873         if (ret != EFL_UTIL_ERROR_NONE) return ret;
1874         inputgen_h->axis_info[idx].pressure = pressure;
1875      }
1876    if (inputgen_h->axis_info[idx].angle != angle)
1877      {
1878         ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_ANGLE, angle);
1879         if (ret != EFL_UTIL_ERROR_NONE) return ret;
1880         inputgen_h->axis_info[idx].angle = angle;
1881      }
1882    if (inputgen_h->axis_info[idx].palm != palm)
1883      {
1884         ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_PALM, palm);
1885         if (ret != EFL_UTIL_ERROR_NONE) return ret;
1886         inputgen_h->axis_info[idx].palm = palm;
1887      }
1888
1889    return ret;
1890 }
1891
1892 API int
1893 efl_util_input_generate_touch_axis(efl_util_inputgen_h inputgen_h, int idx,
1894                                    efl_util_input_touch_type_e touch_type, int x, int y,
1895                                    double radius_x, double radius_y,
1896                                    double pressure, double angle, double palm)
1897 {
1898    int ret, version;
1899    enum tizen_input_device_manager_pointer_event_type type;
1900
1901    EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1902    EINA_SAFETY_ON_FALSE_RETURN_VAL(idx >= 0, EFL_UTIL_ERROR_INVALID_PARAMETER);
1903    EINA_SAFETY_ON_FALSE_RETURN_VAL((x >= 0 && y >= 0), EFL_UTIL_ERROR_INVALID_PARAMETER);
1904    EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1905    EINA_SAFETY_ON_FALSE_RETURN_VAL((radius_x >= 0.0 && radius_y >= 0.0), EFL_UTIL_ERROR_INVALID_PARAMETER);
1906    EINA_SAFETY_ON_FALSE_RETURN_VAL((pressure >= 0.0 && palm >= 0.0), EFL_UTIL_ERROR_INVALID_PARAMETER);
1907
1908    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1909    version = tizen_input_device_manager_get_version(_eflutil.wl.devmgr.devicemgr);
1910    EINA_SAFETY_ON_FALSE_RETURN_VAL((version >= 3), EFL_UTIL_ERROR_NOT_SUPPORTED);
1911
1912    switch(touch_type)
1913      {
1914         case EFL_UTIL_INPUT_TOUCH_BEGIN:
1915            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_BEGIN;
1916            break;
1917         case EFL_UTIL_INPUT_TOUCH_UPDATE:
1918            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_UPDATE;
1919            break;
1920         case EFL_UTIL_INPUT_TOUCH_END:
1921            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_END;
1922            break;
1923         default:
1924            return EFL_UTIL_ERROR_INVALID_PARAMETER;
1925      }
1926
1927    if (touch_type != EFL_UTIL_INPUT_TOUCH_END)
1928      _efl_util_input_generate_touch_axis_process(inputgen_h, idx, radius_x, radius_y, pressure, angle, palm);
1929    else
1930      _efl_util_input_generate_touch_axis_cleanup(inputgen_h, idx);
1931
1932    tizen_input_device_manager_generate_touch(_eflutil.wl.devmgr.devicemgr, type, x, y, idx);
1933
1934    while (_eflutil.wl.devmgr.request_notified == -1)
1935      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1936
1937    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1938    _eflutil.wl.devmgr.request_notified = -1;
1939
1940    return ret;
1941 }
1942
1943
1944 API int
1945 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)
1946 {
1947    int ret;
1948    enum tizen_input_device_manager_pointer_event_type type;
1949
1950    EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1951    EINA_SAFETY_ON_FALSE_RETURN_VAL(buttons > 0, EFL_UTIL_ERROR_INVALID_PARAMETER);
1952    EINA_SAFETY_ON_FALSE_RETURN_VAL((x >= 0 && y >= 0), EFL_UTIL_ERROR_INVALID_PARAMETER);
1953    EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1954
1955    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1956
1957    switch(pointer_type)
1958      {
1959         case EFL_UTIL_INPUT_POINTER_BUTTON_DOWN:
1960            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_BEGIN;
1961            break;
1962         case EFL_UTIL_INPUT_POINTER_MOVE:
1963            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_UPDATE;
1964            break;
1965         case EFL_UTIL_INPUT_POINTER_BUTTON_UP:
1966            type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_END;
1967            break;
1968         default:
1969            return EFL_UTIL_ERROR_INVALID_PARAMETER;
1970      }
1971
1972    tizen_input_device_manager_generate_pointer(_eflutil.wl.devmgr.devicemgr, type, x, y, buttons);
1973
1974    while (_eflutil.wl.devmgr.request_notified == -1)
1975      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1976
1977    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1978    _eflutil.wl.devmgr.request_notified = -1;
1979
1980    return ret;
1981 }
1982
1983 API int
1984 efl_util_input_generate_wheel(efl_util_inputgen_h inputgen_h, efl_util_input_pointer_wheel_type_e wheel_type, int value)
1985 {
1986    int ret, version;
1987    enum tizen_input_device_manager_pointer_event_type type;
1988
1989    EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1990    EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1991
1992    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1993    version = tizen_input_device_manager_get_version(_eflutil.wl.devmgr.devicemgr);
1994    EINA_SAFETY_ON_FALSE_RETURN_VAL((version >= 3), EFL_UTIL_ERROR_NOT_SUPPORTED);
1995
1996    switch(wheel_type)
1997      {
1998         case EFL_UTIL_INPUT_POINTER_WHEEL_VERT:
1999            type = TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_WHEEL;
2000            break;
2001         case EFL_UTIL_INPUT_POINTER_WHEEL_HORZ:
2002            type = TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_HWHEEL;
2003            break;
2004         default:
2005            return EFL_UTIL_ERROR_INVALID_PARAMETER;
2006      }
2007
2008    tizen_input_device_manager_generate_axis(_eflutil.wl.devmgr.devicemgr, type, wl_fixed_from_int(value));
2009
2010    while (_eflutil.wl.devmgr.request_notified == -1)
2011      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2012
2013    ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
2014    _eflutil.wl.devmgr.request_notified = -1;
2015
2016    return ret;
2017 }
2018
2019
2020
2021 struct _efl_util_screenshot_h
2022 {
2023    int width;
2024    int height;
2025
2026    Eina_Bool shot_done;
2027
2028    /* tbm bufmgr */
2029    tbm_bufmgr bufmgr;
2030
2031    Eina_Bool auto_rotation;
2032 };
2033
2034 /* scrrenshot handle */
2035 static efl_util_screenshot_h g_screenshot;
2036 static Eina_Bool shot_mutex_init;
2037 static pthread_mutex_t shot_lock;
2038
2039 static Eina_Bool
2040 _screenshot_mutex_init(void)
2041 {
2042    if (shot_mutex_init)
2043      return EINA_TRUE;
2044
2045    if (pthread_mutex_init(&shot_lock, NULL))
2046      {
2047         fprintf(stderr, "[screenshot] fail: mutex init"); /*LCOV_EXCL_LINE*/
2048         return EINA_FALSE; /*LCOV_EXCL_LINE*/
2049      }
2050
2051    shot_mutex_init = EINA_TRUE;
2052
2053    return EINA_TRUE;
2054 }
2055
2056 static Eina_Bool
2057 _screenshot_mutex_destory(void)
2058 {
2059    if (!shot_mutex_init)
2060      return EINA_TRUE;
2061
2062    if (pthread_mutex_destroy(&shot_lock))
2063      {
2064         fprintf(stderr, "[screenshot] fail: mutex destory"); /*LCOV_EXCL_LINE*/
2065         return EINA_FALSE; /*LCOV_EXCL_LINE*/
2066      }
2067
2068    shot_mutex_init = EINA_FALSE;
2069
2070    return EINA_TRUE;
2071 }
2072
2073 void
2074 _screenshot_mutex_lock(void)
2075 {
2076    if (!_screenshot_mutex_init())
2077      return;
2078
2079    pthread_mutex_lock(&shot_lock);
2080 }
2081
2082 void
2083 _screenshot_mutex_unlock(void)
2084 {
2085    pthread_mutex_unlock(&shot_lock);
2086 }
2087
2088 API efl_util_screenshot_h
2089 efl_util_screenshot_initialize(int width, int height)
2090 {
2091    efl_util_screenshot_h screenshot = NULL;
2092    struct wl_display *display_wrapper = NULL;
2093    struct wl_registry *reg = NULL;
2094    int ret = 0;
2095
2096    if (width <= 0 || height <= 0)
2097      {
2098         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2099         return NULL;
2100      }
2101
2102    _screenshot_mutex_lock();
2103
2104    if (!g_screenshot)
2105      {
2106         screenshot = calloc(1, sizeof(struct _efl_util_screenshot_h));
2107         EINA_SAFETY_ON_NULL_GOTO(screenshot, fail_memory);
2108      }
2109
2110    if (!_eflutil.wl.shot.screenshooter)
2111      {
2112         ret = _wl_init();
2113         if (ret == (int)EINA_FALSE)
2114           {
2115              set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2116              _screenshot_mutex_unlock();
2117              if (screenshot)
2118                 free(screenshot);
2119              return NULL;
2120           }
2121         wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2122
2123         display_wrapper = wl_proxy_create_wrapper(_eflutil.wl.dpy);
2124         EINA_SAFETY_ON_NULL_GOTO(display_wrapper, fail_memory);
2125
2126         _eflutil.wl.shot.queue = wl_display_create_queue(_eflutil.wl.dpy);
2127         EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.queue, fail_memory);
2128
2129         wl_proxy_set_queue((struct wl_proxy *)display_wrapper, _eflutil.wl.shot.queue);
2130
2131         reg = wl_display_get_registry(display_wrapper);
2132         wl_proxy_wrapper_destroy(display_wrapper);
2133         display_wrapper = NULL;
2134         EINA_SAFETY_ON_NULL_GOTO(reg, fail_init);
2135
2136         wl_registry_add_listener(reg, &_wl_reg_screenshooter_listener, NULL);
2137
2138         ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
2139         EINA_SAFETY_ON_TRUE_GOTO(ret == -1, fail_init);
2140         EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.screenshooter, fail_init);
2141         EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tz_screenshooter, fail_init);
2142
2143         _eflutil.wl.shot.tbm_client = wayland_tbm_client_init(_eflutil.wl.dpy);
2144         EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tbm_client, fail_init);
2145
2146         wl_registry_destroy(reg);
2147         reg = NULL;
2148      }
2149
2150    if (_eflutil.wl.shot.noti == 0)
2151      {
2152         fprintf(stderr, "[screenshot] fail: privilege error\n"); /* LCOV_EXCL_LINE */
2153         goto fail_init;
2154      }
2155
2156    if (g_screenshot)
2157      {
2158         if (g_screenshot->width != width || g_screenshot->height != height)
2159           {
2160              g_screenshot->width = width;
2161              g_screenshot->height = height;
2162           }
2163         set_last_result(EFL_UTIL_ERROR_NONE);
2164
2165         _screenshot_mutex_unlock();
2166
2167         return g_screenshot;
2168      }
2169
2170    screenshot->width = width;
2171    screenshot->height = height;
2172    screenshot->auto_rotation = EINA_TRUE;
2173
2174    screenshot->bufmgr = wayland_tbm_client_get_bufmgr(_eflutil.wl.shot.tbm_client);
2175    EINA_SAFETY_ON_NULL_GOTO(screenshot->bufmgr, fail_init);
2176
2177    g_screenshot = screenshot;
2178    set_last_result(EFL_UTIL_ERROR_NONE);
2179
2180    screenshooter_set_user_data(_eflutil.wl.shot.screenshooter, &screenshot->shot_done);
2181
2182    _screenshot_mutex_unlock();
2183
2184    return g_screenshot;
2185
2186 /* LCOV_EXCL_START */
2187 fail_memory:
2188    if (display_wrapper)
2189      wl_proxy_wrapper_destroy(display_wrapper);
2190    set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
2191    if (screenshot)
2192      free(screenshot);
2193    _screenshot_mutex_unlock();
2194    return NULL;
2195
2196 fail_init:
2197    if (reg)
2198      wl_registry_destroy(reg);
2199    if (screenshot)
2200      {
2201         _screenshot_mutex_unlock();
2202         efl_util_screenshot_deinitialize(screenshot);
2203      }
2204    if (_eflutil.wl.shot.noti == 0)
2205      set_last_result(EFL_UTIL_ERROR_PERMISSION_DENIED);
2206    else
2207      set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL);
2208    return NULL;
2209 /* LCOV_EXCL_STOP */
2210 }
2211
2212 API int
2213 efl_util_screenshot_deinitialize(efl_util_screenshot_h screenshot)
2214 {
2215    _screenshot_mutex_lock();
2216
2217    if (!screenshot)
2218      {
2219         _screenshot_mutex_unlock();
2220         _screenshot_mutex_destory();
2221         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2222      }
2223
2224    free(screenshot);
2225    g_screenshot = NULL;
2226
2227    if (_eflutil.wl.shot.tbm_client)
2228      {
2229         wayland_tbm_client_deinit(_eflutil.wl.shot.tbm_client);
2230         _eflutil.wl.shot.tbm_client = NULL;
2231      }
2232
2233    if (_eflutil.wl.shot.screenshooter)
2234      {
2235         screenshooter_destroy(_eflutil.wl.shot.screenshooter);
2236         _eflutil.wl.shot.screenshooter = NULL;
2237      }
2238    if (_eflutil.wl.shot.tz_screenshooter)
2239      {
2240         tizen_screenshooter_destroy(_eflutil.wl.shot.tz_screenshooter);
2241         _eflutil.wl.shot.tz_screenshooter = NULL;
2242      }
2243
2244    if (_eflutil.wl.shot.queue)
2245      {
2246         wl_event_queue_destroy(_eflutil.wl.shot.queue);
2247         _eflutil.wl.shot.queue = NULL;
2248      }
2249
2250    _screenshot_mutex_unlock();
2251    _screenshot_mutex_destory();
2252
2253    return EFL_UTIL_ERROR_NONE;
2254 }
2255
2256
2257 API tbm_surface_h
2258 efl_util_screenshot_take_tbm_surface(efl_util_screenshot_h screenshot)
2259 {
2260    tbm_surface_h t_surface = NULL;
2261    struct wl_buffer *buffer = NULL;
2262    Efl_Util_Wl_Output_Info *output;
2263    int ret = 0;
2264
2265    _screenshot_mutex_lock();
2266
2267    if (!screenshot || (screenshot != g_screenshot))
2268      {
2269         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2270         _screenshot_mutex_unlock();
2271         return NULL;
2272      }
2273
2274    output = eina_list_nth(_eflutil.wl.shot.output_list, 0);
2275    if (!output)
2276      {
2277         fprintf(stderr, "[screenshot] fail: no output for screenshot\n"); /* LCOV_EXCL_LINE */
2278         goto fail;
2279      }
2280
2281    t_surface = tbm_surface_create(screenshot->width, screenshot->height, TBM_FORMAT_XRGB8888);
2282    if (!t_surface)
2283      {
2284         fprintf(stderr, "[screenshot] fail: tbm_surface_create\n"); /* LCOV_EXCL_LINE */
2285         goto fail;
2286      }
2287
2288    buffer = wayland_tbm_client_create_buffer(_eflutil.wl.shot.tbm_client, t_surface);
2289    if (!buffer)
2290      {
2291         fprintf(stderr, "[screenshot] fail: create wl_buffer for screenshot\n"); /* LCOV_EXCL_LINE */
2292         goto fail;
2293      }
2294
2295    screenshooter_shoot(_eflutil.wl.shot.screenshooter, output->output, buffer);
2296
2297    screenshot->shot_done = EINA_FALSE;
2298    while (!screenshot->shot_done && ret != -1)
2299      ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
2300
2301    if (ret == -1)
2302      {
2303         fprintf(stderr, "[screenshot] fail: screenshooter_shoot\n"); /* LCOV_EXCL_LINE */
2304         goto fail;
2305      }
2306
2307    wayland_tbm_client_destroy_buffer(_eflutil.wl.shot.tbm_client, buffer);
2308
2309    /* reset shot_done for next screenshot */
2310    screenshot->shot_done = EINA_FALSE;
2311
2312    set_last_result(EFL_UTIL_ERROR_NONE);
2313
2314    _screenshot_mutex_unlock();
2315
2316    return t_surface;
2317
2318 fail:
2319    if (t_surface)
2320      tbm_surface_destroy(t_surface);
2321    if (buffer)
2322      wayland_tbm_client_destroy_buffer(_eflutil.wl.shot.tbm_client, buffer);
2323
2324    set_last_result(EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL);
2325
2326    _screenshot_mutex_unlock();
2327
2328    return NULL;
2329 }
2330
2331 API int
2332 efl_util_screenshot_set_auto_rotation(efl_util_screenshot_h screenshot, int set)
2333 {
2334    if (!screenshot || (screenshot != g_screenshot))
2335      return EFL_UTIL_ERROR_INVALID_PARAMETER;
2336
2337    if (!(set == 0 || set == 1))
2338      return EFL_UTIL_ERROR_INVALID_PARAMETER;
2339
2340    if (set)
2341      g_screenshot->auto_rotation = EINA_TRUE;
2342    else
2343      g_screenshot->auto_rotation = EINA_FALSE;
2344
2345    tizen_screenshooter_set_oneshot_auto_rotation(_eflutil.wl.shot.tz_screenshooter, g_screenshot->auto_rotation);
2346
2347    return EFL_UTIL_ERROR_NONE;
2348 }
2349
2350 API int
2351 efl_util_screenshot_get_auto_rotation(efl_util_screenshot_h screenshot, int *set)
2352 {
2353    if (!screenshot || (screenshot != g_screenshot) || !set)
2354      return EFL_UTIL_ERROR_INVALID_PARAMETER;
2355
2356    *set = g_screenshot->auto_rotation;
2357
2358    return EFL_UTIL_ERROR_NONE;
2359 }
2360
2361 struct _efl_util_gesture_h
2362 {
2363    Eina_Bool init;
2364 };
2365
2366 API int EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = 0;
2367 API int EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = 0;
2368 API int EFL_UTIL_EVENT_GESTURE_TAP = 0;
2369 API int EFL_UTIL_EVENT_GESTURE_PALM_COVER = 0;
2370
2371 /* LCOV_EXCL_START */
2372 static void
2373 _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)
2374 {
2375    _eflutil_defaultqueue.wl.gesture.request_notified = error;
2376 }
2377
2378 static void
2379 _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)
2380 {
2381    efl_util_event_gesture_edge_swipe_s *ev = NULL;
2382
2383    ev = (efl_util_event_gesture_edge_swipe_s *)calloc(1, sizeof(*ev));
2384    if (!ev) return;
2385
2386    ev->mode = mode;
2387
2388    ev->fingers = fingers;
2389    ev->sx = sx;
2390    ev->sy = sy;
2391    ev->edge = edge;
2392
2393    ecore_event_add(EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE, ev, NULL, NULL);
2394 }
2395
2396 static void
2397 _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)
2398 {
2399    _eflutil_defaultqueue.wl.gesture.request_notified = error;
2400 }
2401
2402 static void
2403 _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)
2404 {
2405    efl_util_event_gesture_edge_drag_s *ev = NULL;
2406
2407    ev = (efl_util_event_gesture_edge_drag_s *)calloc(1, sizeof(*ev));
2408    if (!ev) return;
2409
2410    ev->mode = mode;
2411
2412    ev->fingers = fingers;
2413    ev->cx = cx;
2414    ev->cy = cy;
2415    ev->edge = edge;
2416
2417    ecore_event_add(EFL_UTIL_EVENT_GESTURE_EDGE_DRAG, ev, NULL, NULL);
2418 }
2419
2420 static void
2421 _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)
2422 {
2423    _eflutil_defaultqueue.wl.gesture.request_notified = error;
2424 }
2425
2426 static void
2427 _cb_gesture_tap(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t mode, uint32_t fingers, uint32_t repeats)
2428 {
2429    efl_util_event_gesture_tap_s *ev = NULL;
2430
2431    ev = (efl_util_event_gesture_tap_s *)calloc(1, sizeof(*ev));
2432    if (!ev) return;
2433
2434    ev->mode = mode;
2435
2436    ev->fingers = fingers;
2437    ev->repeats = repeats;
2438
2439    ecore_event_add(EFL_UTIL_EVENT_GESTURE_TAP, ev, NULL, NULL);
2440 }
2441 /* LCOV_EXCL_STOP */
2442
2443 static void
2444 _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)
2445 {
2446    _eflutil_defaultqueue.wl.gesture.request_notified = error;
2447 }
2448
2449 /* LCOV_EXCL_START */
2450 static void
2451 _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)
2452 {
2453    efl_util_event_gesture_palm_cover_s *ev = NULL;
2454
2455    ev = (efl_util_event_gesture_palm_cover_s *)calloc(1, sizeof(*ev));
2456    if (!ev) return;
2457
2458    ev->mode = mode;
2459
2460    ev->duration = duration;
2461    ev->cx = cx;
2462    ev->cy = cy;
2463    ev->size = size;
2464    ev->pressure = wl_fixed_to_int(pressure);
2465
2466    ecore_event_add(EFL_UTIL_EVENT_GESTURE_PALM_COVER, ev, NULL, NULL);
2467 }
2468 /* LCOV_EXCL_STOP */
2469
2470 static void
2471 _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)
2472 {
2473    _eflutil_defaultqueue.wl.gesture.request_notified = error;
2474 }
2475
2476 static efl_util_error_e
2477 _efl_util_gesture_convert_error(int ret)
2478 {
2479    switch (ret)
2480      {
2481         case TIZEN_GESTURE_ERROR_NONE:
2482            return EFL_UTIL_ERROR_NONE;
2483         case TIZEN_GESTURE_ERROR_INVALID_DATA:
2484            return EFL_UTIL_ERROR_INVALID_PARAMETER;
2485         case TIZEN_GESTURE_ERROR_NO_PERMISSION:
2486            return EFL_UTIL_ERROR_PERMISSION_DENIED;
2487         case TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES:
2488            return EFL_UTIL_ERROR_OUT_OF_MEMORY;
2489         case TIZEN_GESTURE_ERROR_GRABBED_ALREADY:
2490            return EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE;
2491         case TIZEN_GESTURE_ERROR_NOT_SUPPORTED:
2492            return EFL_UTIL_ERROR_NOT_SUPPORTED;
2493         default :
2494            return EFL_UTIL_ERROR_NONE;
2495      }
2496 }
2497
2498 /* LCOV_EXCL_START */
2499 static int
2500 _efl_util_gesture_grab_edge_swipe(efl_util_gesture_data data)
2501 {
2502    int ret = EFL_UTIL_ERROR_NONE;
2503    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2504    Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = NULL;
2505    unsigned int fingers = 0;
2506    unsigned int edge = 0;
2507    unsigned int edge_size = 0;
2508    unsigned int start_point = 0;
2509    unsigned int end_point = 0;
2510
2511    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2512
2513    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2514    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2515    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_SWIPE,
2516                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2517
2518    edge_swipe_data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)data;
2519
2520    fingers = edge_swipe_data->fingers;
2521    edge = edge_swipe_data->edge;
2522    edge_size = edge_swipe_data->edge_size;
2523    start_point = edge_swipe_data->start_point;
2524    end_point = edge_swipe_data->end_point;
2525
2526    tizen_gesture_grab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2527
2528    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2529      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2530
2531    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2532    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2533
2534    return ret;
2535 }
2536
2537 static int
2538 _efl_util_gesture_ungrab_edge_swipe(efl_util_gesture_data data)
2539 {
2540    int ret = EFL_UTIL_ERROR_NONE;
2541    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2542    Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = NULL;
2543    unsigned int fingers = 0;
2544    unsigned int edge = 0;
2545    unsigned int edge_size = 0;
2546    unsigned int start_point = 0;
2547    unsigned int end_point = 0;
2548
2549    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2550
2551    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2552    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2553    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_SWIPE,
2554                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2555
2556    edge_swipe_data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)data;
2557
2558    fingers = edge_swipe_data->fingers;
2559    edge = edge_swipe_data->edge;
2560    edge_size = edge_swipe_data->edge_size;
2561    start_point = edge_swipe_data->start_point;
2562    end_point = edge_swipe_data->end_point;
2563
2564    tizen_gesture_ungrab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2565
2566    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2567      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2568
2569    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2570    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2571
2572    return ret;
2573 }
2574
2575 static int
2576 _efl_util_gesture_grab_edge_drag(efl_util_gesture_data data)
2577 {
2578    int ret = EFL_UTIL_ERROR_NONE;
2579    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2580    Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = NULL;
2581    unsigned int fingers = 0;
2582    unsigned int edge = 0;
2583    unsigned int edge_size = 0;
2584    unsigned int start_point = 0;
2585    unsigned int end_point = 0;
2586
2587    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2588
2589    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2590    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2591    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_DRAG,
2592                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2593
2594    edge_drag_data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)data;
2595
2596    fingers = edge_drag_data->fingers;
2597    edge = edge_drag_data->edge;
2598    edge_size = edge_drag_data->edge_size;
2599    start_point = edge_drag_data->start_point;
2600    end_point = edge_drag_data->end_point;
2601
2602    tizen_gesture_grab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2603
2604    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2605      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2606
2607    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2608    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2609
2610    return ret;
2611 }
2612
2613 static int
2614 _efl_util_gesture_ungrab_edge_drag(efl_util_gesture_data data)
2615 {
2616    int ret = EFL_UTIL_ERROR_NONE;
2617    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2618    Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = NULL;
2619    unsigned int fingers = 0;
2620    unsigned int edge = 0;
2621    unsigned int edge_size = 0;
2622    unsigned int start_point = 0;
2623    unsigned int end_point = 0;
2624
2625    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2626
2627    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2628    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2629    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_DRAG,
2630                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2631
2632    edge_drag_data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)data;
2633
2634    fingers = edge_drag_data->fingers;
2635    edge = edge_drag_data->edge;
2636    edge_size = edge_drag_data->edge_size;
2637    start_point = edge_drag_data->start_point;
2638    end_point = edge_drag_data->end_point;
2639
2640    tizen_gesture_ungrab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2641
2642    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2643      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2644
2645    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2646    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2647
2648    return ret;
2649 }
2650
2651
2652 static int
2653 _efl_util_gesture_grab_tap(efl_util_gesture_data data)
2654 {
2655    int ret = EFL_UTIL_ERROR_NONE;
2656    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2657    Efl_Util_Gesture_Tap_Grab_Data *tap_data = NULL;
2658    unsigned int fingers = 0;
2659    unsigned int repeats = 0;
2660
2661    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2662
2663    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2664    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2665    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_TAP,
2666                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2667
2668    tap_data = (Efl_Util_Gesture_Tap_Grab_Data *)data;
2669
2670    fingers = tap_data->fingers;
2671    repeats = tap_data->repeats;
2672
2673    tizen_gesture_grab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats);
2674
2675    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2676      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2677
2678    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2679    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2680
2681    return ret;
2682 }
2683
2684 static int
2685 _efl_util_gesture_ungrab_tap(efl_util_gesture_data data)
2686 {
2687    int ret = EFL_UTIL_ERROR_NONE;
2688    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2689    Efl_Util_Gesture_Tap_Grab_Data *tap_data = NULL;
2690    unsigned int fingers = 0;
2691    unsigned int repeats = 0;
2692
2693    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2694
2695    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2696    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2697    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_TAP,
2698                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2699
2700    tap_data = (Efl_Util_Gesture_Tap_Grab_Data *)data;
2701
2702    fingers = tap_data->fingers;
2703    repeats = tap_data->repeats;
2704
2705    tizen_gesture_ungrab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats);
2706
2707    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2708      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2709
2710    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2711    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2712
2713    return ret;
2714 }
2715
2716 static int
2717 _efl_util_gesture_grab_palm_cover(efl_util_gesture_data data)
2718 {
2719    int ret = EFL_UTIL_ERROR_NONE;
2720    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2721
2722    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2723
2724    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2725    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2726    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_PALM_COVER,
2727                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2728
2729    tizen_gesture_grab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto);
2730
2731    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2732      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2733
2734    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2735    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2736
2737    return ret;
2738 }
2739
2740 static int
2741 _efl_util_gesture_ungrab_palm_cover(efl_util_gesture_data data)
2742 {
2743    int ret = EFL_UTIL_ERROR_NONE;
2744    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2745
2746    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2747
2748    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2749    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2750    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_PALM_COVER,
2751                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2752
2753    tizen_gesture_ungrab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto);
2754
2755    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2756      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2757
2758    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2759    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2760
2761    return ret;
2762 }
2763 /* LCOV_EXCL_STOP */
2764
2765 API efl_util_gesture_h
2766 efl_util_gesture_initialize(void)
2767 {
2768    efl_util_gesture_h gesture_h = NULL;
2769
2770    gesture_h = (efl_util_gesture_h)calloc(1, sizeof(struct _efl_util_gesture_h));
2771    if (!gesture_h)
2772      {
2773         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
2774         goto out; /* LCOV_EXCL_LINE */
2775      }
2776
2777    if (_wl_init_default_queue() == (int)EINA_FALSE)
2778      {
2779         set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED); /* LCOV_EXCL_LINE */
2780         goto out; /* LCOV_EXCL_LINE */
2781      }
2782
2783    while (!_eflutil_defaultqueue.wl.gesture.proto)
2784      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); /* LCOV_EXCL_LINE */
2785
2786    if (_eflutil_defaultqueue.wl.gesture.event_init <= 0)
2787      {
2788         if (ecore_event_init() <= 0)
2789           {
2790              set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED); /* LCOV_EXCL_LINE */
2791              goto out; /* LCOV_EXCL_LINE */
2792           }
2793         EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = ecore_event_type_new();
2794         EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = ecore_event_type_new();
2795         EFL_UTIL_EVENT_GESTURE_TAP = ecore_event_type_new();
2796         EFL_UTIL_EVENT_GESTURE_PALM_COVER = ecore_event_type_new();
2797      }
2798    _eflutil_defaultqueue.wl.gesture.event_init++;
2799    gesture_h->init = EINA_TRUE;
2800
2801    set_last_result(EFL_UTIL_ERROR_NONE);
2802    return gesture_h;
2803
2804 out:
2805 /* LCOV_EXCL_START */
2806    if (gesture_h)
2807      {
2808         free(gesture_h);
2809         gesture_h = NULL;
2810      }
2811    return gesture_h;
2812 /* LCOV_EXCL_STOP */
2813 }
2814
2815 API int
2816 efl_util_gesture_deinitialize(efl_util_gesture_h gesture_h)
2817 {
2818    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
2819    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
2820
2821    free(gesture_h);
2822    gesture_h = NULL;
2823
2824    _eflutil_defaultqueue.wl.gesture.event_init--;
2825
2826    if (_eflutil_defaultqueue.wl.gesture.event_init <= 0)
2827      {
2828         _eflutil_defaultqueue.wl.gesture.event_init = 0;
2829         ecore_event_shutdown();
2830         EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = 0;
2831         EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = 0;
2832         EFL_UTIL_EVENT_GESTURE_TAP = 0;
2833         EFL_UTIL_EVENT_GESTURE_PALM_COVER = 0;
2834      }
2835
2836    return EFL_UTIL_ERROR_NONE;
2837 }
2838
2839 API efl_util_gesture_data
2840 efl_util_gesture_edge_swipe_new(efl_util_gesture_h gesture_h, unsigned int fingers, efl_util_gesture_edge_e edge)
2841 {
2842    Efl_Util_Gesture_Edge_Swipe_Grab_Data *data;
2843
2844    if (!gesture_h || gesture_h->init == EINA_FALSE)
2845      {
2846         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2847         return NULL;
2848      }
2849
2850    if (edge <= EFL_UTIL_GESTURE_EDGE_NONE || edge > EFL_UTIL_GESTURE_EDGE_LEFT)
2851      {
2852         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2853         return NULL;
2854      }
2855
2856    data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Edge_Swipe_Grab_Data));
2857    if (!data)
2858      {
2859         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
2860         return NULL; /* LCOV_EXCL_LINE */
2861      }
2862
2863    data->base.type = TIZEN_GESTURE_TYPE_EDGE_SWIPE;
2864    data->fingers = fingers;
2865    data->edge = edge;
2866    data->edge_size = EFL_UTIL_GESTURE_EDGE_SIZE_FULL;
2867
2868    set_last_result(EFL_UTIL_ERROR_NONE);
2869
2870    return (void *)data;
2871 }
2872
2873 API int
2874 efl_util_gesture_edge_swipe_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
2875 {
2876    if (!gesture_h || gesture_h->init == EINA_FALSE)
2877      {
2878         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2879      }
2880
2881    if (!data)
2882      {
2883         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2884      }
2885
2886    free(data);
2887    data = NULL;
2888
2889    return EFL_UTIL_ERROR_NONE;
2890 }
2891
2892 API int
2893 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)
2894 {
2895    Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = data;
2896
2897    EINA_SAFETY_ON_NULL_RETURN_VAL(edge_swipe_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2898    EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_swipe_data->base.type == TIZEN_GESTURE_TYPE_EDGE_SWIPE,
2899                                    EFL_UTIL_ERROR_INVALID_PARAMETER);
2900    EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_size == EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL,
2901                                    EFL_UTIL_ERROR_INVALID_PARAMETER);
2902    EINA_SAFETY_ON_FALSE_RETURN_VAL(end_point > start_point, EFL_UTIL_ERROR_INVALID_PARAMETER);
2903
2904    edge_swipe_data->edge_size = edge_size;
2905    edge_swipe_data->start_point = start_point;
2906    edge_swipe_data->end_point = end_point;
2907
2908    return EFL_UTIL_ERROR_NONE;
2909 }
2910
2911 API efl_util_gesture_data
2912 efl_util_gesture_edge_drag_new(efl_util_gesture_h gesture_h, unsigned int fingers, efl_util_gesture_edge_e edge)
2913 {
2914    Efl_Util_Gesture_Edge_Drag_Grab_Data *data;
2915
2916    if (!gesture_h || gesture_h->init == EINA_FALSE)
2917      {
2918         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2919         return NULL;
2920      }
2921
2922    if (edge <= EFL_UTIL_GESTURE_EDGE_NONE || edge > EFL_UTIL_GESTURE_EDGE_LEFT)
2923      {
2924         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2925         return NULL;
2926      }
2927
2928    data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Edge_Drag_Grab_Data));
2929    if (!data)
2930      {
2931         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
2932         return NULL; /* LCOV_EXCL_LINE */
2933      }
2934
2935    data->base.type = TIZEN_GESTURE_TYPE_EDGE_DRAG;
2936    data->fingers = fingers;
2937    data->edge = edge;
2938    data->edge_size = EFL_UTIL_GESTURE_EDGE_SIZE_FULL;
2939
2940    set_last_result(EFL_UTIL_ERROR_NONE);
2941
2942    return (void *)data;
2943 }
2944
2945 API int
2946 efl_util_gesture_edge_drag_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
2947 {
2948    if (!gesture_h || gesture_h->init == EINA_FALSE)
2949      {
2950         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2951      }
2952
2953    if (!data)
2954      {
2955         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2956      }
2957
2958    free(data);
2959    data = NULL;
2960
2961    return EFL_UTIL_ERROR_NONE;
2962 }
2963
2964 API int
2965 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)
2966 {
2967    Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = data;
2968
2969    EINA_SAFETY_ON_NULL_RETURN_VAL(edge_drag_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2970    EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_drag_data->base.type == TIZEN_GESTURE_TYPE_EDGE_DRAG,
2971                                    EFL_UTIL_ERROR_INVALID_PARAMETER);
2972    EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_size == EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL,
2973                                    EFL_UTIL_ERROR_INVALID_PARAMETER);
2974    EINA_SAFETY_ON_FALSE_RETURN_VAL(end_point > start_point, EFL_UTIL_ERROR_INVALID_PARAMETER);
2975
2976    edge_drag_data->edge_size = edge_size;
2977    edge_drag_data->start_point = start_point;
2978    edge_drag_data->end_point = end_point;
2979
2980    return EFL_UTIL_ERROR_NONE;
2981 }
2982
2983 API efl_util_gesture_data
2984 efl_util_gesture_tap_new(efl_util_gesture_h gesture_h, unsigned int fingers, unsigned int repeats)
2985 {
2986    Efl_Util_Gesture_Tap_Grab_Data *data;
2987
2988    if (!gesture_h || gesture_h->init == EINA_FALSE)
2989      {
2990         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2991         return NULL;
2992      }
2993
2994    if (fingers <= 1 || repeats <= 1)
2995      {
2996         set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED);
2997         return NULL;
2998      }
2999
3000    data = (Efl_Util_Gesture_Tap_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Tap_Grab_Data));
3001    if (!data)
3002      {
3003         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
3004         return NULL; /* LCOV_EXCL_LINE */
3005      }
3006
3007    data->base.type = TIZEN_GESTURE_TYPE_TAP;
3008    data->fingers = fingers;
3009    data->repeats = repeats;
3010
3011    set_last_result(EFL_UTIL_ERROR_NONE);
3012
3013    return (void *)data;
3014 }
3015
3016 API int
3017 efl_util_gesture_tap_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
3018 {
3019    if (!gesture_h || gesture_h->init == EINA_FALSE)
3020      {
3021         return EFL_UTIL_ERROR_INVALID_PARAMETER;
3022      }
3023
3024    if (!data)
3025      {
3026         return EFL_UTIL_ERROR_INVALID_PARAMETER;
3027      }
3028
3029    free(data);
3030    data = NULL;
3031
3032    return EFL_UTIL_ERROR_NONE;
3033 }
3034
3035 API efl_util_gesture_data
3036 efl_util_gesture_palm_cover_new(efl_util_gesture_h gesture_h)
3037 {
3038    Efl_Util_Gesture_Palm_Cover_Grab_Data *data;
3039
3040    if (!gesture_h || gesture_h->init == EINA_FALSE)
3041      {
3042         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
3043         return NULL;
3044      }
3045
3046    data = (Efl_Util_Gesture_Palm_Cover_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Palm_Cover_Grab_Data));
3047    if (!data)
3048      {
3049         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
3050         return NULL; /* LCOV_EXCL_LINE */
3051      }
3052
3053    data->base.type = TIZEN_GESTURE_TYPE_PALM_COVER;
3054
3055    set_last_result(EFL_UTIL_ERROR_NONE);
3056
3057    return (void *)data;
3058 }
3059
3060 API int
3061 efl_util_gesture_palm_cover_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
3062 {
3063    if (!gesture_h || gesture_h->init == EINA_FALSE)
3064      {
3065         return EFL_UTIL_ERROR_INVALID_PARAMETER;
3066      }
3067
3068    if (!data)
3069      {
3070         return EFL_UTIL_ERROR_INVALID_PARAMETER;
3071      }
3072
3073    free(data);
3074    data = NULL;
3075
3076    return EFL_UTIL_ERROR_NONE;
3077 }
3078
3079 /* LCOV_EXCL_START */
3080 API int
3081 efl_util_gesture_grab(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
3082 {
3083    int ret = EFL_UTIL_ERROR_NONE;
3084    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
3085
3086    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
3087
3088    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3089    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3090    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
3091
3092    switch (base_data->type)
3093      {
3094         case TIZEN_GESTURE_TYPE_EDGE_SWIPE:
3095            ret = _efl_util_gesture_grab_edge_swipe(data);
3096            break;
3097         case TIZEN_GESTURE_TYPE_EDGE_DRAG:
3098            ret = _efl_util_gesture_grab_edge_drag(data);
3099            break;
3100         case TIZEN_GESTURE_TYPE_TAP:
3101            ret = _efl_util_gesture_grab_tap(data);
3102            break;
3103         case TIZEN_GESTURE_TYPE_PALM_COVER:
3104            ret = _efl_util_gesture_grab_palm_cover(data);
3105            break;
3106         default:
3107            return EFL_UTIL_ERROR_INVALID_PARAMETER;
3108      }
3109
3110    return ret;
3111 }
3112
3113 API int
3114 efl_util_gesture_ungrab(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
3115 {
3116    int ret = EFL_UTIL_ERROR_NONE;
3117    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
3118
3119    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
3120
3121    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3122    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3123    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
3124
3125    switch (base_data->type)
3126      {
3127         case TIZEN_GESTURE_TYPE_EDGE_SWIPE:
3128            ret = _efl_util_gesture_ungrab_edge_swipe(data);
3129            break;
3130         case TIZEN_GESTURE_TYPE_EDGE_DRAG:
3131            ret = _efl_util_gesture_ungrab_edge_drag(data);
3132            break;
3133         case TIZEN_GESTURE_TYPE_TAP:
3134            ret = _efl_util_gesture_ungrab_tap(data);
3135            break;
3136         case TIZEN_GESTURE_TYPE_PALM_COVER:
3137            ret = _efl_util_gesture_ungrab_palm_cover(data);
3138            break;
3139         default:
3140            return EFL_UTIL_ERROR_INVALID_PARAMETER;
3141      }
3142
3143    return ret;
3144 }
3145 /* LCOV_EXCL_STOP */
3146
3147 API int
3148 efl_util_gesture_select(efl_util_gesture_h gesture_h, Evas_Object *window, efl_util_gesture_data data)
3149 {
3150    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
3151    Ecore_Wl2_Window *wlwin;
3152    struct wl_surface *surface;
3153    int ret;
3154
3155    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
3156
3157    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3158    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3159    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
3160    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
3161
3162    if (base_data->type != TIZEN_GESTURE_TYPE_PALM_COVER)
3163      return EFL_UTIL_ERROR_NOT_SUPPORTED;
3164
3165    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
3166    if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
3167
3168    surface = ecore_wl2_window_surface_get(wlwin);
3169    EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
3170                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
3171
3172    tizen_gesture_select_palm_cover(_eflutil_defaultqueue.wl.gesture.proto, surface);
3173
3174    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
3175      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
3176
3177    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
3178    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
3179
3180    return ret;
3181 }
3182
3183 API int
3184 efl_util_gesture_deselect(efl_util_gesture_h gesture_h, Evas_Object *window, efl_util_gesture_data data)
3185 {
3186    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
3187    Ecore_Wl2_Window *wlwin;
3188    struct wl_surface *surface;
3189    int ret;
3190
3191    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
3192
3193    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3194    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3195    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
3196    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
3197
3198    if (base_data->type != TIZEN_GESTURE_TYPE_PALM_COVER)
3199      return EFL_UTIL_ERROR_NOT_SUPPORTED;
3200
3201    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
3202    if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
3203
3204    surface = ecore_wl2_window_surface_get(wlwin);
3205    EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
3206                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
3207
3208    tizen_gesture_deselect_palm_cover(_eflutil_defaultqueue.wl.gesture.proto, surface);
3209
3210    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
3211      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
3212
3213    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
3214    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
3215
3216    return ret;
3217 }
3218
3219 /* LCOV_EXCL_START */
3220 API int
3221 efl_util_gesture_activate_set(efl_util_gesture_h gesture_h, unsigned int type, Eina_Bool active)
3222 {
3223    int ret;
3224
3225    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3226    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3227    EINA_SAFETY_ON_TRUE_RETURN_VAL(type == EFL_UTIL_GESTURE_TYPE_NONE, EFL_UTIL_ERROR_INVALID_PARAMETER);
3228
3229    tizen_gesture_activate_set(_eflutil_defaultqueue.wl.gesture.proto, NULL, type, active);
3230
3231    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
3232      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
3233
3234    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
3235    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
3236
3237    return ret;
3238 }
3239 /* LCOV_EXCL_STOP */
3240
3241 API int
3242 efl_util_gesture_activate_set_on_window(efl_util_gesture_h gesture_h, Evas_Object *window, unsigned int type, Eina_Bool active)
3243 {
3244    Ecore_Wl2_Window *wlwin;
3245    struct wl_surface *surface;
3246    int ret;
3247
3248    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3249    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3250    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
3251    EINA_SAFETY_ON_TRUE_RETURN_VAL(type == EFL_UTIL_GESTURE_TYPE_NONE, EFL_UTIL_ERROR_INVALID_PARAMETER);
3252
3253    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
3254    if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
3255
3256    surface = ecore_wl2_window_surface_get(wlwin);
3257    EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
3258                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
3259
3260    tizen_gesture_activate_set(_eflutil_defaultqueue.wl.gesture.proto, surface, type, active);
3261
3262    while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
3263      wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
3264
3265    ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
3266    _eflutil_defaultqueue.wl.gesture.request_notified = -1;
3267
3268    return ret;
3269 }