src/efl_util.c

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