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