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