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