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