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    if (width <= 0 || height <= 0)
1816      {
1817         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
1818         return NULL;
1819      }
1820
1821    _screenshot_mutex_lock();
1822
1823    if (!g_screenshot)
1824      {
1825         screenshot = calloc(1, sizeof(struct _efl_util_screenshot_h));
1826         EINA_SAFETY_ON_NULL_GOTO(screenshot, fail_memory);
1827      }
1828
1829    if (!_eflutil.wl.shot.screenshooter)
1830      {
1831         ret = _wl_init();
1832         if (ret == (int)EINA_FALSE)
1833           {
1834              set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
1835              _screenshot_mutex_unlock();
1836              return NULL;
1837           }
1838         wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1839
1840         display_wrapper = wl_proxy_create_wrapper(_eflutil.wl.dpy);
1841         EINA_SAFETY_ON_NULL_GOTO(display_wrapper, fail_memory);
1842
1843         _eflutil.wl.shot.queue = wl_display_create_queue(_eflutil.wl.dpy);
1844         EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.queue, fail_memory);
1845
1846         wl_proxy_set_queue((struct wl_proxy *)display_wrapper, _eflutil.wl.shot.queue);
1847
1848         reg = wl_display_get_registry(display_wrapper);
1849         wl_proxy_wrapper_destroy(display_wrapper);
1850         display_wrapper = NULL;
1851         EINA_SAFETY_ON_NULL_GOTO(reg, fail_init);
1852
1853         wl_registry_add_listener(reg, &_wl_reg_screenshooter_listener, NULL);
1854
1855         ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
1856         EINA_SAFETY_ON_TRUE_GOTO(ret == -1, fail_init);
1857         EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.screenshooter, fail_init);
1858         EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tz_screenshooter, fail_init);
1859
1860         _eflutil.wl.shot.tbm_client = wayland_tbm_client_init(_eflutil.wl.dpy);
1861         EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tbm_client, fail_init);
1862
1863         wl_registry_destroy(reg);
1864         reg = NULL;
1865      }
1866
1867    if (_eflutil.wl.shot.noti == 0)
1868      {
1869         fprintf(stderr, "[screenshot] fail: privilege error\n"); /* LCOV_EXCL_LINE */
1870         goto fail_init;
1871      }
1872
1873    if (g_screenshot)
1874      {
1875         if (g_screenshot->width != width || g_screenshot->height != height)
1876           {
1877              g_screenshot->width = width;
1878              g_screenshot->height = height;
1879           }
1880         set_last_result(EFL_UTIL_ERROR_NONE);
1881
1882         _screenshot_mutex_unlock();
1883
1884         return g_screenshot;
1885      }
1886
1887    screenshot->width = width;
1888    screenshot->height = height;
1889    screenshot->auto_rotation = EINA_TRUE;
1890
1891    screenshot->bufmgr = wayland_tbm_client_get_bufmgr(_eflutil.wl.shot.tbm_client);
1892    EINA_SAFETY_ON_NULL_GOTO(screenshot->bufmgr, fail_init);
1893
1894    g_screenshot = screenshot;
1895    set_last_result(EFL_UTIL_ERROR_NONE);
1896
1897    screenshooter_set_user_data(_eflutil.wl.shot.screenshooter, &screenshot->shot_done);
1898
1899    _screenshot_mutex_unlock();
1900
1901    return g_screenshot;
1902
1903 /* LCOV_EXCL_START */
1904 fail_memory:
1905    if (display_wrapper)
1906      wl_proxy_wrapper_destroy(display_wrapper);
1907    set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
1908    _screenshot_mutex_unlock();
1909    return NULL;
1910
1911 fail_init:
1912    if (reg)
1913      wl_registry_destroy(reg);
1914    if (screenshot)
1915      {
1916         _screenshot_mutex_unlock();
1917         efl_util_screenshot_deinitialize(screenshot);
1918      }
1919    set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL);
1920    return NULL;
1921 /* LCOV_EXCL_STOP */
1922 }
1923
1924 API int
1925 efl_util_screenshot_deinitialize(efl_util_screenshot_h screenshot)
1926 {
1927    _screenshot_mutex_lock();
1928
1929    if (!screenshot)
1930      {
1931         _screenshot_mutex_unlock();
1932         _screenshot_mutex_destory();
1933         return EFL_UTIL_ERROR_INVALID_PARAMETER;
1934      }
1935
1936    free(screenshot);
1937    g_screenshot = NULL;
1938
1939    if (_eflutil.wl.shot.tbm_client)
1940      {
1941         wayland_tbm_client_deinit(_eflutil.wl.shot.tbm_client);
1942         _eflutil.wl.shot.tbm_client = NULL;
1943      }
1944
1945    if (_eflutil.wl.shot.screenshooter)
1946      {
1947         screenshooter_destroy(_eflutil.wl.shot.screenshooter);
1948         _eflutil.wl.shot.screenshooter = NULL;
1949      }
1950    if (_eflutil.wl.shot.tz_screenshooter)
1951      {
1952         tizen_screenshooter_destroy(_eflutil.wl.shot.tz_screenshooter);
1953         _eflutil.wl.shot.tz_screenshooter = NULL;
1954      }
1955
1956    if (_eflutil.wl.shot.queue)
1957      {
1958         wl_event_queue_destroy(_eflutil.wl.shot.queue);
1959         _eflutil.wl.shot.queue = NULL;
1960      }
1961
1962    _screenshot_mutex_unlock();
1963    _screenshot_mutex_destory();
1964
1965    return EFL_UTIL_ERROR_NONE;
1966 }
1967
1968
1969 API tbm_surface_h
1970 efl_util_screenshot_take_tbm_surface(efl_util_screenshot_h screenshot)
1971 {
1972    tbm_surface_h t_surface = NULL;
1973    struct wl_buffer *buffer = NULL;
1974    Efl_Util_Wl_Output_Info *output;
1975    int ret = 0;
1976
1977    _screenshot_mutex_lock();
1978
1979    if (!screenshot || (screenshot != g_screenshot))
1980      {
1981         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
1982         _screenshot_mutex_unlock();
1983         return NULL;
1984      }
1985
1986    output = eina_list_nth(_eflutil.wl.shot.output_list, 0);
1987    if (!output)
1988      {
1989         fprintf(stderr, "[screenshot] fail: no output for screenshot\n"); /* LCOV_EXCL_LINE */
1990         goto fail;
1991      }
1992
1993    t_surface = tbm_surface_create(screenshot->width, screenshot->height, TBM_FORMAT_XRGB8888);
1994    if (!t_surface)
1995      {
1996         fprintf(stderr, "[screenshot] fail: tbm_surface_create\n"); /* LCOV_EXCL_LINE */
1997         goto fail;
1998      }
1999
2000    buffer = wayland_tbm_client_create_buffer(_eflutil.wl.shot.tbm_client, t_surface);
2001    if (!buffer)
2002      {
2003         fprintf(stderr, "[screenshot] fail: create wl_buffer for screenshot\n"); /* LCOV_EXCL_LINE */
2004         goto fail;
2005      }
2006
2007    screenshooter_shoot(_eflutil.wl.shot.screenshooter, output->output, buffer);
2008
2009    screenshot->shot_done = EINA_FALSE;
2010    while (!screenshot->shot_done && ret != -1)
2011      ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
2012
2013    if (ret == -1)
2014      {
2015         fprintf(stderr, "[screenshot] fail: screenshooter_shoot\n"); /* LCOV_EXCL_LINE */
2016         goto fail;
2017      }
2018
2019    wayland_tbm_client_destroy_buffer(_eflutil.wl.shot.tbm_client, buffer);
2020
2021    /* reset shot_done for next screenshot */
2022    screenshot->shot_done = EINA_FALSE;
2023
2024    set_last_result(EFL_UTIL_ERROR_NONE);
2025
2026    _screenshot_mutex_unlock();
2027
2028    return t_surface;
2029
2030 fail:
2031    if (t_surface)
2032      tbm_surface_destroy(t_surface);
2033    if (buffer)
2034      wayland_tbm_client_destroy_buffer(_eflutil.wl.shot.tbm_client, buffer);
2035
2036    set_last_result(EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL);
2037
2038    _screenshot_mutex_unlock();
2039
2040    return NULL;
2041 }
2042
2043 API int
2044 efl_util_screenshot_set_auto_rotation(efl_util_screenshot_h screenshot, int set)
2045 {
2046    if (!screenshot || (screenshot != g_screenshot))
2047      return EFL_UTIL_ERROR_INVALID_PARAMETER;
2048
2049    if (!(set == 0 || set == 1))
2050      return EFL_UTIL_ERROR_INVALID_PARAMETER;
2051
2052    if (set)
2053      g_screenshot->auto_rotation = EINA_TRUE;
2054    else
2055      g_screenshot->auto_rotation = EINA_FALSE;
2056
2057    tizen_screenshooter_set_oneshot_auto_rotation(_eflutil.wl.shot.tz_screenshooter, g_screenshot->auto_rotation);
2058
2059    return EFL_UTIL_ERROR_NONE;
2060 }
2061
2062 API int
2063 efl_util_screenshot_get_auto_rotation(efl_util_screenshot_h screenshot, int *set)
2064 {
2065    if (!screenshot || (screenshot != g_screenshot) || !set)
2066      return EFL_UTIL_ERROR_INVALID_PARAMETER;
2067
2068    *set = g_screenshot->auto_rotation;
2069
2070    return EFL_UTIL_ERROR_NONE;
2071 }
2072
2073 struct _efl_util_gesture_h
2074 {
2075    Eina_Bool init;
2076 };
2077
2078 API int EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = 0;
2079 API int EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = 0;
2080 API int EFL_UTIL_EVENT_GESTURE_TAP = 0;
2081 API int EFL_UTIL_EVENT_GESTURE_PALM_COVER = 0;
2082
2083 /* LCOV_EXCL_START */
2084 static void
2085 _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)
2086 {
2087    _eflutil.wl.gesture.request_notified = error;
2088 }
2089
2090 static void
2091 _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)
2092 {
2093    efl_util_event_gesture_edge_swipe_s *ev = NULL;
2094
2095    ev = (efl_util_event_gesture_edge_swipe_s *)calloc(1, sizeof(*ev));
2096    if (!ev) return;
2097
2098    ev->mode = mode;
2099
2100    ev->fingers = fingers;
2101    ev->sx = sx;
2102    ev->sy = sy;
2103    ev->edge = edge;
2104
2105    ecore_event_add(EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE, ev, NULL, NULL);
2106 }
2107
2108 static void
2109 _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)
2110 {
2111    _eflutil.wl.gesture.request_notified = error;
2112 }
2113
2114 static void
2115 _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)
2116 {
2117    efl_util_event_gesture_edge_drag_s *ev = NULL;
2118
2119    ev = (efl_util_event_gesture_edge_drag_s *)calloc(1, sizeof(*ev));
2120    if (!ev) return;
2121
2122    ev->mode = mode;
2123
2124    ev->fingers = fingers;
2125    ev->cx = cx;
2126    ev->cy = cy;
2127    ev->edge = edge;
2128
2129    ecore_event_add(EFL_UTIL_EVENT_GESTURE_EDGE_DRAG, ev, NULL, NULL);
2130 }
2131
2132 static void
2133 _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)
2134 {
2135    _eflutil.wl.gesture.request_notified = error;
2136 }
2137
2138 static void
2139 _cb_gesture_tap(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t mode, uint32_t fingers, uint32_t repeats)
2140 {
2141    efl_util_event_gesture_tap_s *ev = NULL;
2142
2143    ev = (efl_util_event_gesture_tap_s *)calloc(1, sizeof(*ev));
2144    if (!ev) return;
2145
2146    ev->mode = mode;
2147
2148    ev->fingers = fingers;
2149    ev->repeats = repeats;
2150
2151    ecore_event_add(EFL_UTIL_EVENT_GESTURE_TAP, ev, NULL, NULL);
2152 }
2153 /* LCOV_EXCL_STOP */
2154
2155 static void
2156 _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)
2157 {
2158    _eflutil.wl.gesture.request_notified = error;
2159 }
2160
2161 /* LCOV_EXCL_START */
2162 static void
2163 _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)
2164 {
2165    efl_util_event_gesture_palm_cover_s *ev = NULL;
2166
2167    ev = (efl_util_event_gesture_palm_cover_s *)calloc(1, sizeof(*ev));
2168    if (!ev) return;
2169
2170    ev->mode = mode;
2171
2172    ev->duration = duration;
2173    ev->cx = cx;
2174    ev->cy = cy;
2175    ev->size = size;
2176    ev->pressure = wl_fixed_to_int(pressure);
2177
2178    ecore_event_add(EFL_UTIL_EVENT_GESTURE_PALM_COVER, ev, NULL, NULL);
2179 }
2180 /* LCOV_EXCL_STOP */
2181
2182 static void
2183 _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)
2184 {
2185    _eflutil.wl.gesture.request_notified = error;
2186 }
2187
2188 static efl_util_error_e
2189 _efl_util_gesture_convert_error(int ret)
2190 {
2191    switch (ret)
2192      {
2193         case TIZEN_GESTURE_ERROR_NONE:
2194            return EFL_UTIL_ERROR_NONE;
2195         case TIZEN_GESTURE_ERROR_INVALID_DATA:
2196            return EFL_UTIL_ERROR_INVALID_PARAMETER;
2197         case TIZEN_GESTURE_ERROR_NO_PERMISSION:
2198            return EFL_UTIL_ERROR_PERMISSION_DENIED;
2199         case TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES:
2200            return EFL_UTIL_ERROR_OUT_OF_MEMORY;
2201         case TIZEN_GESTURE_ERROR_GRABBED_ALREADY:
2202            return EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE;
2203         case TIZEN_GESTURE_ERROR_NOT_SUPPORTED:
2204            return EFL_UTIL_ERROR_NOT_SUPPORTED;
2205         default :
2206            return EFL_UTIL_ERROR_NONE;
2207      }
2208 }
2209
2210 /* LCOV_EXCL_START */
2211 static int
2212 _efl_util_gesture_grab_edge_swipe(efl_util_gesture_data data)
2213 {
2214    int ret = EFL_UTIL_ERROR_NONE;
2215    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2216    Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = NULL;
2217    unsigned int fingers = 0;
2218    unsigned int edge = 0;
2219    unsigned int edge_size = 0;
2220    unsigned int start_point = 0;
2221    unsigned int end_point = 0;
2222
2223    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2224
2225    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2226    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2227    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_SWIPE,
2228                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2229
2230    edge_swipe_data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)data;
2231
2232    fingers = edge_swipe_data->fingers;
2233    edge = edge_swipe_data->edge;
2234    edge_size = edge_swipe_data->edge_size;
2235    start_point = edge_swipe_data->start_point;
2236    end_point = edge_swipe_data->end_point;
2237
2238    tizen_gesture_grab_edge_swipe(_eflutil.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2239
2240    while (_eflutil.wl.gesture.request_notified == -1)
2241      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2242
2243    ret = _efl_util_gesture_convert_error(_eflutil.wl.gesture.request_notified);
2244    _eflutil.wl.gesture.request_notified = -1;
2245
2246    return ret;
2247 }
2248
2249 static int
2250 _efl_util_gesture_ungrab_edge_swipe(efl_util_gesture_data data)
2251 {
2252    int ret = EFL_UTIL_ERROR_NONE;
2253    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2254    Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = NULL;
2255    unsigned int fingers = 0;
2256    unsigned int edge = 0;
2257    unsigned int edge_size = 0;
2258    unsigned int start_point = 0;
2259    unsigned int end_point = 0;
2260
2261    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2262
2263    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2264    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2265    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_SWIPE,
2266                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2267
2268    edge_swipe_data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)data;
2269
2270    fingers = edge_swipe_data->fingers;
2271    edge = edge_swipe_data->edge;
2272    edge_size = edge_swipe_data->edge_size;
2273    start_point = edge_swipe_data->start_point;
2274    end_point = edge_swipe_data->end_point;
2275
2276    tizen_gesture_ungrab_edge_swipe(_eflutil.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2277
2278    while (_eflutil.wl.gesture.request_notified == -1)
2279      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2280
2281    ret = _efl_util_gesture_convert_error(_eflutil.wl.gesture.request_notified);
2282    _eflutil.wl.gesture.request_notified = -1;
2283
2284    return ret;
2285 }
2286
2287 static int
2288 _efl_util_gesture_grab_edge_drag(efl_util_gesture_data data)
2289 {
2290    int ret = EFL_UTIL_ERROR_NONE;
2291    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2292    Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = NULL;
2293    unsigned int fingers = 0;
2294    unsigned int edge = 0;
2295    unsigned int edge_size = 0;
2296    unsigned int start_point = 0;
2297    unsigned int end_point = 0;
2298
2299    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2300
2301    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2302    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2303    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_DRAG,
2304                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2305
2306    edge_drag_data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)data;
2307
2308    fingers = edge_drag_data->fingers;
2309    edge = edge_drag_data->edge;
2310    edge_size = edge_drag_data->edge_size;
2311    start_point = edge_drag_data->start_point;
2312    end_point = edge_drag_data->end_point;
2313
2314    tizen_gesture_grab_edge_drag(_eflutil.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2315
2316    while (_eflutil.wl.gesture.request_notified == -1)
2317      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2318
2319    ret = _efl_util_gesture_convert_error(_eflutil.wl.gesture.request_notified);
2320    _eflutil.wl.gesture.request_notified = -1;
2321
2322    return ret;
2323 }
2324
2325 static int
2326 _efl_util_gesture_ungrab_edge_drag(efl_util_gesture_data data)
2327 {
2328    int ret = EFL_UTIL_ERROR_NONE;
2329    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2330    Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = NULL;
2331    unsigned int fingers = 0;
2332    unsigned int edge = 0;
2333    unsigned int edge_size = 0;
2334    unsigned int start_point = 0;
2335    unsigned int end_point = 0;
2336
2337    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2338
2339    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2340    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2341    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_DRAG,
2342                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2343
2344    edge_drag_data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)data;
2345
2346    fingers = edge_drag_data->fingers;
2347    edge = edge_drag_data->edge;
2348    edge_size = edge_drag_data->edge_size;
2349    start_point = edge_drag_data->start_point;
2350    end_point = edge_drag_data->end_point;
2351
2352    tizen_gesture_ungrab_edge_drag(_eflutil.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2353
2354    while (_eflutil.wl.gesture.request_notified == -1)
2355      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2356
2357    ret = _efl_util_gesture_convert_error(_eflutil.wl.gesture.request_notified);
2358    _eflutil.wl.gesture.request_notified = -1;
2359
2360    return ret;
2361 }
2362
2363
2364 static int
2365 _efl_util_gesture_grab_tap(efl_util_gesture_data data)
2366 {
2367    int ret = EFL_UTIL_ERROR_NONE;
2368    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2369    Efl_Util_Gesture_Tap_Grab_Data *tap_data = NULL;
2370    unsigned int fingers = 0;
2371    unsigned int repeats = 0;
2372
2373    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2374
2375    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2376    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2377    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_TAP,
2378                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2379
2380    tap_data = (Efl_Util_Gesture_Tap_Grab_Data *)data;
2381
2382    fingers = tap_data->fingers;
2383    repeats = tap_data->repeats;
2384
2385    tizen_gesture_grab_tap(_eflutil.wl.gesture.proto, fingers, repeats);
2386
2387    while (_eflutil.wl.gesture.request_notified == -1)
2388      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2389
2390    ret = _efl_util_gesture_convert_error(_eflutil.wl.gesture.request_notified);
2391    _eflutil.wl.gesture.request_notified = -1;
2392
2393    return ret;
2394 }
2395
2396 static int
2397 _efl_util_gesture_ungrab_tap(efl_util_gesture_data data)
2398 {
2399    int ret = EFL_UTIL_ERROR_NONE;
2400    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2401    Efl_Util_Gesture_Tap_Grab_Data *tap_data = NULL;
2402    unsigned int fingers = 0;
2403    unsigned int repeats = 0;
2404
2405    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2406
2407    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2408    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2409    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_TAP,
2410                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2411
2412    tap_data = (Efl_Util_Gesture_Tap_Grab_Data *)data;
2413
2414    fingers = tap_data->fingers;
2415    repeats = tap_data->repeats;
2416
2417    tizen_gesture_ungrab_tap(_eflutil.wl.gesture.proto, fingers, repeats);
2418
2419    while (_eflutil.wl.gesture.request_notified == -1)
2420      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2421
2422    ret = _efl_util_gesture_convert_error(_eflutil.wl.gesture.request_notified);
2423    _eflutil.wl.gesture.request_notified = -1;
2424
2425    return ret;
2426 }
2427
2428 static int
2429 _efl_util_gesture_grab_palm_cover(efl_util_gesture_data data)
2430 {
2431    int ret = EFL_UTIL_ERROR_NONE;
2432    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2433
2434    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2435
2436    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2437    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2438    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_PALM_COVER,
2439                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2440
2441    tizen_gesture_grab_palm_cover(_eflutil.wl.gesture.proto);
2442
2443    while (_eflutil.wl.gesture.request_notified == -1)
2444      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2445
2446    ret = _efl_util_gesture_convert_error(_eflutil.wl.gesture.request_notified);
2447    _eflutil.wl.gesture.request_notified = -1;
2448
2449    return ret;
2450 }
2451
2452 static int
2453 _efl_util_gesture_ungrab_palm_cover(efl_util_gesture_data data)
2454 {
2455    int ret = EFL_UTIL_ERROR_NONE;
2456    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2457
2458    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2459
2460    EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2461    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2462    EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_PALM_COVER,
2463                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2464
2465    tizen_gesture_ungrab_palm_cover(_eflutil.wl.gesture.proto);
2466
2467    while (_eflutil.wl.gesture.request_notified == -1)
2468      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2469
2470    ret = _efl_util_gesture_convert_error(_eflutil.wl.gesture.request_notified);
2471    _eflutil.wl.gesture.request_notified = -1;
2472
2473    return ret;
2474 }
2475
2476 static Eina_Bool
2477 _efl_util_fd_cb(void *data, Ecore_Fd_Handler *hdl)
2478 {
2479    if (_eflutil.wl.dpy && _eflutil.wl.queue)
2480      {
2481         wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2482         return ECORE_CALLBACK_RENEW;
2483      }
2484    else
2485      {
2486         return ECORE_CALLBACK_CANCEL;
2487      }
2488 }
2489 /* LCOV_EXCL_STOP */
2490
2491 API efl_util_gesture_h
2492 efl_util_gesture_initialize(void)
2493 {
2494    efl_util_gesture_h gesture_h = NULL;
2495    int dpy_fd = -1;
2496
2497    gesture_h = (efl_util_gesture_h)calloc(1, sizeof(struct _efl_util_gesture_h));
2498    if (!gesture_h)
2499      {
2500         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
2501         goto out; /* LCOV_EXCL_LINE */
2502      }
2503
2504    if (_wl_init() == (int)EINA_FALSE)
2505      {
2506         set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED); /* LCOV_EXCL_LINE */
2507         goto out; /* LCOV_EXCL_LINE */
2508      }
2509
2510    while (!_eflutil.wl.gesture.proto)
2511      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); /* LCOV_EXCL_LINE */
2512
2513    if (_eflutil.wl.gesture.event_init <= 0)
2514      {
2515         if (ecore_event_init() <= 0)
2516           {
2517              set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED); /* LCOV_EXCL_LINE */
2518              goto out; /* LCOV_EXCL_LINE */
2519           }
2520         EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = ecore_event_type_new();
2521         EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = ecore_event_type_new();
2522         EFL_UTIL_EVENT_GESTURE_TAP = ecore_event_type_new();
2523         EFL_UTIL_EVENT_GESTURE_PALM_COVER = ecore_event_type_new();
2524
2525         dpy_fd = wl_display_get_fd(_eflutil.wl.dpy);
2526         _eflutil.wl.dpy_fd = fcntl(dpy_fd, F_DUPFD_CLOEXEC, 0);
2527         if (_eflutil.wl.dpy_fd >= 0)
2528           _eflutil.wl.fd_hdl = ecore_main_fd_handler_add(_eflutil.wl.dpy_fd,
2529                                  ECORE_FD_READ | ECORE_FD_WRITE | ECORE_FD_ERROR,
2530                                  _efl_util_fd_cb, NULL,
2531                                  NULL, NULL);
2532      }
2533    _eflutil.wl.gesture.event_init++;
2534    gesture_h->init = EINA_TRUE;
2535
2536    set_last_result(EFL_UTIL_ERROR_NONE);
2537    return gesture_h;
2538
2539 out:
2540 /* LCOV_EXCL_START */
2541    if (gesture_h)
2542      {
2543         free(gesture_h);
2544         gesture_h = NULL;
2545      }
2546    return gesture_h;
2547 /* LCOV_EXCL_STOP */
2548 }
2549
2550 API int
2551 efl_util_gesture_deinitialize(efl_util_gesture_h gesture_h)
2552 {
2553    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
2554    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
2555
2556    free(gesture_h);
2557    gesture_h = NULL;
2558
2559    _eflutil.wl.gesture.event_init--;
2560
2561    if (_eflutil.wl.gesture.event_init <= 0)
2562      {
2563         _eflutil.wl.gesture.event_init = 0;
2564         ecore_event_shutdown();
2565         EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = 0;
2566         EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = 0;
2567         EFL_UTIL_EVENT_GESTURE_TAP = 0;
2568         EFL_UTIL_EVENT_GESTURE_PALM_COVER = 0;
2569         if (_eflutil.wl.dpy_fd >= 0)
2570           {
2571              ecore_main_fd_handler_del(_eflutil.wl.fd_hdl);
2572              _eflutil.wl.fd_hdl = NULL;
2573              close(_eflutil.wl.dpy_fd);
2574              _eflutil.wl.dpy_fd = -1;
2575           }
2576      }
2577
2578    return EFL_UTIL_ERROR_NONE;
2579 }
2580
2581 API efl_util_gesture_data
2582 efl_util_gesture_edge_swipe_new(efl_util_gesture_h gesture_h, unsigned int fingers, efl_util_gesture_edge_e edge)
2583 {
2584    Efl_Util_Gesture_Edge_Swipe_Grab_Data *data;
2585
2586    if (!gesture_h || gesture_h->init == EINA_FALSE)
2587      {
2588         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2589         return NULL;
2590      }
2591
2592    if (edge <= EFL_UTIL_GESTURE_EDGE_NONE || edge > EFL_UTIL_GESTURE_EDGE_LEFT)
2593      {
2594         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2595         return NULL;
2596      }
2597
2598    data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Edge_Swipe_Grab_Data));
2599    if (!data)
2600      {
2601         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
2602         return NULL; /* LCOV_EXCL_LINE */
2603      }
2604
2605    data->base.type = TIZEN_GESTURE_TYPE_EDGE_SWIPE;
2606    data->fingers = fingers;
2607    data->edge = edge;
2608    data->edge_size = EFL_UTIL_GESTURE_EDGE_SIZE_FULL;
2609
2610    set_last_result(EFL_UTIL_ERROR_NONE);
2611
2612    return (void *)data;
2613 }
2614
2615 API int
2616 efl_util_gesture_edge_swipe_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
2617 {
2618    if (!gesture_h || gesture_h->init == EINA_FALSE)
2619      {
2620         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2621      }
2622
2623    if (!data)
2624      {
2625         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2626      }
2627
2628    free(data);
2629    data = NULL;
2630
2631    return EFL_UTIL_ERROR_NONE;
2632 }
2633
2634 API int
2635 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)
2636 {
2637    Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = data;
2638
2639    EINA_SAFETY_ON_NULL_RETURN_VAL(edge_swipe_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2640    EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_swipe_data->base.type == TIZEN_GESTURE_TYPE_EDGE_SWIPE,
2641                                    EFL_UTIL_ERROR_INVALID_PARAMETER);
2642    EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_size == EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL,
2643                                    EFL_UTIL_ERROR_INVALID_PARAMETER);
2644    EINA_SAFETY_ON_FALSE_RETURN_VAL(end_point > start_point, EFL_UTIL_ERROR_INVALID_PARAMETER);
2645
2646    edge_swipe_data->edge_size = edge_size;
2647    edge_swipe_data->start_point = start_point;
2648    edge_swipe_data->end_point = end_point;
2649
2650    return EFL_UTIL_ERROR_NONE;
2651 }
2652
2653 API efl_util_gesture_data
2654 efl_util_gesture_edge_drag_new(efl_util_gesture_h gesture_h, unsigned int fingers, efl_util_gesture_edge_e edge)
2655 {
2656    Efl_Util_Gesture_Edge_Drag_Grab_Data *data;
2657
2658    if (!gesture_h || gesture_h->init == EINA_FALSE)
2659      {
2660         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2661         return NULL;
2662      }
2663
2664    if (edge <= EFL_UTIL_GESTURE_EDGE_NONE || edge > EFL_UTIL_GESTURE_EDGE_LEFT)
2665      {
2666         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2667         return NULL;
2668      }
2669
2670    data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Edge_Drag_Grab_Data));
2671    if (!data)
2672      {
2673         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
2674         return NULL; /* LCOV_EXCL_LINE */
2675      }
2676
2677    data->base.type = TIZEN_GESTURE_TYPE_EDGE_DRAG;
2678    data->fingers = fingers;
2679    data->edge = edge;
2680    data->edge_size = EFL_UTIL_GESTURE_EDGE_SIZE_FULL;
2681
2682    set_last_result(EFL_UTIL_ERROR_NONE);
2683
2684    return (void *)data;
2685 }
2686
2687 API int
2688 efl_util_gesture_edge_drag_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
2689 {
2690    if (!gesture_h || gesture_h->init == EINA_FALSE)
2691      {
2692         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2693      }
2694
2695    if (!data)
2696      {
2697         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2698      }
2699
2700    free(data);
2701    data = NULL;
2702
2703    return EFL_UTIL_ERROR_NONE;
2704 }
2705
2706 API int
2707 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)
2708 {
2709    Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = data;
2710
2711    EINA_SAFETY_ON_NULL_RETURN_VAL(edge_drag_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2712    EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_drag_data->base.type == TIZEN_GESTURE_TYPE_EDGE_DRAG,
2713                                    EFL_UTIL_ERROR_INVALID_PARAMETER);
2714    EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_size == EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL,
2715                                    EFL_UTIL_ERROR_INVALID_PARAMETER);
2716    EINA_SAFETY_ON_FALSE_RETURN_VAL(end_point > start_point, EFL_UTIL_ERROR_INVALID_PARAMETER);
2717
2718    edge_drag_data->edge_size = edge_size;
2719    edge_drag_data->start_point = start_point;
2720    edge_drag_data->end_point = end_point;
2721
2722    return EFL_UTIL_ERROR_NONE;
2723 }
2724
2725 API efl_util_gesture_data
2726 efl_util_gesture_tap_new(efl_util_gesture_h gesture_h, unsigned int fingers, unsigned int repeats)
2727 {
2728    Efl_Util_Gesture_Tap_Grab_Data *data;
2729
2730    if (!gesture_h || gesture_h->init == EINA_FALSE)
2731      {
2732         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2733         return NULL;
2734      }
2735
2736    if (fingers <= 1 || repeats <= 1)
2737      {
2738         set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED);
2739         return NULL;
2740      }
2741
2742    data = (Efl_Util_Gesture_Tap_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Tap_Grab_Data));
2743    if (!data)
2744      {
2745         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
2746         return NULL; /* LCOV_EXCL_LINE */
2747      }
2748
2749    data->base.type = TIZEN_GESTURE_TYPE_TAP;
2750    data->fingers = fingers;
2751    data->repeats = repeats;
2752
2753    set_last_result(EFL_UTIL_ERROR_NONE);
2754
2755    return (void *)data;
2756 }
2757
2758 API int
2759 efl_util_gesture_tap_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
2760 {
2761    if (!gesture_h || gesture_h->init == EINA_FALSE)
2762      {
2763         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2764      }
2765
2766    if (!data)
2767      {
2768         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2769      }
2770
2771    free(data);
2772    data = NULL;
2773
2774    return EFL_UTIL_ERROR_NONE;
2775 }
2776
2777 API efl_util_gesture_data
2778 efl_util_gesture_palm_cover_new(efl_util_gesture_h gesture_h)
2779 {
2780    Efl_Util_Gesture_Palm_Cover_Grab_Data *data;
2781
2782    if (!gesture_h || gesture_h->init == EINA_FALSE)
2783      {
2784         set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2785         return NULL;
2786      }
2787
2788    data = (Efl_Util_Gesture_Palm_Cover_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Palm_Cover_Grab_Data));
2789    if (!data)
2790      {
2791         set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
2792         return NULL; /* LCOV_EXCL_LINE */
2793      }
2794
2795    data->base.type = TIZEN_GESTURE_TYPE_PALM_COVER;
2796
2797    set_last_result(EFL_UTIL_ERROR_NONE);
2798
2799    return (void *)data;
2800 }
2801
2802 API int
2803 efl_util_gesture_palm_cover_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
2804 {
2805    if (!gesture_h || gesture_h->init == EINA_FALSE)
2806      {
2807         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2808      }
2809
2810    if (!data)
2811      {
2812         return EFL_UTIL_ERROR_INVALID_PARAMETER;
2813      }
2814
2815    free(data);
2816    data = NULL;
2817
2818    return EFL_UTIL_ERROR_NONE;
2819 }
2820
2821 /* LCOV_EXCL_START */
2822 API int
2823 efl_util_gesture_grab(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
2824 {
2825    int ret = EFL_UTIL_ERROR_NONE;
2826    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2827
2828    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2829
2830    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
2831    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
2832    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2833
2834    switch (base_data->type)
2835      {
2836         case TIZEN_GESTURE_TYPE_EDGE_SWIPE:
2837            ret = _efl_util_gesture_grab_edge_swipe(data);
2838            break;
2839         case TIZEN_GESTURE_TYPE_EDGE_DRAG:
2840            ret = _efl_util_gesture_grab_edge_drag(data);
2841            break;
2842         case TIZEN_GESTURE_TYPE_TAP:
2843            ret = _efl_util_gesture_grab_tap(data);
2844            break;
2845         case TIZEN_GESTURE_TYPE_PALM_COVER:
2846            ret = _efl_util_gesture_grab_palm_cover(data);
2847            break;
2848         default:
2849            return EFL_UTIL_ERROR_INVALID_PARAMETER;
2850      }
2851
2852    return ret;
2853 }
2854
2855 API int
2856 efl_util_gesture_ungrab(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
2857 {
2858    int ret = EFL_UTIL_ERROR_NONE;
2859    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2860
2861    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2862
2863    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
2864    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
2865    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2866
2867    switch (base_data->type)
2868      {
2869         case TIZEN_GESTURE_TYPE_EDGE_SWIPE:
2870            ret = _efl_util_gesture_ungrab_edge_swipe(data);
2871            break;
2872         case TIZEN_GESTURE_TYPE_EDGE_DRAG:
2873            ret = _efl_util_gesture_ungrab_edge_drag(data);
2874            break;
2875         case TIZEN_GESTURE_TYPE_TAP:
2876            ret = _efl_util_gesture_ungrab_tap(data);
2877            break;
2878         case TIZEN_GESTURE_TYPE_PALM_COVER:
2879            ret = _efl_util_gesture_ungrab_palm_cover(data);
2880            break;
2881         default:
2882            return EFL_UTIL_ERROR_INVALID_PARAMETER;
2883      }
2884
2885    return ret;
2886 }
2887 /* LCOV_EXCL_STOP */
2888
2889 API int
2890 efl_util_gesture_select(efl_util_gesture_h gesture_h, Evas_Object *window, efl_util_gesture_data data)
2891 {
2892    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2893    Ecore_Wl2_Window *wlwin;
2894    struct wl_surface *surface;
2895    int ret;
2896
2897    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2898
2899    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
2900    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
2901    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
2902    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2903
2904    if (base_data->type != TIZEN_GESTURE_TYPE_PALM_COVER)
2905      return EFL_UTIL_ERROR_NOT_SUPPORTED;
2906
2907    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
2908    if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
2909
2910    surface = ecore_wl2_window_surface_get(wlwin);
2911    EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
2912                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2913
2914    tizen_gesture_select_palm_cover(_eflutil.wl.gesture.proto, surface);
2915
2916    while (_eflutil.wl.gesture.request_notified == -1)
2917      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2918
2919    ret = _efl_util_gesture_convert_error(_eflutil.wl.gesture.request_notified);
2920    _eflutil.wl.gesture.request_notified = -1;
2921
2922    return ret;
2923 }
2924
2925 API int
2926 efl_util_gesture_deselect(efl_util_gesture_h gesture_h, Evas_Object *window, efl_util_gesture_data data)
2927 {
2928    Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2929    Ecore_Wl2_Window *wlwin;
2930    struct wl_surface *surface;
2931    int ret;
2932
2933    base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2934
2935    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
2936    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
2937    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
2938    EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2939
2940    if (base_data->type != TIZEN_GESTURE_TYPE_PALM_COVER)
2941      return EFL_UTIL_ERROR_NOT_SUPPORTED;
2942
2943    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
2944    if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
2945
2946    surface = ecore_wl2_window_surface_get(wlwin);
2947    EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
2948                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
2949
2950    tizen_gesture_deselect_palm_cover(_eflutil.wl.gesture.proto, surface);
2951
2952    while (_eflutil.wl.gesture.request_notified == -1)
2953      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2954
2955    ret = _efl_util_gesture_convert_error(_eflutil.wl.gesture.request_notified);
2956    _eflutil.wl.gesture.request_notified = -1;
2957
2958    return ret;
2959 }
2960
2961 /* LCOV_EXCL_START */
2962 API int
2963 efl_util_gesture_activate_set(efl_util_gesture_h gesture_h, unsigned int type, Eina_Bool active)
2964 {
2965    int ret;
2966
2967    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
2968    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
2969    EINA_SAFETY_ON_TRUE_RETURN_VAL(type == EFL_UTIL_GESTURE_TYPE_NONE, EFL_UTIL_ERROR_INVALID_PARAMETER);
2970
2971    tizen_gesture_activate_set(_eflutil.wl.gesture.proto, NULL, type, active);
2972
2973    while (_eflutil.wl.gesture.request_notified == -1)
2974      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
2975
2976    ret = _efl_util_gesture_convert_error(_eflutil.wl.gesture.request_notified);
2977    _eflutil.wl.gesture.request_notified = -1;
2978
2979    return ret;
2980 }
2981 /* LCOV_EXCL_STOP */
2982
2983 API int
2984 efl_util_gesture_activate_set_on_window(efl_util_gesture_h gesture_h, Evas_Object *window, unsigned int type, Eina_Bool active)
2985 {
2986    Ecore_Wl2_Window *wlwin;
2987    struct wl_surface *surface;
2988    int ret;
2989
2990    EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
2991    EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
2992    EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
2993    EINA_SAFETY_ON_TRUE_RETURN_VAL(type == EFL_UTIL_GESTURE_TYPE_NONE, EFL_UTIL_ERROR_INVALID_PARAMETER);
2994
2995    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
2996    if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
2997
2998    surface = ecore_wl2_window_surface_get(wlwin);
2999    EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
3000                                   EFL_UTIL_ERROR_INVALID_PARAMETER);
3001
3002    tizen_gesture_activate_set(_eflutil.wl.gesture.proto, surface, type, active);
3003
3004    while (_eflutil.wl.gesture.request_notified == -1)
3005      wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
3006
3007    ret = _efl_util_gesture_convert_error(_eflutil.wl.gesture.request_notified);
3008    _eflutil.wl.gesture.request_notified = -1;
3009
3010    return ret;
3011 }