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