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