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