src/efl_util.c

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