X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fefl_util.c;h=0f7794d1e37aa5ffbac94a4ba77ad303314d0ca0;hb=10a3cb4c1743f190bf772a76ed03c239ad01d285;hp=743c6914cd5b1c604f5526954bed65ad8dbe7678;hpb=2661e174a44a68375f4bc95cad1c832e651660e8;p=platform%2Fcore%2Fapi%2Fefl-util.git diff --git a/src/efl_util.c b/src/efl_util.c index 743c691..0f7794d 100644 --- a/src/efl_util.c +++ b/src/efl_util.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2015 Samsung Electronics Co., Ltd All Rights Reserved + * Copyright (c) 2011-2017 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -14,6 +14,8 @@ * limitations under the License. */ +#define _GNU_SOURCE + #define LOG_TAG "TIZEN_N_EFL_UTIL" #include @@ -30,40 +32,25 @@ #include #include #include +#include -#if X11 -#include -#include -#include -#include -#include -#include -#include -#endif /* end of X11 */ - -#if WAYLAND -#include +#include #include #include #include -#include -#endif /* end of WAYLAND */ -/* callback handler index */ -#define CBH_NOTI_LEV 0 -#define CBH_SCR_MODE 1 -#define CBH_MAX 2 +#include -typedef void (*Efl_Util_Cb)(Evas_Object *, int, void *); +#include +#ifdef LOG_TAG +#undef LOG_TAG +#endif -typedef struct _Efl_Util_Callback_Info -{ - Evas_Object *win; - Efl_Util_Cb cb; - void *data; -} Efl_Util_Callback_Info; +#define LOG_TAG "TIZEN_N_EFL_UTIL" +#define EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER 10 + +#define NUM_EVENT_WAIT_DONE_COUNT 10 -#if WAYLAND typedef struct _Efl_Util_Wl_Surface_Lv_Info { void *surface; /* wl_surface */ @@ -80,98 +67,163 @@ typedef struct _Efl_Util_Wl_Surface_Scr_Mode_Info uint32_t state; } Efl_Util_Wl_Surface_Scr_Mode_Info; +typedef struct _Efl_Util_Wl_Surface_Brightness_Info +{ + void *surface; /* wl_surface */ + int brightness; + Eina_Bool wait_for_done; + uint32_t state; +} Efl_Util_Wl_Surface_Brightness_Info; + typedef struct _Efl_Util_Wl_Output_Info { struct wl_output *output; int offset_x, offset_y, width, height; } Efl_Util_Wl_Output_Info; -#endif -typedef struct _Efl_Util_Data +typedef struct _Efl_Util_Gesture_Common_Grab_Data { -#if X11 - /* x11 related stuffs */ - struct - { - Eina_Bool init; - Ecore_Event_Handler *handler; /* x11 client message handler */ - Ecore_X_Display *dpy; - } x11; -#endif /* end of X11 */ + int type; +} Efl_Util_Gesture_Common_Grab_Data; + +typedef struct _Efl_Util_Gesture_Edge_Swipe_Grab_Data +{ + Efl_Util_Gesture_Common_Grab_Data base; + + unsigned int fingers; + efl_util_gesture_edge_e edge; + efl_util_gesture_edge_size_e edge_size; + unsigned int start_point; + unsigned int end_point; +} Efl_Util_Gesture_Edge_Swipe_Grab_Data; + +typedef struct _Efl_Util_Gesture_Edge_Drag_Grab_Data +{ + Efl_Util_Gesture_Common_Grab_Data base; + + unsigned int fingers; + efl_util_gesture_edge_e edge; + efl_util_gesture_edge_size_e edge_size; + unsigned int start_point; + unsigned int end_point; +} Efl_Util_Gesture_Edge_Drag_Grab_Data; + +typedef struct _Efl_Util_Gesture_Tap_Grab_Data +{ + Efl_Util_Gesture_Common_Grab_Data base; + + unsigned int fingers; + unsigned int repeats; +} Efl_Util_Gesture_Tap_Grab_Data; -#if WAYLAND +typedef struct _Efl_Util_Gesture_Palm_Cover_Grab_Data +{ + Efl_Util_Gesture_Common_Grab_Data base; +} Efl_Util_Gesture_Palm_Cover_Grab_Data; + +typedef struct _E_Devicemgr_Inputgen_Touch_Axis +{ + double radius_x; + double radius_y; + double pressure; + double angle; + double palm; +} E_Devicemgr_Inputgen_Touch_Axis; + +typedef struct _Efl_Util_Data +{ /* wayland related stuffs */ struct { Eina_Bool init; + Ecore_Wl2_Display *wl2_display; struct wl_display *dpy; struct wl_event_queue *queue; struct { + unsigned int id; struct tizen_policy *proto; Eina_Hash *hash_noti_lv; Eina_Hash *hash_scr_mode; } policy; struct { - struct screenshooter *screenshooter; + struct wl_event_queue *queue; + struct tizen_screenshooter *tz_screenshooter; struct wayland_tbm_client *tbm_client; Eina_List *output_list; + uint32_t noti; } shot; struct { struct tizen_input_device_manager *devicemgr; int request_notified; + Eina_List *devices; + Eina_List *wait_devices; + struct wl_event_source *wait_timer; + int max_touch_count; + int request_touch_count; } devmgr; + struct + { + unsigned int id; + struct tizen_display_policy *proto; + Eina_Hash *hash_brightness; + } display_policy; } wl; -#endif /* end of WAYLAND */ +} Efl_Util_Data; +typedef struct _Efl_Util_Data_Default_Queue +{ + /* wayland related stuffs */ struct { - Eina_List *info_list; /* list of callback info */ - unsigned int atom; /* x11 atom */ - } cb_handler[CBH_MAX]; -} Efl_Util_Data; + Eina_Bool init; + Ecore_Wl2_Display *wl2_display; + struct wl_display *dpy; + + struct + { + unsigned int id; + struct tizen_gesture *proto; + int request_notified; + int event_init; + } gesture; + } wl; +} Efl_Util_Data_Default_Queue; + static Efl_Util_Data _eflutil = { -#if X11 { EINA_FALSE, - NULL, - NULL + NULL, NULL, NULL, + { 0, NULL, NULL, NULL }, /* tizen_policy protocol */ + { NULL, NULL, NULL, NULL, 0 }, /* screenshooter protocol */ + { NULL, -1, NULL, NULL, NULL, 0, 0 }, /* tizen_input_device_manager protocol */ + { 0, NULL, NULL } /* display_policy protocol */ }, -#endif /* end of X11 */ -#if WAYLAND +}; + +static Efl_Util_Data_Default_Queue _eflutil_defaultqueue = +{ { EINA_FALSE, NULL, NULL, - { NULL, NULL, NULL }, /* tizen_policy protocol */ - { NULL, NULL, NULL }, /* screenshooter protocol */ - { NULL, -1 } /* tizen_input_device_manager protocol */ - }, -#endif /* end of WAYLAND */ - { - { NULL, 0 }, /* handler for notification level */ - { NULL, 0 } /* handler for screen mode */ + { 0, NULL, -1, 0 } /* gesture protocol */ }, }; -static Eina_Bool _cb_info_add(Evas_Object *win, Efl_Util_Cb cb, void *data, int idx); -static Eina_Bool _cb_info_del_by_win(Evas_Object *win, int idx); -static Eina_List *_cb_info_list_get(int idx); -static Efl_Util_Callback_Info *_cb_info_find_by_win(Evas_Object *win, int idx); -#if X11 -static Efl_Util_Callback_Info *_cb_info_find_by_xwin(unsigned int xwin, int idx); -static Eina_Bool _cb_x11_client_msg(void *data, int type, void *event); -static Eina_Bool _x11_init(void); -#endif /* end of X11 */ -#if WAYLAND + static Eina_Bool _wl_init(void); +static Eina_Bool _wl_init_default_queue(void); static void _cb_wl_reg_global(void *data, struct wl_registry *reg, unsigned int name, const char *interface, unsigned int version); static void _cb_wl_reg_global_remove(void *data, struct wl_registry *reg, unsigned int name); -static Efl_Util_Callback_Info *_cb_info_find_by_wlsurf(void *wlsurf, int idx); +static void _cb_wl_default_queue_reg_global(void *data, struct wl_registry *reg, unsigned int name, const char *interface, unsigned int version); +static void _cb_wl_default_queue_reg_global_remove(void *data, struct wl_registry *reg, unsigned int name); +static void _cb_wl_reg_screenshooter_global(void *data, struct wl_registry *reg, unsigned int name, const char *interface, unsigned int version); +static void _cb_wl_reg_screenshooter_global_remove(void *data, struct wl_registry *reg, unsigned int name); static void _cb_wl_tz_policy_conformant(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface, uint32_t is_conformant); 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); 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); @@ -180,11 +232,27 @@ static void _cb_wl_tz_policy_scr_mode_done(void *data, struct 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); 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); static void _cb_wl_tz_policy_allowed_aux_hint(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, int id); +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); +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); + +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); 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); 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); static void _cb_error(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED, uint32_t errorcode); static void _cb_block_expired(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED); +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); + +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); +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); +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); +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); +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); +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); +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); +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); +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); + static const struct wl_registry_listener _wl_reg_listener = { @@ -192,6 +260,12 @@ static const struct wl_registry_listener _wl_reg_listener = _cb_wl_reg_global_remove }; +static const struct wl_registry_listener _wl_reg_screenshooter_listener = +{ + _cb_wl_reg_screenshooter_global, + _cb_wl_reg_screenshooter_global_remove +}; + struct tizen_policy_listener _wl_tz_policy_listener = { _cb_wl_tz_policy_conformant, @@ -202,6 +276,8 @@ struct tizen_policy_listener _wl_tz_policy_listener = _cb_wl_tz_policy_iconify_state_changed, _cb_wl_tz_policy_supported_aux_hints, _cb_wl_tz_policy_allowed_aux_hint, + _cb_wl_tz_policy_aux_message, + _cb_wl_conformant_region, }; struct tizen_input_device_manager_listener _wl_tz_devmgr_listener = @@ -209,211 +285,112 @@ struct tizen_input_device_manager_listener _wl_tz_devmgr_listener = _cb_device_add, _cb_device_remove, _cb_error, - _cb_block_expired + _cb_block_expired, + _cb_max_touch_count }; -#endif /* end of WAYLAND */ - -static Eina_Bool -_cb_info_add(Evas_Object *win, - Efl_Util_Cb cb, - void *data, - int idx) +struct tizen_display_policy_listener _wl_tz_display_policy_listener = { - Efl_Util_Callback_Info *info; - - info = _cb_info_find_by_win(win, idx); - if (info) - { - _eflutil.cb_handler[idx].info_list - = eina_list_remove(_eflutil.cb_handler[idx].info_list, - info); - free(info); - } - - info = (Efl_Util_Callback_Info *)calloc(1, sizeof(Efl_Util_Callback_Info)); - if (!info) return EINA_FALSE; - - info->win = win; - info->cb = cb; - info->data = data; - - _eflutil.cb_handler[idx].info_list - = eina_list_append(_eflutil.cb_handler[idx].info_list, - info); - -#if X11 - if (!_eflutil.x11.handler) - _eflutil.x11.handler = ecore_event_handler_add(ECORE_X_EVENT_CLIENT_MESSAGE, - _cb_x11_client_msg, - NULL); -#endif /* end of X11 */ - - return EINA_TRUE; -} + _cb_wl_tz_display_policy_brightness_done, +}; -static Eina_Bool -_cb_info_del_by_win(Evas_Object *win, - int idx) +static const struct wl_registry_listener _wl_default_queue_reg_listener = { - Efl_Util_Callback_Info *info; - - info = _cb_info_find_by_win(win, idx); - if (!info) return EINA_FALSE; - - _eflutil.cb_handler[idx].info_list - = eina_list_remove(_eflutil.cb_handler[idx].info_list, - info); - free(info); - -#if X11 - unsigned int count = eina_list_count(_eflutil.cb_handler[idx].info_list); - if ((count == 0) && (_eflutil.x11.handler)) - { - ecore_event_handler_del(_eflutil.x11.handler); - _eflutil.x11.handler = NULL; - } -#endif - - return EINA_TRUE; -} + _cb_wl_default_queue_reg_global, + _cb_wl_default_queue_reg_global_remove +}; -static Eina_List * -_cb_info_list_get(int idx) +struct tizen_gesture_listener _wl_tz_gesture_listener = { - return _eflutil.cb_handler[idx].info_list; -} + _cb_gesture_edge_swipe_notify, + _cb_gesture_edge_swipe, + _cb_gesture_edge_drag_notify, + _cb_gesture_edge_drag, + _cb_gesture_tap_notify, + _cb_gesture_tap, + _cb_gesture_palm_cover_notify, + _cb_gesture_palm_cover, + _cb_gesture_activate_notify +}; -static Efl_Util_Callback_Info * -_cb_info_find_by_win(Evas_Object *win, - int idx) +static Eina_Bool +_wl_init(void) { - Eina_List *l, *ll; - Efl_Util_Callback_Info *info; + struct wl_display *display_wrapper = NULL; + struct wl_registry *reg = NULL; - l = _cb_info_list_get(idx); - EINA_LIST_FOREACH(l, ll, info) - { - if (info->win == win) return info; - } + if (_eflutil.wl.init) return EINA_TRUE; - return NULL; -} + ecore_wl2_init(); -#if X11 -static Efl_Util_Callback_Info * -_cb_info_find_by_xwin(unsigned int xwin, - int idx) -{ - Eina_List *l, *ll; - Efl_Util_Callback_Info *info; - unsigned int xwin2; + _eflutil.wl.wl2_display = ecore_wl2_display_connect(NULL); + EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.wl2_display, fail); + _eflutil.wl.dpy = ecore_wl2_display_get(_eflutil.wl.wl2_display); + EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.dpy, fail); - l = _cb_info_list_get(idx); - EINA_LIST_FOREACH(l, ll, info) - { - xwin2 = elm_win_xwindow_get(info->win); - if (xwin == xwin2) return info; - } + display_wrapper = wl_proxy_create_wrapper(_eflutil.wl.dpy); + EINA_SAFETY_ON_NULL_GOTO(display_wrapper, fail); - return NULL; -} + _eflutil.wl.queue = wl_display_create_queue(_eflutil.wl.dpy); + EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.queue, fail); -static Eina_Bool -_cb_x11_client_msg(void *data, - int type, - void *event) -{ - Ecore_X_Event_Client_Message *ev; - Ecore_X_Window xwin; - Efl_Util_Callback_Info *info; + wl_proxy_set_queue((struct wl_proxy *)display_wrapper, _eflutil.wl.queue); - ev = event; - if (!ev) return ECORE_CALLBACK_PASS_ON; + reg = wl_display_get_registry(display_wrapper); + wl_proxy_wrapper_destroy(display_wrapper); + display_wrapper = NULL; + EINA_SAFETY_ON_NULL_GOTO(reg, fail); - xwin = ev->win; - if (xwin == 0) return ECORE_CALLBACK_PASS_ON; + wl_registry_add_listener(reg, &_wl_reg_listener, NULL); - if (ev->message_type == _eflutil.cb_handler[CBH_NOTI_LEV].atom) - { - info = _cb_info_find_by_xwin(xwin, CBH_NOTI_LEV); + _eflutil.wl.init = EINA_TRUE; - /* permission denied */ - if ((ev->data.l[1] == 0) && - (info) && - (info->cb)) - { - info->cb(info->win, - EFL_UTIL_ERROR_PERMISSION_DENIED, - info->data); - } - } - else if (ev->message_type == _eflutil.cb_handler[CBH_SCR_MODE].atom) - { - info = _cb_info_find_by_xwin(xwin, CBH_SCR_MODE); + return EINA_TRUE; +fail: + if (display_wrapper) + wl_proxy_wrapper_destroy(display_wrapper); - /* permission denied */ - if ((ev->data.l[1] == 0) && - (info) && - (info->cb)) - { - info->cb(info->win, - EFL_UTIL_ERROR_PERMISSION_DENIED, - info->data); - } + if (_eflutil.wl.queue) + { + wl_event_queue_destroy(_eflutil.wl.queue); + _eflutil.wl.queue = NULL; } - return ECORE_CALLBACK_PASS_ON; -} - -static Eina_Bool -_x11_init(void) -{ - if (_eflutil.x11.init) return EINA_TRUE; - - _eflutil.x11.dpy = ecore_x_display_get(); - EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.x11.dpy, EINA_FALSE); - - _eflutil.x11.init = EINA_TRUE; - return EINA_TRUE; + ecore_wl2_shutdown(); + return EINA_FALSE; } -#endif /* end of X11 */ -#if WAYLAND static Eina_Bool -_wl_init(void) +_wl_init_default_queue(void) { + struct wl_display *display_wrapper = NULL; struct wl_registry *reg = NULL; - if (_eflutil.wl.init) return EINA_TRUE; + if (_eflutil_defaultqueue.wl.init) return EINA_TRUE; - ecore_wl_init(NULL); + if (ecore_wl2_init() <= 0) return EINA_FALSE; - _eflutil.wl.dpy = ecore_wl_display_get(); - EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.dpy, fail); + _eflutil_defaultqueue.wl.wl2_display = ecore_wl2_connected_display_get(NULL); + EINA_SAFETY_ON_NULL_GOTO(_eflutil_defaultqueue.wl.wl2_display, fail); + _eflutil_defaultqueue.wl.dpy = ecore_wl2_display_get(_eflutil_defaultqueue.wl.wl2_display); + EINA_SAFETY_ON_NULL_GOTO(_eflutil_defaultqueue.wl.dpy, fail); - _eflutil.wl.queue = wl_display_create_queue(_eflutil.wl.dpy); - EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.queue, fail); + display_wrapper = wl_proxy_create_wrapper(_eflutil_defaultqueue.wl.dpy); + EINA_SAFETY_ON_NULL_GOTO(display_wrapper, fail); - reg = wl_display_get_registry(_eflutil.wl.dpy); + reg = wl_display_get_registry(display_wrapper); + wl_proxy_wrapper_destroy(display_wrapper); + display_wrapper = NULL; EINA_SAFETY_ON_NULL_GOTO(reg, fail); - wl_proxy_set_queue((struct wl_proxy*)reg, _eflutil.wl.queue); - wl_registry_add_listener(reg, &_wl_reg_listener, NULL); + wl_registry_add_listener(reg, &_wl_default_queue_reg_listener, NULL); - _eflutil.wl.init = EINA_TRUE; + _eflutil_defaultqueue.wl.init = EINA_TRUE; return EINA_TRUE; fail: - if (_eflutil.wl.queue) - { - wl_event_queue_destroy(_eflutil.wl.queue); - _eflutil.wl.queue = NULL; - } - if (reg) - wl_registry_destroy(reg); - ecore_wl_shutdown(); + ecore_wl2_shutdown(); return EINA_FALSE; } @@ -461,22 +438,35 @@ static const struct wl_output_listener output_listener = }; static void -_cb_wl_screenshot_done(void *data, struct screenshooter *screenshooter) +_cb_tz_screenshot_format(void *data, struct tizen_screenshooter *tz_screenshooter, uint32_t format) +{ +} + +static void +_cb_tz_screenshot_noti(void *data, struct tizen_screenshooter *tz_screenshooter, uint32_t noti) +{ + _eflutil.wl.shot.noti = noti; +} + +static void +_cb_tz_screenshot_done(void *data, struct tizen_screenshooter *tz_screenshooter) { Eina_Bool *shot_done = (Eina_Bool*)data; if (shot_done) *shot_done = EINA_TRUE; } -static const struct screenshooter_listener screenshooter_listener = +static const struct tizen_screenshooter_listener tz_screenshooter_listener = { - _cb_wl_screenshot_done + _cb_tz_screenshot_format, + _cb_tz_screenshot_noti, + _cb_tz_screenshot_done, }; static void _cb_wl_reg_global(void *data, struct wl_registry *reg, - unsigned int name, + unsigned int id, const char *interface, unsigned int version) { @@ -484,9 +474,9 @@ _cb_wl_reg_global(void *data, { struct tizen_policy *proto; proto = wl_registry_bind(reg, - name, + id, &tizen_policy_interface, - 1); + 7); if (!proto) return; tizen_policy_add_listener(proto, @@ -496,6 +486,7 @@ _cb_wl_reg_global(void *data, _eflutil.wl.policy.hash_noti_lv = eina_hash_pointer_new(free); _eflutil.wl.policy.hash_scr_mode = eina_hash_pointer_new(free); _eflutil.wl.policy.proto = proto; + _eflutil.wl.policy.id = id; } else if (strcmp(interface, "wl_output") == 0) { @@ -504,49 +495,103 @@ _cb_wl_reg_global(void *data, _eflutil.wl.shot.output_list = eina_list_append(_eflutil.wl.shot.output_list, output); - output->output = wl_registry_bind(reg, name, &wl_output_interface, version); + output->output = wl_registry_bind(reg, id, &wl_output_interface, version); wl_output_add_listener(output->output, &output_listener, output); } - else if (strcmp(interface, "screenshooter") == 0) - { - _eflutil.wl.shot.screenshooter = wl_registry_bind(reg, name, &screenshooter_interface, version); - screenshooter_add_listener(_eflutil.wl.shot.screenshooter, &screenshooter_listener, NULL); - } else if (strcmp(interface, "tizen_input_device_manager") == 0) { - _eflutil.wl.devmgr.devicemgr = wl_registry_bind(reg, name, &tizen_input_device_manager_interface, version); + _eflutil.wl.devmgr.devicemgr = wl_registry_bind(reg, id, &tizen_input_device_manager_interface, version); tizen_input_device_manager_add_listener(_eflutil.wl.devmgr.devicemgr, &_wl_tz_devmgr_listener, NULL); } -} + else if (!strcmp(interface, "tizen_display_policy")) + { + _eflutil.wl.display_policy.proto = wl_registry_bind(reg, id, &tizen_display_policy_interface, version); + if (!_eflutil.wl.display_policy.proto) return; + + tizen_display_policy_add_listener(_eflutil.wl.display_policy.proto, + &_wl_tz_display_policy_listener, + NULL); + _eflutil.wl.display_policy.hash_brightness = eina_hash_pointer_new(free); + _eflutil.wl.display_policy.id = id; + } +} +/* LCOV_EXCL_START */ static void _cb_wl_reg_global_remove(void *data, struct wl_registry *reg, - unsigned int name) + unsigned int id) { - _eflutil.wl.policy.proto = NULL; - eina_hash_free(_eflutil.wl.policy.hash_noti_lv); - eina_hash_free(_eflutil.wl.policy.hash_scr_mode); + /* unset each global id number to 0 since global id is started + * from number 1 on server side display structure + */ + if (id == _eflutil.wl.policy.id) + { + _eflutil.wl.policy.id = 0; + _eflutil.wl.policy.proto = NULL; + eina_hash_free(_eflutil.wl.policy.hash_noti_lv); + eina_hash_free(_eflutil.wl.policy.hash_scr_mode); + } + else if (id == _eflutil.wl.display_policy.id) + { + _eflutil.wl.display_policy.id = 0; + _eflutil.wl.display_policy.proto = NULL; + eina_hash_free(_eflutil.wl.display_policy.hash_brightness); + } } +/* LCOV_EXCL_STOP */ -static Efl_Util_Callback_Info * -_cb_info_find_by_wlsurf(void *wlsurf, - int idx) +static void +_cb_wl_default_queue_reg_global(void *data, + struct wl_registry *reg, + unsigned int id, + const char *interface, + unsigned int version) { - Eina_List *l, *ll; - Efl_Util_Callback_Info *info; - Ecore_Wl_Window *wlwin2 = NULL; - void *wlsurf2 = NULL; + if (strcmp(interface, "tizen_gesture") == 0) + { + _eflutil_defaultqueue.wl.gesture.id = id; + _eflutil_defaultqueue.wl.gesture.proto = wl_registry_bind(reg, id, &tizen_gesture_interface, version); + tizen_gesture_add_listener(_eflutil_defaultqueue.wl.gesture.proto, &_wl_tz_gesture_listener, NULL); + } +} +/* LCOV_EXCL_START */ +static void +_cb_wl_default_queue_reg_global_remove(void *data, + struct wl_registry *reg, + unsigned int id) +{ + if (id == _eflutil_defaultqueue.wl.gesture.id) + { + _eflutil_defaultqueue.wl.gesture.id = 0; + _eflutil_defaultqueue.wl.gesture.proto = NULL; + } +} +/* LCOV_EXCL_STOP */ + - l = _cb_info_list_get(idx); - EINA_LIST_FOREACH(l, ll, info) +static void +_cb_wl_reg_screenshooter_global(void *data, + struct wl_registry *reg, + unsigned int name, + const char *interface, + unsigned int version) +{ + if (strcmp(interface, "tizen_screenshooter") == 0) { - wlwin2 = elm_win_wl_window_get(info->win); - wlsurf2 = ecore_wl_window_surface_get(wlwin2); - if (wlsurf== wlsurf2) return info; + _eflutil.wl.shot.tz_screenshooter = wl_registry_bind(reg, name, &tizen_screenshooter_interface, version); + tizen_screenshooter_add_listener(_eflutil.wl.shot.tz_screenshooter, &tz_screenshooter_listener, NULL); + + wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue); } +} - return NULL; +/* LCOV_EXCL_START */ +static void +_cb_wl_reg_screenshooter_global_remove(void *data, + struct wl_registry *reg, + unsigned int name) +{ } static void @@ -561,6 +606,7 @@ _cb_wl_tz_policy_conformant_area(void *data, struct tizen_policy *tizen_policy, uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h) { } +/* LCOV_EXCL_STOP */ static void _cb_wl_tz_policy_notification_done(void *data, @@ -570,7 +616,6 @@ _cb_wl_tz_policy_notification_done(void *data, uint32_t state) { Efl_Util_Wl_Surface_Lv_Info *lv_info; - Efl_Util_Callback_Info *cb_info; lv_info = eina_hash_find(_eflutil.wl.policy.hash_noti_lv, &surface); if (lv_info) @@ -579,22 +624,14 @@ _cb_wl_tz_policy_notification_done(void *data, lv_info->wait_for_done = EINA_FALSE; lv_info->state = state; } - - if (state != TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED) return; - - cb_info = _cb_info_find_by_wlsurf((void *)surface, CBH_NOTI_LEV); - if (!cb_info) return; - if (!cb_info->cb) return; - - cb_info->cb(cb_info->win, - EFL_UTIL_ERROR_PERMISSION_DENIED, - cb_info->data); } +/* LCOV_EXCL_START */ static void _cb_wl_tz_policy_transient_for_done(void *data, struct tizen_policy *tizen_policy, uint32_t child_id) { } +/* LCOV_EXCL_STOP */ static void _cb_wl_tz_policy_scr_mode_done(void *data, @@ -603,9 +640,7 @@ _cb_wl_tz_policy_scr_mode_done(void *data, uint32_t mode, uint32_t state) { - Efl_Util_Wl_Surface_Scr_Mode_Info *scr_mode_info; - Efl_Util_Callback_Info *cb_info; scr_mode_info = eina_hash_find(_eflutil.wl.policy.hash_scr_mode, &surface); if (scr_mode_info) @@ -614,18 +649,9 @@ _cb_wl_tz_policy_scr_mode_done(void *data, scr_mode_info->wait_for_done = EINA_FALSE; scr_mode_info->state = state; } - - if (state != TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED) return; - - cb_info = _cb_info_find_by_wlsurf((void *)surface, CBH_SCR_MODE); - if (!cb_info) return; - if (!cb_info->cb) return; - - cb_info->cb(cb_info->win, - EFL_UTIL_ERROR_PERMISSION_DENIED, - cb_info->data); } +/* LCOV_EXCL_START */ 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) { } @@ -638,6 +664,32 @@ static void _cb_wl_tz_policy_allowed_aux_hint(void *data, str { } +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) +{ +} +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) +{ +} +/* LCOV_EXCL_STOP */ + +static void +_cb_wl_tz_display_policy_brightness_done(void *data, + struct tizen_display_policy *tizen_display_policy, + struct wl_surface *surface, + int32_t brightness, + uint32_t state) +{ + Efl_Util_Wl_Surface_Brightness_Info *brightness_info; + + brightness_info = eina_hash_find(_eflutil.wl.display_policy.hash_brightness, &surface); + if (brightness_info) + { + brightness_info->brightness = brightness; + brightness_info->wait_for_done = EINA_FALSE; + brightness_info->state = state; + } +} + static void _cb_window_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED) { @@ -649,7 +701,6 @@ _cb_window_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, vo eina_hash_del(_eflutil.wl.policy.hash_noti_lv, &lv_info->surface, lv_info); } -#endif /* end of WAYLAND */ API int efl_util_set_notification_window_level(Evas_Object *window, @@ -662,62 +713,30 @@ efl_util_set_notification_window_level(Evas_Object *window, (level <= EFL_UTIL_NOTIFICATION_LEVEL_TOP), EFL_UTIL_ERROR_INVALID_PARAMETER); -#if X11 - Ecore_X_Window_Type window_type; - Ecore_X_Window xwin; - - res = _x11_init(); - EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); - - xwin = elm_win_xwindow_get(window); - if (xwin) - { - if (ecore_x_netwm_window_type_get(xwin, &window_type) == EINA_TRUE) - { - // success to get window type - if (window_type != ECORE_X_WINDOW_TYPE_NOTIFICATION) - { - // given EFL window's type is not notification type. - return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE; - } - } - else - return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE; - - utilx_set_system_notification_level(_eflutil.x11.dpy, - xwin, - level); - return EFL_UTIL_ERROR_NONE; - } - - return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE; -#endif /* end of X11 */ - -#if WAYLAND Elm_Win_Type type; - Ecore_Wl_Window *wlwin; + Ecore_Wl2_Window *wlwin; struct wl_surface *surface; Efl_Util_Wl_Surface_Lv_Info *lv_info; - Ecore_Wl_Window_Type wl_type; + Ecore_Wl2_Window_Type wl_type; res = _wl_init(); EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); - wlwin = elm_win_wl_window_get(window); + wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window); EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE); type = elm_win_type_get(window); if (type != ELM_WIN_NOTIFICATION) { - wl_type = ecore_wl_window_type_get(wlwin); - EINA_SAFETY_ON_FALSE_RETURN_VAL((wl_type == ECORE_WL_WINDOW_TYPE_NOTIFICATION), + wl_type = ecore_wl2_window_type_get(wlwin); + EINA_SAFETY_ON_FALSE_RETURN_VAL((wl_type == ECORE_WL2_WINDOW_TYPE_NOTIFICATION), EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE); } while (!_eflutil.wl.policy.proto) wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - surface = ecore_wl_window_surface_get(wlwin); + surface = ecore_wl2_window_surface_get(wlwin); EINA_SAFETY_ON_NULL_RETURN_VAL(surface, EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE); @@ -752,9 +771,9 @@ efl_util_set_notification_window_level(Evas_Object *window, if (lv_info->wait_for_done) { int count = 0; - while (lv_info->wait_for_done && (count < 3)) + while (lv_info->wait_for_done && (count < NUM_EVENT_WAIT_DONE_COUNT)) { - ecore_wl_flush(); + ecore_wl2_display_flush(_eflutil.wl.wl2_display); wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); count++; } @@ -773,7 +792,6 @@ efl_util_set_notification_window_level(Evas_Object *window, } return EFL_UTIL_ERROR_NONE; -#endif /* end of WAYLAND */ } API int @@ -785,70 +803,30 @@ efl_util_get_notification_window_level(Evas_Object *window, EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); EINA_SAFETY_ON_NULL_RETURN_VAL(level, EFL_UTIL_ERROR_INVALID_PARAMETER); -#if X11 - Ecore_X_Window_Type window_type; - Utilx_Notification_Level utilx_level; - Ecore_X_Window xwin; - - res = _x11_init(); - EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); - - xwin = elm_win_xwindow_get(window); - if (xwin) - { - if (ecore_x_netwm_window_type_get(xwin, &window_type) == EINA_TRUE) - { - // success to get window type - if (window_type != ECORE_X_WINDOW_TYPE_NOTIFICATION) - { - // given EFL window's type is not notification type. - return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE; - } - - utilx_level = utilx_get_system_notification_level(_eflutil.x11.dpy, xwin); - if (utilx_level == UTILX_NOTIFICATION_LEVEL_LOW) - *level = EFL_UTIL_NOTIFICATION_LEVEL_1; - else if(utilx_level == UTILX_NOTIFICATION_LEVEL_NORMAL) - *level = EFL_UTIL_NOTIFICATION_LEVEL_2; - else if(utilx_level == UTILX_NOTIFICATION_LEVEL_HIGH) - *level = EFL_UTIL_NOTIFICATION_LEVEL_3; - else - return EFL_UTIL_ERROR_INVALID_PARAMETER; - } - else - return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE; - - return EFL_UTIL_ERROR_NONE; - } - - return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE; -#endif /* end of X11 */ - -#if WAYLAND Elm_Win_Type type; - Ecore_Wl_Window *wlwin; + Ecore_Wl2_Window *wlwin; struct wl_surface *surface; Efl_Util_Wl_Surface_Lv_Info *lv_info; - Ecore_Wl_Window_Type wl_type; + Ecore_Wl2_Window_Type wl_type; res = _wl_init(); EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); - wlwin = elm_win_wl_window_get(window); + wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window); EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE); type = elm_win_type_get(window); if (type != ELM_WIN_NOTIFICATION) { - wl_type = ecore_wl_window_type_get(wlwin); - EINA_SAFETY_ON_FALSE_RETURN_VAL((wl_type == ECORE_WL_WINDOW_TYPE_NOTIFICATION), + wl_type = ecore_wl2_window_type_get(wlwin); + EINA_SAFETY_ON_FALSE_RETURN_VAL((wl_type == ECORE_WL2_WINDOW_TYPE_NOTIFICATION), EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE); } while (!_eflutil.wl.policy.proto) wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - surface = ecore_wl_window_surface_get(wlwin); + surface = ecore_wl2_window_surface_get(wlwin); EINA_SAFETY_ON_NULL_RETURN_VAL(surface, EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE); @@ -858,9 +836,9 @@ efl_util_get_notification_window_level(Evas_Object *window, if (lv_info->wait_for_done) { int count = 0; - while ((lv_info->wait_for_done) && (count < 3)) + while ((lv_info->wait_for_done) && (count < NUM_EVENT_WAIT_DONE_COUNT)) { - ecore_wl_flush(); + ecore_wl2_display_flush(_eflutil.wl.wl2_display); wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); count++; } @@ -874,9 +852,6 @@ efl_util_get_notification_window_level(Evas_Object *window, switch (lv_info->level) { - case TIZEN_POLICY_LEVEL_1: *level = EFL_UTIL_NOTIFICATION_LEVEL_1; break; - case TIZEN_POLICY_LEVEL_2: *level = EFL_UTIL_NOTIFICATION_LEVEL_2; break; - case TIZEN_POLICY_LEVEL_3: *level = EFL_UTIL_NOTIFICATION_LEVEL_3; break; case TIZEN_POLICY_LEVEL_NONE: *level = EFL_UTIL_NOTIFICATION_LEVEL_NONE; break; case TIZEN_POLICY_LEVEL_DEFAULT: *level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT; break; case TIZEN_POLICY_LEVEL_MEDIUM: *level = EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM; break; @@ -891,44 +866,6 @@ efl_util_get_notification_window_level(Evas_Object *window, *level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT; return EFL_UTIL_ERROR_NONE; -#endif /* end of WAYLAND */ -} - -API int -efl_util_set_notification_window_level_error_cb(Evas_Object *window, - efl_util_notification_window_level_error_cb callback, - void *user_data) -{ - Eina_Bool ret = EINA_FALSE; - - EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); - EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EFL_UTIL_ERROR_INVALID_PARAMETER); - - ret = _cb_info_add(window, - (Efl_Util_Cb)callback, - user_data, - CBH_NOTI_LEV); - if (!ret) return EFL_UTIL_ERROR_OUT_OF_MEMORY; - -#if X11 - if (!_eflutil.cb_handler[CBH_NOTI_LEV].atom) - _eflutil.cb_handler[CBH_NOTI_LEV].atom = ecore_x_atom_get("_E_NOTIFICATION_LEVEL_ACCESS_RESULT"); -#endif /* end of X11 */ - - return EFL_UTIL_ERROR_NONE; -} - -API int -efl_util_unset_notification_window_level_error_cb(Evas_Object *window) -{ - Eina_Bool ret = EINA_FALSE; - - EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); - - ret = _cb_info_del_by_win(window, CBH_NOTI_LEV); - if (!ret) return EFL_UTIL_ERROR_INVALID_PARAMETER; - - return EFL_UTIL_ERROR_NONE; } API int @@ -941,35 +878,8 @@ efl_util_set_window_opaque_state(Evas_Object *window, EINA_SAFETY_ON_FALSE_RETURN_VAL(((opaque >= 0) && (opaque <= 1)), EFL_UTIL_ERROR_INVALID_PARAMETER); -#if X11 - Ecore_X_Window xwin; - Utilx_Opaque_State state; - int ret; - - res = _x11_init(); - EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); - - xwin = elm_win_xwindow_get(window); - EINA_SAFETY_ON_FALSE_RETURN_VAL(xwin > 0, EFL_UTIL_ERROR_INVALID_PARAMETER); - - if (opaque) - state = UTILX_OPAQUE_STATE_ON; - else - state = UTILX_OPAQUE_STATE_OFF; - - ret = utilx_set_window_opaque_state(_eflutil.x11.dpy, - xwin, - state); - - if (!ret) - return EFL_UTIL_ERROR_INVALID_PARAMETER; - else - return EFL_UTIL_ERROR_NONE; -#endif /* end of X11 */ - -#if WAYLAND - Ecore_Wl_Window *wlwin; - struct wl_surface *surface; + Ecore_Wl2_Window *wlwin; + struct wl_surface *surface; if (!_eflutil.wl.policy.proto) { @@ -984,18 +894,17 @@ efl_util_set_window_opaque_state(Evas_Object *window, EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.policy.proto, EFL_UTIL_ERROR_INVALID_PARAMETER); } - wlwin = elm_win_wl_window_get(window); + wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window); if (!wlwin) return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE; - surface = ecore_wl_window_surface_get(wlwin); + surface = ecore_wl2_window_surface_get(wlwin); if (!surface) return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE; tizen_policy_set_opaque_state(_eflutil.wl.policy.proto, surface, opaque); return EFL_UTIL_ERROR_NONE; -#endif /* end of WAYLAND */ } API int @@ -1007,40 +916,7 @@ efl_util_set_window_screen_mode(Evas_Object *window, (mode <= EFL_UTIL_SCREEN_MODE_ALWAYS_ON)), EFL_UTIL_ERROR_INVALID_PARAMETER); -#if X11 - Evas *e; - Ecore_Evas *ee; - int id; - - e = evas_object_evas_get(window); - EINA_SAFETY_ON_NULL_RETURN_VAL(e, EFL_UTIL_ERROR_INVALID_PARAMETER); - - ee = ecore_evas_ecore_evas_get(e); - EINA_SAFETY_ON_NULL_RETURN_VAL(ee, EFL_UTIL_ERROR_INVALID_PARAMETER); - - id = ecore_evas_aux_hint_id_get(ee, "wm.policy.win.lcd.lock"); - if (mode == EFL_UTIL_SCREEN_MODE_ALWAYS_ON) - { - if (id == -1) - ecore_evas_aux_hint_add(ee, "wm.policy.win.lcd.lock", "1"); - else - ecore_evas_aux_hint_val_set(ee, id, "1"); - } - else if (mode == EFL_UTIL_SCREEN_MODE_DEFAULT) - { - if (id == -1) - ecore_evas_aux_hint_add(ee, "wm.policy.win.lcd.lock", "0"); - else - ecore_evas_aux_hint_val_set(ee, id, "0"); - } - else - return EFL_UTIL_ERROR_INVALID_PARAMETER; - - return EFL_UTIL_ERROR_NONE; -#endif /* end of X11 */ - -#if WAYLAND - Ecore_Wl_Window *wlwin; + Ecore_Wl2_Window *wlwin; struct wl_surface *surface; Efl_Util_Wl_Surface_Scr_Mode_Info *scr_mode_info; Eina_Bool res; @@ -1048,13 +924,13 @@ efl_util_set_window_screen_mode(Evas_Object *window, res = _wl_init(); EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); - wlwin = elm_win_wl_window_get(window); + wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window); if (wlwin) { while (!_eflutil.wl.policy.proto) wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - surface = ecore_wl_window_surface_get(wlwin); + surface = ecore_wl2_window_surface_get(wlwin); EINA_SAFETY_ON_NULL_RETURN_VAL(surface, EFL_UTIL_ERROR_INVALID_PARAMETER); @@ -1085,9 +961,9 @@ efl_util_set_window_screen_mode(Evas_Object *window, if (scr_mode_info->wait_for_done) { int count = 0; - while (scr_mode_info->wait_for_done && (count < 3)) + while (scr_mode_info->wait_for_done && (count < NUM_EVENT_WAIT_DONE_COUNT)) { - ecore_wl_flush(); + ecore_wl2_display_flush(_eflutil.wl.wl2_display); wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); count++; } @@ -1109,7 +985,6 @@ efl_util_set_window_screen_mode(Evas_Object *window, } else return EFL_UTIL_ERROR_INVALID_PARAMETER; -#endif /* end of WAYLAND */ } API int @@ -1119,34 +994,7 @@ efl_util_get_window_screen_mode(Evas_Object *window, EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); EINA_SAFETY_ON_NULL_RETURN_VAL(mode, EFL_UTIL_ERROR_INVALID_PARAMETER); -#if X11 - Evas *e; - Ecore_Evas *ee; - const char *str; - int id; - - e = evas_object_evas_get(window); - EINA_SAFETY_ON_NULL_RETURN_VAL(e, EFL_UTIL_ERROR_INVALID_PARAMETER); - - ee = ecore_evas_ecore_evas_get(e); - EINA_SAFETY_ON_NULL_RETURN_VAL(ee, EFL_UTIL_ERROR_INVALID_PARAMETER); - - id = ecore_evas_aux_hint_id_get(ee, "wm.policy.win.lcd.lock"); - EINA_SAFETY_ON_TRUE_RETURN_VAL((id == -1), EFL_UTIL_ERROR_INVALID_PARAMETER); - - str = ecore_evas_aux_hint_val_get(ee, id); - EINA_SAFETY_ON_NULL_RETURN_VAL(str, EFL_UTIL_ERROR_INVALID_PARAMETER); - - if (strncmp(str, "1", strlen("1")) == 0) - *mode = EFL_UTIL_SCREEN_MODE_ALWAYS_ON; - else - *mode = EFL_UTIL_SCREEN_MODE_DEFAULT; - - return EFL_UTIL_ERROR_NONE; -#endif /* end of X11 */ - -#if WAYLAND - Ecore_Wl_Window *wlwin; + Ecore_Wl2_Window *wlwin; struct wl_surface *surface; Efl_Util_Wl_Surface_Scr_Mode_Info *scr_mode_info; Eina_Bool res; @@ -1154,13 +1002,13 @@ efl_util_get_window_screen_mode(Evas_Object *window, res = _wl_init(); EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); - wlwin = elm_win_wl_window_get(window); + wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window); if (wlwin) { while (!_eflutil.wl.policy.proto) wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - surface = ecore_wl_window_surface_get(wlwin); + surface = ecore_wl2_window_surface_get(wlwin); EINA_SAFETY_ON_NULL_RETURN_VAL(surface, EFL_UTIL_ERROR_INVALID_PARAMETER); @@ -1171,7 +1019,7 @@ efl_util_get_window_screen_mode(Evas_Object *window, { while (scr_mode_info->wait_for_done) { - ecore_wl_flush(); + ecore_wl2_display_flush(_eflutil.wl.wl2_display); wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); } } @@ -1193,58 +1041,143 @@ efl_util_get_window_screen_mode(Evas_Object *window, } else return EFL_UTIL_ERROR_INVALID_PARAMETER; -#endif /* end of WAYLAND */ } API int -efl_util_set_window_screen_mode_error_cb(Evas_Object *window, - efl_util_window_screen_mode_error_cb callback, - void *user_data) +efl_util_set_window_brightness(Evas_Object *window, int brightness) { - Eina_Bool ret = EINA_FALSE; + Ecore_Wl2_Window *wlwin; + struct wl_surface *surface; + Efl_Util_Wl_Surface_Brightness_Info *brightness_info; + Eina_Bool res; EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); - EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(brightness <= 100, EFL_UTIL_ERROR_INVALID_PARAMETER); - ret = _cb_info_add(window, - (Efl_Util_Cb)callback, - user_data, - CBH_SCR_MODE); - if (!ret) return EFL_UTIL_ERROR_OUT_OF_MEMORY; + res = _wl_init(); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); -#if X11 - if (!_eflutil.cb_handler[CBH_SCR_MODE].atom) - _eflutil.cb_handler[CBH_SCR_MODE].atom = ecore_x_atom_get("_E_SCREEN_MODE_ACCESS_RESULT"); -#endif /* end of X11 */ + wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window); + if (wlwin) + { + while (!_eflutil.wl.display_policy.proto) + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - return EFL_UTIL_ERROR_NONE; + surface = ecore_wl2_window_surface_get(wlwin); + EINA_SAFETY_ON_NULL_RETURN_VAL(surface, + EFL_UTIL_ERROR_INVALID_PARAMETER); + + brightness_info = eina_hash_find(_eflutil.wl.display_policy.hash_brightness, &surface); + if (!brightness_info) + { + brightness_info = calloc(1, sizeof(Efl_Util_Wl_Surface_Brightness_Info)); + EINA_SAFETY_ON_NULL_RETURN_VAL(brightness_info, EFL_UTIL_ERROR_OUT_OF_MEMORY); + + brightness_info->surface = surface; + brightness_info->brightness = brightness; + brightness_info->wait_for_done = EINA_TRUE; + brightness_info->state = TIZEN_DISPLAY_POLICY_ERROR_STATE_NONE; + + eina_hash_add(_eflutil.wl.display_policy.hash_brightness, + &surface, + brightness_info); + } + else + { + brightness_info->brightness = brightness; + brightness_info->wait_for_done = EINA_TRUE; + brightness_info->state = TIZEN_DISPLAY_POLICY_ERROR_STATE_NONE; + } + + tizen_display_policy_set_window_brightness(_eflutil.wl.display_policy.proto, + surface, brightness); + if (brightness_info->wait_for_done) + { + int count = 0; + while (brightness_info->wait_for_done && (count < NUM_EVENT_WAIT_DONE_COUNT)) + { + ecore_wl2_display_flush(_eflutil.wl.wl2_display); + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + count++; + } + + if (brightness_info->wait_for_done) + { + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + else + { + if (brightness_info->state == TIZEN_DISPLAY_POLICY_ERROR_STATE_PERMISSION_DENIED) + { + return EFL_UTIL_ERROR_PERMISSION_DENIED; + } + } + } + return EFL_UTIL_ERROR_NONE; + } + else + return EFL_UTIL_ERROR_INVALID_PARAMETER; } API int -efl_util_unset_window_screen_mode_error_cb(Evas_Object *window) +efl_util_get_window_brightness(Evas_Object *window, int *brightness) { - Eina_Bool ret = EINA_FALSE; + Ecore_Wl2_Window *wlwin; + struct wl_surface *surface; + Efl_Util_Wl_Surface_Brightness_Info *brightness_info; + Eina_Bool res; EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(brightness, EFL_UTIL_ERROR_INVALID_PARAMETER); + + res = _wl_init(); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); - ret = _cb_info_del_by_win(window, CBH_SCR_MODE); - if (!ret) return EFL_UTIL_ERROR_INVALID_PARAMETER; + wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window); + if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER; + + while (!_eflutil.wl.display_policy.proto) + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + + surface = ecore_wl2_window_surface_get(wlwin); + EINA_SAFETY_ON_NULL_RETURN_VAL(surface, + EFL_UTIL_ERROR_INVALID_PARAMETER); + + brightness_info = eina_hash_find(_eflutil.wl.display_policy.hash_brightness, &surface); + if (brightness_info) + { + if (brightness_info->wait_for_done) + { + while (brightness_info->wait_for_done) + { + ecore_wl2_display_flush(_eflutil.wl.wl2_display); + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + } + } + *brightness = brightness_info->brightness; + } + else + *brightness = -1; return EFL_UTIL_ERROR_NONE; } + struct _efl_util_inputgen_h { unsigned int init_type; + char name[32]; + E_Devicemgr_Inputgen_Touch_Axis *axis_info; }; -#if WAYLAND +/* LCOV_EXCL_STOP */ + 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 tizen_input_device *device, struct wl_seat *seat EINA_UNUSED) { ; @@ -1255,7 +1188,7 @@ _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 tizen_input_device *device, struct wl_seat *seat EINA_UNUSED) { ; @@ -1269,13 +1202,24 @@ _cb_error(void *data EINA_UNUSED, _eflutil.wl.devmgr.request_notified = errorcode; } +/* LCOV_EXCL_START */ static void _cb_block_expired(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED) { ; } -#endif /* end of WAYLAND */ +/* LCOV_EXCL_STOP */ + +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, + struct wl_seat *seat EINA_UNUSED) +{ + _eflutil.wl.devmgr.max_touch_count = max_count; +} static efl_util_error_e _efl_util_input_convert_input_generator_error(int ret) @@ -1290,19 +1234,23 @@ _efl_util_input_convert_input_generator_error(int ret) return EFL_UTIL_ERROR_OUT_OF_MEMORY; case TIZEN_INPUT_DEVICE_MANAGER_ERROR_INVALID_PARAMETER: return EFL_UTIL_ERROR_INVALID_PARAMETER; + case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NOT_ALLOWED: + return EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE; default : return EFL_UTIL_ERROR_NONE; } } -API efl_util_inputgen_h -efl_util_input_initialize_generator(efl_util_input_device_type_e dev_type) +static efl_util_inputgen_h +_efl_util_input_create_inputgen(unsigned int dev_type, const char *name, int *ret, int with_name) { - int res = EFL_UTIL_ERROR_NONE; efl_util_inputgen_h inputgen_h = NULL; + unsigned int clas = 0x0; - if ((dev_type <= EFL_UTIL_INPUT_DEVTYPE_NONE) || - (dev_type >= EFL_UTIL_INPUT_DEVTYPE_MAX)) + if (!dev_type || + dev_type & ~(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN + | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD + | EFL_UTIL_INPUT_DEVTYPE_POINTER)) { set_last_result(EFL_UTIL_ERROR_NO_SUCH_DEVICE); goto out; @@ -1316,19 +1264,46 @@ efl_util_input_initialize_generator(efl_util_input_device_type_e dev_type) } inputgen_h->init_type |= dev_type; -#if WAYLAND - res = _wl_init(); - if (res == (int)EINA_FALSE) + if (with_name) + { + if (name) strncpy(inputgen_h->name, name, 31); + else strncpy(inputgen_h->name, "Input Generator", 31); + } + + *ret = _wl_init(); + if (*ret == (int)EINA_FALSE) { set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); goto out; } + if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN) + clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN; + if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD) + clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD; + if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER) + clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE; + while (!_eflutil.wl.devmgr.devicemgr) wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - tizen_input_device_manager_init_generator(_eflutil.wl.devmgr.devicemgr); -#endif + if (with_name == 2) + tizen_input_device_manager_init_generator_with_sync(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name); + else if (with_name == 1) + tizen_input_device_manager_init_generator_with_name(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name); + else + tizen_input_device_manager_init_generator(_eflutil.wl.devmgr.devicemgr, clas); + + + while (_eflutil.wl.devmgr.request_notified == -1) + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + + *ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified); + _eflutil.wl.devmgr.request_notified = -1; + + set_last_result(*ret); + if (*ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE) + goto out; return inputgen_h; @@ -1341,21 +1316,109 @@ out: return NULL; } +API efl_util_inputgen_h +efl_util_input_initialize_generator(unsigned int dev_type) +{ + int ret = EFL_UTIL_ERROR_NONE; + efl_util_inputgen_h inputgen_h = NULL; + + inputgen_h = _efl_util_input_create_inputgen(dev_type, NULL, &ret, 0); + if (!inputgen_h) + return NULL; + + return inputgen_h; +} + +API efl_util_inputgen_h +efl_util_input_initialize_generator_with_name(unsigned int dev_type, const char *name) +{ + int ret = EFL_UTIL_ERROR_NONE; + efl_util_inputgen_h inputgen_h = NULL; + + inputgen_h = _efl_util_input_create_inputgen(dev_type, name, &ret, 1); + if (!inputgen_h) + return NULL; + + return inputgen_h; +} + +API efl_util_inputgen_h +efl_util_input_initialize_generator_with_sync(unsigned int dev_type, const char *name) +{ + int ret = EFL_UTIL_ERROR_NONE; + efl_util_inputgen_h inputgen_h = NULL; + + inputgen_h = _efl_util_input_create_inputgen(dev_type, name, &ret, 2); + if (!inputgen_h) + return NULL; + + return inputgen_h; +} + +API int +efl_util_input_set_touch_count(int max_count) +{ + int ret = EFL_UTIL_ERROR_NONE; + + ret = _wl_init(); + if (ret == (int)EINA_FALSE) + { + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + + while (!_eflutil.wl.devmgr.devicemgr) + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + + if (_eflutil.wl.devmgr.max_touch_count >= max_count) + return EFL_UTIL_ERROR_NONE; + + tizen_input_device_manager_set_touch_count(_eflutil.wl.devmgr.devicemgr, max_count); + + while (_eflutil.wl.devmgr.request_notified == -1) + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + + ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified); + _eflutil.wl.devmgr.request_notified = -1; + + if (ret == EFL_UTIL_ERROR_NONE) + { + _eflutil.wl.devmgr.request_touch_count = max_count; + } + + return ret; +} + API int efl_util_input_deinitialize_generator(efl_util_inputgen_h inputgen_h) { + int ret = EFL_UTIL_ERROR_NONE; + unsigned int clas = 0x0; EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER); + if (inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN) + clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN; + if (inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD) + clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD; + if (inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER) + clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE; + + if (inputgen_h->axis_info) + free(inputgen_h->axis_info); + free(inputgen_h); inputgen_h = NULL; -#if WAYLAND EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER); - tizen_input_device_manager_deinit_generator(_eflutil.wl.devmgr.devicemgr); -#endif + tizen_input_device_manager_deinit_generator(_eflutil.wl.devmgr.devicemgr, clas); - return EFL_UTIL_ERROR_NONE; + while (_eflutil.wl.devmgr.request_notified == -1) + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + + ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified); + _eflutil.wl.devmgr.request_notified = -1; + + return ret; } API int @@ -1368,7 +1431,6 @@ efl_util_input_generate_key(efl_util_inputgen_h inputgen_h, const char *key_name EINA_SAFETY_ON_FALSE_RETURN_VAL(pressed == 0 || pressed == 1, EFL_UTIL_ERROR_INVALID_PARAMETER); EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, EFL_UTIL_ERROR_NO_SUCH_DEVICE); -#if WAYLAND EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER); tizen_input_device_manager_generate_key(_eflutil.wl.devmgr.devicemgr, key_name, pressed); @@ -1378,7 +1440,6 @@ efl_util_input_generate_key(efl_util_inputgen_h inputgen_h, const char *key_name ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified); _eflutil.wl.devmgr.request_notified = -1; -#endif return ret; } @@ -1388,16 +1449,16 @@ efl_util_input_generate_touch(efl_util_inputgen_h inputgen_h, int idx, efl_util_input_touch_type_e touch_type, int x, int y) { int ret; -#if WAYLAND enum tizen_input_device_manager_pointer_event_type type; -#endif EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER); EINA_SAFETY_ON_FALSE_RETURN_VAL(idx >= 0, EFL_UTIL_ERROR_INVALID_PARAMETER); EINA_SAFETY_ON_FALSE_RETURN_VAL((x > 0 && y > 0), EFL_UTIL_ERROR_INVALID_PARAMETER); EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, EFL_UTIL_ERROR_NO_SUCH_DEVICE); -#if WAYLAND + if (idx >= _eflutil.wl.devmgr.max_touch_count) + return EFL_UTIL_ERROR_INVALID_PARAMETER; + EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER); switch(touch_type) @@ -1422,617 +1483,1749 @@ efl_util_input_generate_touch(efl_util_inputgen_h inputgen_h, int idx, ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified); _eflutil.wl.devmgr.request_notified = -1; -#endif return ret; } -struct _efl_util_screenshot_h +static int +_efl_util_input_generate_touch_axis_send(unsigned int type, double value) { - int width; - int height; - -#if X11 - Ecore_X_Display *dpy; - int internal_display; - int screen; - Window root; - Pixmap pixmap; - GC gc; - Atom atom_capture; - - /* port */ - int port; - - /* damage */ - Damage damage; - int damage_base; - - /* dri2 */ - int eventBase, errorBase; - int dri2Major, dri2Minor; - char *driver_name, *device_name; - drm_magic_t magic; - - /* drm */ - int drm_fd; -#endif - - Eina_Bool shot_done; - - /* tbm bufmgr */ - tbm_bufmgr bufmgr; -}; - -/* scrrenshot handle */ -static efl_util_screenshot_h g_screenshot; - -#if X11 -#define FOURCC(a,b,c,d) (((unsigned)d&0xff)<<24 | ((unsigned)c&0xff)<<16 | ((unsigned)b&0xff)<<8 | ((unsigned)a&0xff)) -#define FOURCC_RGB32 FOURCC('R','G','B','4') -#define TIMEOUT_CAPTURE 3 + int ret; -/* x error handling */ -static Bool g_efl_util_x_error_caught; + tizen_input_device_manager_generate_axis(_eflutil.wl.devmgr.devicemgr, type, wl_fixed_from_double(value)); -static int -_efl_util_screenshot_x_error_handle(Display *dpy, XErrorEvent *ev) -{ - if (!g_screenshot || (dpy != g_screenshot->dpy)) - return 0; + while (_eflutil.wl.devmgr.request_notified == -1) + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - g_efl_util_x_error_caught = True; + ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified); + _eflutil.wl.devmgr.request_notified = -1; - return 0; + return ret; } -static int -_efl_util_screenshot_get_port(Display *dpy, unsigned int id, Window win) +static void +_efl_util_input_generate_touch_axis_cleanup(efl_util_inputgen_h inputgen_h, int idx) { - unsigned int ver, rev, req_base, evt_base, err_base; - unsigned int adaptors; - XvAdaptorInfo *ai = NULL; - XvImageFormatValues *fo = NULL; - int formats; - int i, j, p; - - if (XvQueryExtension(dpy, &ver, &rev, &req_base, &evt_base, &err_base) != Success) - { - fprintf(stderr, "[screenshot] fail: no XV extension. \n"); - return -1; - } - - if (XvQueryAdaptors(dpy, win, &adaptors, &ai) != Success) + int i; + if (idx >= 0) { - fprintf(stderr, "[screenshot] fail: query adaptors. \n"); - return -1; + inputgen_h->axis_info[idx].radius_x = 1.0; + inputgen_h->axis_info[idx].radius_y = 1.0; + inputgen_h->axis_info[idx].pressure = 1.0; + inputgen_h->axis_info[idx].angle = 0.0; + inputgen_h->axis_info[idx].palm = 0.0; } - - EINA_SAFETY_ON_NULL_RETURN_VAL(ai, -1); - - for (i = 0; i < adaptors; i++) + else { - int support_format = False; - - if (!(ai[i].type & XvInputMask) || - !(ai[i].type & XvStillMask)) - continue; - - p = ai[i].base_id; - - fo = XvListImageFormats(dpy, p, &formats); - for (j = 0; j < formats; j++) - if (fo[j].id == (int)id) - support_format = True; - - if (fo) - XFree(fo); - - if (!support_format) - continue; - - for (; p < ai[i].base_id + ai[i].num_ports; p++) + for (i = 0; i < EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER; i++) { - if (XvGrabPort(dpy, p, 0) == Success) - { - XvFreeAdaptorInfo(ai); - return p; - } + inputgen_h->axis_info[i].radius_x = 1.0; + inputgen_h->axis_info[i].radius_y = 1.0; + inputgen_h->axis_info[i].pressure = 1.0; + inputgen_h->axis_info[i].angle = 0.0; + inputgen_h->axis_info[i].palm = 0.0; } } - - XvFreeAdaptorInfo(ai); - - XSync(dpy, False); - - return -1; } static int -_efl_util_screenshot_get_best_size(Display *dpy, int port, int width, int height, unsigned int *best_width, unsigned int *best_height) -{ - XErrorHandler old_handler = NULL; - - Atom atom_capture = XInternAtom(dpy, "_USER_WM_PORT_ATTRIBUTE_CAPTURE", False); - - g_efl_util_x_error_caught = False; - old_handler = XSetErrorHandler(_efl_util_screenshot_x_error_handle); - - XvSetPortAttribute(dpy, port, atom_capture, 1); - XSync(dpy, False); - - g_efl_util_x_error_caught = False; - XSetErrorHandler(old_handler); - - XvQueryBestSize(dpy, port, 0, 0, 0, width, height, best_width, best_height); - if (best_width <= 0 || best_height <= 0) - return 0; - - return 1; -} -#endif - -API efl_util_screenshot_h -efl_util_screenshot_initialize(int width, int height) +_efl_util_input_generate_touch_axis_process(efl_util_inputgen_h inputgen_h, int idx, double radius_x, + double radius_y, double pressure, double angle, double palm) { -#if X11 - efl_util_screenshot_h screenshot = NULL; - int depth = 0; - int damage_err_base = 0; - unsigned int best_width = 0; - unsigned int best_height = 0; - - EINA_SAFETY_ON_FALSE_GOTO(width > 0, fail_param); - EINA_SAFETY_ON_FALSE_GOTO(height > 0, fail_param); + int ret = EFL_UTIL_ERROR_NONE; - if (g_screenshot != NULL) + if (!inputgen_h->axis_info) { - if (g_screenshot->width != width || g_screenshot->height != height) - { - // TODO: recreate pixmap and update information - if (!_efl_util_screenshot_get_best_size(screenshot->dpy, screenshot->port, width, height, &best_width, &best_height)) - { - set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL); - return NULL; - } - - g_screenshot->width = width; - g_screenshot->height = height; - } - - return g_screenshot; + inputgen_h->axis_info = calloc(EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER, + sizeof(E_Devicemgr_Inputgen_Touch_Axis)); + _efl_util_input_generate_touch_axis_cleanup(inputgen_h, -1); } - screenshot = calloc(1, sizeof(struct _efl_util_screenshot_h)); - EINA_SAFETY_ON_NULL_GOTO(screenshot, fail_memory); - - /* set dpy */ - screenshot->dpy = ecore_x_display_get(); - if (!screenshot->dpy) + if (inputgen_h->axis_info[idx].radius_x != radius_x) { - screenshot->dpy = XOpenDisplay(0); - EINA_SAFETY_ON_NULL_GOTO(screenshot, fail_init); - - /* for XCloseDisplay at denitialization */ - screenshot->internal_display = 1; + ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_RADIUS_X, radius_x); + if (ret != EFL_UTIL_ERROR_NONE) return ret; + inputgen_h->axis_info[idx].radius_x = radius_x; } - - /* set screen */ - screenshot->screen = DefaultScreen(screenshot->dpy); - - /* set root window */ - screenshot->root = DefaultRootWindow(screenshot->dpy); - - /* initialize capture adaptor */ - screenshot->port = _efl_util_screenshot_get_port(screenshot->dpy, FOURCC_RGB32, screenshot->root); - EINA_SAFETY_ON_FALSE_GOTO(screenshot->port > 0, fail_init); - - /* get the best size */ - _efl_util_screenshot_get_best_size(screenshot->dpy, screenshot->port, width, height, &best_width, &best_height); - EINA_SAFETY_ON_FALSE_GOTO(best_width > 0, fail_init); - EINA_SAFETY_ON_FALSE_GOTO(best_height > 0, fail_init); - - /* set the width and the height */ - screenshot->width = best_width; - screenshot->height = best_height; - - /* create a pixmap */ - depth = DefaultDepth(screenshot->dpy, screenshot->screen); - screenshot->pixmap = XCreatePixmap(screenshot->dpy, screenshot->root, screenshot->width, screenshot->height, depth); - EINA_SAFETY_ON_FALSE_GOTO(screenshot->pixmap > 0, fail_init); - - screenshot->gc = XCreateGC(screenshot->dpy, screenshot->pixmap, 0, 0); - EINA_SAFETY_ON_NULL_GOTO(screenshot->gc, fail_init); - - XSetForeground(screenshot->dpy, screenshot->gc, 0xFF000000); - XFillRectangle(screenshot->dpy, screenshot->pixmap, screenshot->gc, 0, 0, width, height); - - /* initialize damage */ - if (!XDamageQueryExtension(screenshot->dpy, &screenshot->damage_base, &damage_err_base)) - goto fail_init; - - screenshot->damage = XDamageCreate(screenshot->dpy, screenshot->pixmap, XDamageReportNonEmpty); - EINA_SAFETY_ON_FALSE_GOTO(screenshot->damage > 0, fail_init); - - /* initialize dri3 and dri2 */ - if (!DRI2QueryExtension(screenshot->dpy, &screenshot->eventBase, &screenshot->errorBase)) + if (inputgen_h->axis_info[idx].radius_y != radius_y) { - fprintf(stderr, "[screenshot] fail: DRI2QueryExtention\n"); - goto fail_init; + ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_RADIUS_Y, radius_y); + if (ret != EFL_UTIL_ERROR_NONE) return ret; + inputgen_h->axis_info[idx].radius_y = radius_y; } - - if (!DRI2QueryVersion(screenshot->dpy, &screenshot->dri2Major, &screenshot->dri2Minor)) + if (inputgen_h->axis_info[idx].pressure != pressure) { - fprintf(stderr, "[screenshot] fail: DRI2QueryVersion\n"); - goto fail_init; + ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_PRESSURE, pressure); + if (ret != EFL_UTIL_ERROR_NONE) return ret; + inputgen_h->axis_info[idx].pressure = pressure; } - - if (!DRI2Connect(screenshot->dpy, screenshot->root, &screenshot->driver_name, &screenshot->device_name)) + if (inputgen_h->axis_info[idx].angle != angle) { - fprintf(stderr, "[screenshot] fail: DRI2Connect\n"); - goto fail_init; + ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_ANGLE, angle); + if (ret != EFL_UTIL_ERROR_NONE) return ret; + inputgen_h->axis_info[idx].angle = angle; } - - screenshot->drm_fd = open(screenshot->device_name, O_RDWR); - EINA_SAFETY_ON_FALSE_GOTO(screenshot->drm_fd >= 0, fail_init); - - if (drmGetMagic(screenshot->drm_fd, &screenshot->magic)) + if (inputgen_h->axis_info[idx].palm != palm) { - fprintf(stderr, "[screenshot] fail: drmGetMagic\n"); - goto fail_init; + ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_PALM, palm); + if (ret != EFL_UTIL_ERROR_NONE) return ret; + inputgen_h->axis_info[idx].palm = palm; } - if (!DRI2Authenticate(screenshot->dpy, screenshot->root, screenshot->magic)) - { - fprintf(stderr, "[screenshot] fail: DRI2Authenticate\n"); - goto fail_init; - } + return ret; +} - if (!drmAuthMagic(screenshot->drm_fd, screenshot->magic)) - { - fprintf(stderr, "[screenshot] fail: drmAuthMagic\n"); - goto fail_init; - } +API int +efl_util_input_generate_touch_axis(efl_util_inputgen_h inputgen_h, int idx, + efl_util_input_touch_type_e touch_type, int x, int y, + double radius_x, double radius_y, + double pressure, double angle, double palm) +{ + int ret, version; + enum tizen_input_device_manager_pointer_event_type type; - DRI2CreateDrawable(screenshot->dpy, screenshot->pixmap); + EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(idx >= 0, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL((x >= 0 && y >= 0), EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, EFL_UTIL_ERROR_NO_SUCH_DEVICE); + EINA_SAFETY_ON_FALSE_RETURN_VAL((radius_x >= 0.0 && radius_y >= 0.0), EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL((pressure >= 0.0 && palm >= 0.0), EFL_UTIL_ERROR_INVALID_PARAMETER); - /* tbm bufmgr */ - screenshot->bufmgr = tbm_bufmgr_init(screenshot->drm_fd); - EINA_SAFETY_ON_NULL_GOTO(screenshot->bufmgr, fail_init); + EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER); + version = tizen_input_device_manager_get_version(_eflutil.wl.devmgr.devicemgr); + EINA_SAFETY_ON_FALSE_RETURN_VAL((version >= 3), EFL_UTIL_ERROR_NOT_SUPPORTED); - XFlush(screenshot->dpy); + switch(touch_type) + { + case EFL_UTIL_INPUT_TOUCH_BEGIN: + type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_BEGIN; + break; + case EFL_UTIL_INPUT_TOUCH_UPDATE: + type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_UPDATE; + break; + case EFL_UTIL_INPUT_TOUCH_END: + type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_END; + break; + default: + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } - g_screenshot = screenshot; - set_last_result(EFL_UTIL_ERROR_NONE); + if (touch_type != EFL_UTIL_INPUT_TOUCH_END) + _efl_util_input_generate_touch_axis_process(inputgen_h, idx, radius_x, radius_y, pressure, angle, palm); + else + _efl_util_input_generate_touch_axis_cleanup(inputgen_h, idx); - return g_screenshot; -#endif + tizen_input_device_manager_generate_touch(_eflutil.wl.devmgr.devicemgr, type, x, y, idx); -#if WAYLAND - efl_util_screenshot_h screenshot = NULL; + while (_eflutil.wl.devmgr.request_notified == -1) + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - if (!_eflutil.wl.shot.screenshooter) - { - int ret = 0; - _wl_init(); - while (!_eflutil.wl.shot.screenshooter && ret != -1) - ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.screenshooter, fail_init); + ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified); + _eflutil.wl.devmgr.request_notified = -1; + + return ret; +} + + +API int +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) +{ + int ret; + enum tizen_input_device_manager_pointer_event_type type; + + EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(buttons > 0, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL((x >= 0 && y >= 0), EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER, EFL_UTIL_ERROR_NO_SUCH_DEVICE); + + EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER); - _eflutil.wl.shot.tbm_client = wayland_tbm_client_init(_eflutil.wl.dpy); - EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tbm_client, fail_init); + switch(pointer_type) + { + case EFL_UTIL_INPUT_POINTER_BUTTON_DOWN: + type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_BEGIN; + break; + case EFL_UTIL_INPUT_POINTER_MOVE: + type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_UPDATE; + break; + case EFL_UTIL_INPUT_POINTER_BUTTON_UP: + type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_END; + break; + default: + return EFL_UTIL_ERROR_INVALID_PARAMETER; } - EINA_SAFETY_ON_FALSE_GOTO(width > 0, fail_param); - EINA_SAFETY_ON_FALSE_GOTO(height > 0, fail_param); + tizen_input_device_manager_generate_pointer(_eflutil.wl.devmgr.devicemgr, type, x, y, buttons); - if (g_screenshot) + while (_eflutil.wl.devmgr.request_notified == -1) + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + + ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified); + _eflutil.wl.devmgr.request_notified = -1; + + return ret; +} + +API int +efl_util_input_generate_wheel(efl_util_inputgen_h inputgen_h, efl_util_input_pointer_wheel_type_e wheel_type, int value) +{ + int ret, version; + enum tizen_input_device_manager_pointer_event_type type; + + EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER, EFL_UTIL_ERROR_NO_SUCH_DEVICE); + + EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER); + version = tizen_input_device_manager_get_version(_eflutil.wl.devmgr.devicemgr); + EINA_SAFETY_ON_FALSE_RETURN_VAL((version >= 3), EFL_UTIL_ERROR_NOT_SUPPORTED); + + switch(wheel_type) { - if (g_screenshot->width != width || g_screenshot->height != height) - { - g_screenshot->width = width; - g_screenshot->height = height; - } + case EFL_UTIL_INPUT_POINTER_WHEEL_VERT: + type = TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_WHEEL; + break; + case EFL_UTIL_INPUT_POINTER_WHEEL_HORZ: + type = TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_HWHEEL; + break; + default: + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } - return g_screenshot; + tizen_input_device_manager_generate_axis(_eflutil.wl.devmgr.devicemgr, type, wl_fixed_from_int(value)); + + while (_eflutil.wl.devmgr.request_notified == -1) + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + + ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified); + _eflutil.wl.devmgr.request_notified = -1; + + return ret; +} + + + +struct _efl_util_screenshot_h +{ + int width; + int height; + + Eina_Bool shot_done; + + /* tbm bufmgr */ + tbm_bufmgr bufmgr; + + Eina_Bool auto_rotation; +}; + +/* scrrenshot handle */ +static efl_util_screenshot_h g_screenshot; +static Eina_Bool shot_mutex_init; +static pthread_mutex_t shot_lock; + +static Eina_Bool +_screenshot_mutex_init(void) +{ + if (shot_mutex_init) + return EINA_TRUE; + + if (pthread_mutex_init(&shot_lock, NULL)) + { + fprintf(stderr, "[screenshot] fail: mutex init"); /*LCOV_EXCL_LINE*/ + return EINA_FALSE; /*LCOV_EXCL_LINE*/ } - screenshot = calloc(1, sizeof(struct _efl_util_screenshot_h)); - EINA_SAFETY_ON_NULL_GOTO(screenshot, fail_memory); + shot_mutex_init = EINA_TRUE; - screenshot->width = width; - screenshot->height = height; + return EINA_TRUE; +} - screenshot->bufmgr = wayland_tbm_client_get_bufmgr(_eflutil.wl.shot.tbm_client); - EINA_SAFETY_ON_NULL_GOTO(screenshot->bufmgr, fail_init); +static Eina_Bool +_screenshot_mutex_destory(void) +{ + if (!shot_mutex_init) + return EINA_TRUE; - g_screenshot = screenshot; - set_last_result(EFL_UTIL_ERROR_NONE); + if (pthread_mutex_destroy(&shot_lock)) + { + fprintf(stderr, "[screenshot] fail: mutex destory"); /*LCOV_EXCL_LINE*/ + return EINA_FALSE; /*LCOV_EXCL_LINE*/ + } - screenshooter_set_user_data(_eflutil.wl.shot.screenshooter, &screenshot->shot_done); + shot_mutex_init = EINA_FALSE; - return g_screenshot; -#endif -fail_param: - if (screenshot) - efl_util_screenshot_deinitialize(screenshot); - set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); - return NULL; -fail_memory: - if (screenshot) - efl_util_screenshot_deinitialize(screenshot); - set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); - return NULL; -fail_init: - if (screenshot) - efl_util_screenshot_deinitialize(screenshot); - set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL); - return NULL; + return EINA_TRUE; } -API int -efl_util_screenshot_deinitialize(efl_util_screenshot_h screenshot) +void +_screenshot_mutex_lock(void) { -#if X11 - if (!screenshot) - return EFL_UTIL_ERROR_INVALID_PARAMETER; + if (!_screenshot_mutex_init()) + return; - /* tbm bufmgr */ - if (screenshot->bufmgr) - tbm_bufmgr_deinit(screenshot->bufmgr); + pthread_mutex_lock(&shot_lock); +} - DRI2DestroyDrawable(screenshot->dpy, screenshot->pixmap); +void +_screenshot_mutex_unlock(void) +{ + pthread_mutex_unlock(&shot_lock); +} - /* dri2 */ - if (screenshot->drm_fd) - close(screenshot->drm_fd); - if (screenshot->driver_name) - free(screenshot->driver_name); - if (screenshot->device_name) - free(screenshot->device_name); +static Eina_Bool +_efl_util_wl_screenshooter_init() +{ + struct wl_display *display_wrapper = NULL; + struct wl_registry *registry = NULL; + int ret = 0; - /* xv */ - if (screenshot->port > 0 && screenshot->pixmap > 0) - XvStopVideo(screenshot->dpy, screenshot->port, screenshot->pixmap); + if (_wl_init() == EINA_FALSE) + return EINA_FALSE; - /* damage */ - if (screenshot->damage) - XDamageDestroy(screenshot->dpy, screenshot->damage); + wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - /* gc */ - if (screenshot->gc) - XFreeGC(screenshot->dpy, screenshot->gc); + display_wrapper = wl_proxy_create_wrapper(_eflutil.wl.dpy); + EINA_SAFETY_ON_NULL_RETURN_VAL(display_wrapper, EINA_FALSE); - /* pixmap */ - if (screenshot->pixmap > 0) - XFreePixmap(screenshot->dpy, screenshot->pixmap); + _eflutil.wl.shot.queue = wl_display_create_queue(_eflutil.wl.dpy); + EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.queue, fail_create_queue); - /* port */ - if (screenshot->port > 0) - XvUngrabPort(screenshot->dpy, screenshot->port, 0); + wl_proxy_set_queue((struct wl_proxy *)display_wrapper, _eflutil.wl.shot.queue); - XSync(screenshot->dpy, False); + registry = wl_display_get_registry(display_wrapper); + EINA_SAFETY_ON_NULL_GOTO(registry, fail_get_registry); - /* dpy */ - if (screenshot->internal_display ==1 && screenshot->dpy) - XCloseDisplay(screenshot->dpy); + wl_registry_add_listener(registry, &_wl_reg_screenshooter_listener, NULL); - free(screenshot); - g_screenshot = NULL; + ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue); + EINA_SAFETY_ON_TRUE_GOTO(ret == -1, fail_roundtrip); + EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tz_screenshooter, fail_roundtrip); - return EFL_UTIL_ERROR_NONE; -#endif -#if WAYLAND - if (!screenshot) - return EFL_UTIL_ERROR_INVALID_PARAMETER; + _eflutil.wl.shot.tbm_client = wayland_tbm_client_init(_eflutil.wl.dpy); + EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tbm_client, fail_tbm_client_init); - free(screenshot); - g_screenshot = NULL; + wl_registry_destroy(registry); + wl_proxy_wrapper_destroy(display_wrapper); - if (_eflutil.wl.shot.screenshooter) - screenshooter_set_user_data(_eflutil.wl.shot.screenshooter, NULL); + if (_eflutil.wl.shot.noti == 0) + { + fprintf(stderr, "[screenshot] fail: privilege error\n"); /* LCOV_EXCL_LINE */ + return EINA_FALSE; + } - return EFL_UTIL_ERROR_NONE; -#endif + return EINA_TRUE; + +fail_tbm_client_init: + tizen_screenshooter_destroy(_eflutil.wl.shot.tz_screenshooter); + _eflutil.wl.shot.tz_screenshooter = NULL; +fail_roundtrip: + wl_registry_destroy(registry); +fail_get_registry: + wl_event_queue_destroy(_eflutil.wl.shot.queue); + _eflutil.wl.shot.queue = NULL; +fail_create_queue: + wl_proxy_wrapper_destroy(display_wrapper); + + return EINA_FALSE; } +static void +_efl_util_wl_screenshooter_deinit() +{ + if (_eflutil.wl.shot.tbm_client) + { + wayland_tbm_client_deinit(_eflutil.wl.shot.tbm_client); + _eflutil.wl.shot.tbm_client = NULL; + } + + if (_eflutil.wl.shot.tz_screenshooter) + { + tizen_screenshooter_destroy(_eflutil.wl.shot.tz_screenshooter); + _eflutil.wl.shot.tz_screenshooter = NULL; + } -API tbm_surface_h -efl_util_screenshot_take_tbm_surface(efl_util_screenshot_h screenshot) + if (_eflutil.wl.shot.queue) + { + wl_event_queue_destroy(_eflutil.wl.shot.queue); + _eflutil.wl.shot.queue = NULL; + } +} + +API efl_util_screenshot_h +efl_util_screenshot_initialize(int width, int height) { -#if X11 - XEvent ev = {0,}; - XErrorHandler old_handler = NULL; - unsigned int attachment = DRI2BufferFrontLeft; - int nbufs = 0; - DRI2Buffer *bufs = NULL; - tbm_bo t_bo = NULL; - tbm_surface_h t_surface = NULL; - int buf_width = 0; - int buf_height = 0; - tbm_surface_info_s surf_info; - int i; + efl_util_screenshot_h screenshot = NULL; - if (screenshot != g_screenshot) + if (width <= 0 || height <= 0) { set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); return NULL; } - /* for flush other pending requests and pending events */ - XSync(screenshot->dpy, 0); + _screenshot_mutex_lock(); - g_efl_util_x_error_caught = False; - old_handler = XSetErrorHandler(_efl_util_screenshot_x_error_handle); + if (g_screenshot) + { + if (g_screenshot->width != width || g_screenshot->height != height) + { + g_screenshot->width = width; + g_screenshot->height = height; + } + set_last_result(EFL_UTIL_ERROR_NONE); - /* dump here */ - XvPutStill(screenshot->dpy, screenshot->port, screenshot->pixmap, screenshot->gc, - 0, 0, screenshot->width, screenshot->height, - 0, 0, screenshot->width, screenshot->height); + _screenshot_mutex_unlock(); - XSync(screenshot->dpy, 0); + return g_screenshot; + } - if (g_efl_util_x_error_caught) + screenshot = calloc(1, sizeof(struct _efl_util_screenshot_h)); + if (screenshot == NULL) { - g_efl_util_x_error_caught = False; - XSetErrorHandler(old_handler); - goto fail; - } + set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); - g_efl_util_x_error_caught = False; - XSetErrorHandler(old_handler); + _screenshot_mutex_unlock(); - if (XPending(screenshot->dpy)) - XNextEvent(screenshot->dpy, &ev); - else + return NULL; + } + + if (!_eflutil.wl.shot.tz_screenshooter) { - int fd = ConnectionNumber(screenshot->dpy); - fd_set mask; - struct timeval tv; - int ret; + if (_efl_util_wl_screenshooter_init() == EINA_FALSE) + { + if (_eflutil.wl.shot.noti == 0) + set_last_result(EFL_UTIL_ERROR_PERMISSION_DENIED); + else + set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL); - FD_ZERO(&mask); - FD_SET(fd, &mask); + free(screenshot); - tv.tv_usec = 0; - tv.tv_sec = TIMEOUT_CAPTURE; + _screenshot_mutex_unlock(); - ret = select(fd + 1, &mask, 0, 0, &tv); - if (ret < 0) - fprintf(stderr, "[screenshot] fail: select.\n"); - else if (ret == 0) - fprintf(stderr, "[screenshot] fail: timeout(%d sec)!\n", TIMEOUT_CAPTURE); - else if (XPending(screenshot->dpy)) - XNextEvent(screenshot->dpy, &ev); - else - fprintf(stderr, "[screenshot] fail: not passed a event!\n"); + return NULL; + } } - /* check if the capture is done by xserver and pixmap has got the captured image */ - if (ev.type == (screenshot->damage_base + XDamageNotify)) - { - XDamageNotifyEvent *damage_ev = (XDamageNotifyEvent *)&ev; - if (damage_ev->drawable == screenshot->pixmap) - { - /* Get DRI2 FrontLeft buffer of the pixmap */ - bufs = DRI2GetBuffers(screenshot->dpy, screenshot->pixmap, &buf_width, &buf_height, &attachment, 1, &nbufs); - if (!bufs) - { - fprintf(stderr, "[screenshot] fail: DRI2GetBuffers\n"); - goto fail; - } + screenshot->width = width; + screenshot->height = height; + screenshot->auto_rotation = EINA_TRUE; - t_bo = tbm_bo_import(screenshot->bufmgr, bufs[0].name); - if (!t_bo) - { - fprintf(stderr, "[screenshot] fail: import tbm_bo!\n"); - goto fail; - } + screenshot->bufmgr = wayland_tbm_client_get_bufmgr(_eflutil.wl.shot.tbm_client); + EINA_SAFETY_ON_NULL_GOTO(screenshot->bufmgr, fail_get_bufmgr); - surf_info.width = buf_width; - surf_info.height = buf_height; - surf_info.format = TBM_FORMAT_XRGB8888; - surf_info.bpp = 32; - surf_info.size = bufs->pitch * surf_info.height; - surf_info.num_planes = 1; - for (i = 0; i < surf_info.num_planes; i++) - { - surf_info.planes[i].size = bufs->pitch * surf_info.height; - surf_info.planes[i].stride = bufs->pitch; - surf_info.planes[i].offset = 0; - } - t_surface = tbm_surface_internal_create_with_bos(&surf_info, &t_bo, 1); - if (!t_surface) - { - fprintf(stderr, "[screenshot] fail: get tbm_surface!\n"); - goto fail; - } + g_screenshot = screenshot; + set_last_result(EFL_UTIL_ERROR_NONE); - tbm_bo_unref(t_bo); - free(bufs); + tizen_screenshooter_set_user_data(_eflutil.wl.shot.tz_screenshooter, &screenshot->shot_done); - XDamageSubtract(screenshot->dpy, screenshot->damage, None, None ); + _screenshot_mutex_unlock(); - set_last_result(EFL_UTIL_ERROR_NONE); + return g_screenshot; - return t_surface; - } +/* LCOV_EXCL_START */ +fail_get_bufmgr: + set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL); + _screenshot_mutex_unlock(); + efl_util_screenshot_deinitialize(screenshot); + + return NULL; +/* LCOV_EXCL_STOP */ +} + +API int +efl_util_screenshot_deinitialize(efl_util_screenshot_h screenshot) +{ + _screenshot_mutex_lock(); - XDamageSubtract(screenshot->dpy, screenshot->damage, None, None ); + if (!screenshot) + { + _screenshot_mutex_unlock(); + _screenshot_mutex_destory(); + return EFL_UTIL_ERROR_INVALID_PARAMETER; } -fail: + free(screenshot); + g_screenshot = NULL; - if (t_bo) - tbm_bo_unref(t_bo); - if (bufs) - free(bufs); + _efl_util_wl_screenshooter_deinit(); - set_last_result(EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL); + _screenshot_mutex_unlock(); + _screenshot_mutex_destory(); + + return EFL_UTIL_ERROR_NONE; +} - return NULL; -#endif -#if WAYLAND +API tbm_surface_h +efl_util_screenshot_take_tbm_surface(efl_util_screenshot_h screenshot) +{ tbm_surface_h t_surface = NULL; struct wl_buffer *buffer = NULL; Efl_Util_Wl_Output_Info *output; int ret = 0; - if (screenshot != g_screenshot) + _screenshot_mutex_lock(); + + if (!screenshot || (screenshot != g_screenshot)) { set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); + _screenshot_mutex_unlock(); return NULL; } output = eina_list_nth(_eflutil.wl.shot.output_list, 0); if (!output) { - fprintf(stderr, "[screenshot] fail: no output for screenshot\n"); + fprintf(stderr, "[screenshot] fail: no output for screenshot\n"); /* LCOV_EXCL_LINE */ goto fail; } t_surface = tbm_surface_create(screenshot->width, screenshot->height, TBM_FORMAT_XRGB8888); if (!t_surface) { - fprintf(stderr, "[screenshot] fail: tbm_surface_create\n"); + fprintf(stderr, "[screenshot] fail: tbm_surface_create\n"); /* LCOV_EXCL_LINE */ goto fail; } buffer = wayland_tbm_client_create_buffer(_eflutil.wl.shot.tbm_client, t_surface); if (!buffer) { - fprintf(stderr, "[screenshot] fail: create wl_buffer for screenshot\n"); + fprintf(stderr, "[screenshot] fail: create wl_buffer for screenshot\n"); /* LCOV_EXCL_LINE */ goto fail; } - screenshooter_shoot(_eflutil.wl.shot.screenshooter, output->output, buffer); + tizen_screenshooter_shoot(_eflutil.wl.shot.tz_screenshooter, output->output, buffer); screenshot->shot_done = EINA_FALSE; + while (!screenshot->shot_done && ret != -1) - ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue); if (ret == -1) { - fprintf(stderr, "[screenshot] fail: screenshooter_shoot\n"); + fprintf(stderr, "[screenshot] fail: tizen_screenshooter_shoot\n"); /* LCOV_EXCL_LINE */ goto fail; } - wl_buffer_destroy(buffer); + wayland_tbm_client_destroy_buffer(_eflutil.wl.shot.tbm_client, buffer); /* reset shot_done for next screenshot */ screenshot->shot_done = EINA_FALSE; + set_last_result(EFL_UTIL_ERROR_NONE); + + _screenshot_mutex_unlock(); + return t_surface; fail: if (t_surface) tbm_surface_destroy(t_surface); if (buffer) - wl_buffer_destroy(buffer); + wayland_tbm_client_destroy_buffer(_eflutil.wl.shot.tbm_client, buffer); set_last_result(EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL); + _screenshot_mutex_unlock(); + return NULL; -#endif +} + +API int +efl_util_screenshot_set_auto_rotation(efl_util_screenshot_h screenshot, int set) +{ + if (!screenshot || (screenshot != g_screenshot)) + return EFL_UTIL_ERROR_INVALID_PARAMETER; + + if (!(set == 0 || set == 1)) + return EFL_UTIL_ERROR_INVALID_PARAMETER; + + if (set) + g_screenshot->auto_rotation = EINA_TRUE; + else + g_screenshot->auto_rotation = EINA_FALSE; + + tizen_screenshooter_set_oneshot_auto_rotation(_eflutil.wl.shot.tz_screenshooter, g_screenshot->auto_rotation); + + return EFL_UTIL_ERROR_NONE; +} + +API int +efl_util_screenshot_get_auto_rotation(efl_util_screenshot_h screenshot, int *set) +{ + if (!screenshot || (screenshot != g_screenshot) || !set) + return EFL_UTIL_ERROR_INVALID_PARAMETER; + + *set = g_screenshot->auto_rotation; + + return EFL_UTIL_ERROR_NONE; +} + +/* LCOV_EXCL_START */ +struct _efl_util_screenmirror_h +{ + struct tizen_screenmirror *tz_screenmirror; + pthread_t thread; + int width; + int height; + + tbm_bufmgr bufmgr; + Eina_List *buffer_list; + + Eina_Bool mirror_working; + Eina_Bool cb_start; + Eina_Bool cb_stop; + Eina_Bool cb_content; + efl_util_screenmirror_handler user_func; + void *user_data; +}; + +typedef struct _efl_util_mirror_buffer efl_util_mirror_buffer; +struct _efl_util_mirror_buffer +{ + struct wl_buffer *buffer; + int w, h; + tbm_surface_h t_surface; +}; + +static efl_util_screenmirror_h g_screenmirror; + +static void * +_efl_util_screenmirror_loop(void *data) +{ + efl_util_screenmirror_h screenmirror; + int ret = 0; + + screenmirror = (efl_util_screenmirror_h)data; + + while (1) + { + if (!screenmirror->mirror_working) + break; + + ret = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue); + if (ret == -1) + { + fprintf(stderr, "[screenmirror] fail: dispatch_queue\n"); + break; + } + } + + return NULL; +} + +static efl_util_mirror_buffer * +_efl_util_create_mirror_buffer(efl_util_screenmirror_h screenmirror) +{ + efl_util_mirror_buffer *mbuffer; + + mbuffer = calloc(1, sizeof(struct _efl_util_mirror_buffer)); + EINA_SAFETY_ON_NULL_RETURN_VAL(mbuffer, NULL); + + mbuffer->w = screenmirror->width; + mbuffer->h = screenmirror->height; + + mbuffer->t_surface = tbm_surface_internal_create_with_flags(mbuffer->w, + mbuffer->h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT); + EINA_SAFETY_ON_NULL_GOTO(mbuffer->t_surface, fail_create_surface); + + mbuffer->buffer = wayland_tbm_client_create_buffer(_eflutil.wl.shot.tbm_client, mbuffer->t_surface); + EINA_SAFETY_ON_NULL_GOTO(mbuffer->buffer, fail_create_buffer); + + return mbuffer; + +fail_create_buffer: + tbm_surface_destroy(mbuffer->t_surface); +fail_create_surface: + free(mbuffer); + + return NULL; +} + +static void +_efl_util_destroy_mirror_buffer(efl_util_mirror_buffer *mbuffer) +{ + EINA_SAFETY_ON_NULL_RETURN(mbuffer); + + if (mbuffer->buffer) + wl_buffer_destroy(mbuffer->buffer); + + free(mbuffer); +} + +static void +_efl_util_screenmirror_handle_dequeued(void *data, + struct tizen_screenmirror *tz_screenmirror, struct wl_buffer *buffer) +{ + efl_util_screenmirror_h screenmirror; + efl_util_mirror_buffer *mbuffer; + Eina_List *l, *ll; + + screenmirror = (efl_util_screenmirror_h)data; + screenmirror->cb_start = EINA_TRUE; + + EINA_LIST_FOREACH_SAFE(screenmirror->buffer_list, l, ll, mbuffer) + { + if (mbuffer->buffer == buffer) + { + if (mbuffer->w != screenmirror->width || mbuffer->h != screenmirror->height || + !screenmirror->mirror_working) + tbm_surface_destroy(mbuffer->t_surface); + else + screenmirror->user_func(screenmirror, mbuffer->t_surface, screenmirror->user_data); + + screenmirror->buffer_list = eina_list_remove_list(screenmirror->buffer_list, l); + _efl_util_destroy_mirror_buffer(mbuffer); + + break; + } + } + + mbuffer = _efl_util_create_mirror_buffer(screenmirror); + if (mbuffer == NULL) + { + fprintf(stderr, "[screenmirror] fail: buffer create\n"); + return; + } + screenmirror->buffer_list = eina_list_append(screenmirror->buffer_list, mbuffer); + tizen_screenmirror_queue(screenmirror->tz_screenmirror, mbuffer->buffer); +} + +static void +_efl_util_screenmirror_handle_content(void *data, + struct tizen_screenmirror *tz_screenmirror, uint32_t content) +{ + efl_util_screenmirror_h screenmirror = NULL; + + screenmirror = (efl_util_screenmirror_h)data; + screenmirror->cb_content = EINA_TRUE; +} + +static void +_efl_util_screenmirror_handle_stop(void *data, struct tizen_screenmirror *tz_screenmirror) +{ + efl_util_screenmirror_h screenmirror = NULL; + + screenmirror = (efl_util_screenmirror_h)data; + screenmirror->cb_stop = EINA_TRUE; +} + +static const struct tizen_screenmirror_listener efl_util_screenmirror_listener = { + _efl_util_screenmirror_handle_dequeued, + _efl_util_screenmirror_handle_content, + _efl_util_screenmirror_handle_stop +}; + +API efl_util_screenmirror_h +efl_util_screenmirror_initialize(int width, int height) +{ + efl_util_screenmirror_h screenmirror = NULL; + efl_util_mirror_buffer *mbuffer; + Efl_Util_Wl_Output_Info *output; + int ret = 0, i; + + if (width <= 0 || height <= 0) + { + set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); + return NULL; + } + + _screenshot_mutex_lock(); + + if (g_screenmirror) + { + if (g_screenmirror->mirror_working) + { + set_last_result(EFL_UTIL_ERROR_INVALID_OPERATION); + _screenshot_mutex_unlock(); + return NULL; + } + else + { + g_screenmirror->width = width; + g_screenmirror->height = height; + set_last_result(EFL_UTIL_ERROR_NONE); + _screenshot_mutex_unlock(); + return g_screenmirror; + } + } + + screenmirror = calloc(1, sizeof(struct _efl_util_screenmirror_h)); + if (screenmirror == NULL) + { + set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); + _screenshot_mutex_unlock(); + return NULL; + } + + if (!_eflutil.wl.shot.tz_screenshooter) + { + if (_efl_util_wl_screenshooter_init() == EINA_FALSE) + { + if (_eflutil.wl.shot.noti == 0) + set_last_result(EFL_UTIL_ERROR_PERMISSION_DENIED); + else + set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL); + + goto fail_wl_init; + } + } + + output = eina_list_nth(_eflutil.wl.shot.output_list, 0); + if (!output) + { + set_last_result(EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE); + fprintf(stderr, "[screenmirror] fail: no output for screenmirror\n"); + goto fail_get_output; + } + + screenmirror->tz_screenmirror = tizen_screenshooter_get_screenmirror(_eflutil.wl.shot.tz_screenshooter, output->output); + wl_proxy_set_queue((struct wl_proxy *)screenmirror->tz_screenmirror, _eflutil.wl.shot.queue); + tizen_screenmirror_add_listener(screenmirror->tz_screenmirror, &efl_util_screenmirror_listener, screenmirror); + tizen_screenmirror_set_stretch(screenmirror->tz_screenmirror, TIZEN_SCREENMIRROR_STRETCH_KEEP_RATIO); + screenmirror->width = width; + screenmirror->height = height; + + g_screenmirror = screenmirror; + + for (i = 0; i < 1; i++) + { + mbuffer = _efl_util_create_mirror_buffer(screenmirror); + if (mbuffer) + { + screenmirror->buffer_list = eina_list_append(screenmirror->buffer_list, mbuffer); + tizen_screenmirror_queue(screenmirror->tz_screenmirror, mbuffer->buffer); + } + else + fprintf(stderr, "[screenmirror] fail: buffer create %d\n", i); + } + while (!screenmirror->cb_content && ret != -1) + ret = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue); + + _screenshot_mutex_unlock(); + + return screenmirror; + +fail_get_output: +fail_wl_init: + free(screenmirror); + _screenshot_mutex_unlock(); + return NULL; +} + +API int +efl_util_screenmirror_deinitialize(efl_util_screenmirror_h screenmirror) +{ + efl_util_mirror_buffer *mbuffer; + Eina_List *l; + + _screenshot_mutex_lock(); + + if (!screenmirror || (screenmirror != g_screenmirror)) + { + _screenshot_mutex_unlock(); + _screenshot_mutex_destory(); + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + + if (screenmirror->mirror_working) + { + fprintf(stderr, "[screenmirror] fail: execute stop before deinit\n"); + _screenshot_mutex_unlock(); + _screenshot_mutex_destory(); + return EFL_UTIL_ERROR_INVALID_OPERATION; + } + + EINA_LIST_FOREACH(screenmirror->buffer_list, l, mbuffer) + { + tbm_surface_destroy(mbuffer->t_surface); + _efl_util_destroy_mirror_buffer(mbuffer); + } + eina_list_free(screenmirror->buffer_list); + + tizen_screenmirror_destroy(screenmirror->tz_screenmirror); + free(screenmirror); + g_screenmirror = NULL; + + _efl_util_wl_screenshooter_deinit(); + + _screenshot_mutex_unlock(); + _screenshot_mutex_destory(); + + return EFL_UTIL_ERROR_NONE; +} + +API int +efl_util_screenmirror_set_handler(efl_util_screenmirror_h screenmirror, + efl_util_screenmirror_handler func, void *data) +{ + _screenshot_mutex_lock(); + + if (!screenmirror || (screenmirror != g_screenmirror) || !func) + { + _screenshot_mutex_unlock(); + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + screenmirror->user_func = func; + screenmirror->user_data = data; + + _screenshot_mutex_unlock(); + + return EFL_UTIL_ERROR_NONE; +} + +API int +efl_util_screenmirror_start(efl_util_screenmirror_h screenmirror) +{ + int ret = 0; + + _screenshot_mutex_lock(); + + if (!screenmirror || (screenmirror != g_screenmirror)) + { + _screenshot_mutex_unlock(); + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + else if (!screenmirror->user_func) + { + _screenshot_mutex_unlock(); + return EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL; + } + else if (screenmirror->mirror_working) + { + _screenshot_mutex_unlock(); + return EFL_UTIL_ERROR_NONE; + } + + screenmirror->cb_start = EINA_FALSE; + screenmirror->mirror_working = EINA_TRUE; + tizen_screenmirror_start(screenmirror->tz_screenmirror); + while (!screenmirror->cb_start && ret != -1) + ret = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue); + if (ret == -1) + { + fprintf(stderr, "[screenmirror] fail: tizen_screenmirror_start\n"); + _screenshot_mutex_unlock(); + return EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL; + } + + ret = pthread_create(&screenmirror->thread, NULL, _efl_util_screenmirror_loop, screenmirror); + if (ret < 0) + { + fprintf(stderr, "[screenmirror] fail: thread create fail\n"); + _screenshot_mutex_unlock(); + return EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL; + } + + pthread_setname_np(screenmirror->thread, "e_util_mirror"); + + _screenshot_mutex_unlock(); + + return EFL_UTIL_ERROR_NONE; +} + +API int +efl_util_screenmirror_stop(efl_util_screenmirror_h screenmirror) +{ + int ret = 0; + + _screenshot_mutex_lock(); + + if (!screenmirror || (screenmirror != g_screenmirror)) + { + _screenshot_mutex_unlock(); + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + else if (!screenmirror->mirror_working) + { + _screenshot_mutex_unlock(); + return EFL_UTIL_ERROR_NONE; + } + screenmirror->mirror_working = EINA_FALSE; + pthread_join(screenmirror->thread, NULL); + tizen_screenmirror_stop(screenmirror->tz_screenmirror); + screenmirror->cb_stop = EINA_FALSE; + + while (!screenmirror->cb_stop && ret != -1) + ret = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue); + if (ret == -1) + { + fprintf(stderr, "[screenmirror] fail: tizen_screenmirror_stop\n"); + _screenshot_mutex_unlock(); + return EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL; + } + + _screenshot_mutex_unlock(); + + return EFL_UTIL_ERROR_NONE; +} +/* LCOV_EXCL_STOP */ + +struct _efl_util_gesture_h +{ + Eina_Bool init; +}; + +API int EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = 0; +API int EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = 0; +API int EFL_UTIL_EVENT_GESTURE_TAP = 0; +API int EFL_UTIL_EVENT_GESTURE_PALM_COVER = 0; + +/* LCOV_EXCL_START */ +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) +{ + _eflutil_defaultqueue.wl.gesture.request_notified = error; +} + +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) +{ + efl_util_event_gesture_edge_swipe_s *ev = NULL; + + ev = (efl_util_event_gesture_edge_swipe_s *)calloc(1, sizeof(*ev)); + if (!ev) return; + + ev->mode = mode; + + ev->fingers = fingers; + ev->sx = sx; + ev->sy = sy; + ev->edge = edge; + + ecore_event_add(EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE, ev, NULL, NULL); +} + +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) +{ + _eflutil_defaultqueue.wl.gesture.request_notified = error; +} + +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) +{ + efl_util_event_gesture_edge_drag_s *ev = NULL; + + ev = (efl_util_event_gesture_edge_drag_s *)calloc(1, sizeof(*ev)); + if (!ev) return; + + ev->mode = mode; + + ev->fingers = fingers; + ev->cx = cx; + ev->cy = cy; + ev->edge = edge; + + ecore_event_add(EFL_UTIL_EVENT_GESTURE_EDGE_DRAG, ev, NULL, NULL); +} + +static void +_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) +{ + _eflutil_defaultqueue.wl.gesture.request_notified = error; +} + +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) +{ + efl_util_event_gesture_tap_s *ev = NULL; + + ev = (efl_util_event_gesture_tap_s *)calloc(1, sizeof(*ev)); + if (!ev) return; + + ev->mode = mode; + + ev->fingers = fingers; + ev->repeats = repeats; + + ecore_event_add(EFL_UTIL_EVENT_GESTURE_TAP, ev, NULL, NULL); +} +/* LCOV_EXCL_STOP */ + +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) +{ + _eflutil_defaultqueue.wl.gesture.request_notified = error; +} + +/* LCOV_EXCL_START */ +static void +_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) +{ + efl_util_event_gesture_palm_cover_s *ev = NULL; + + ev = (efl_util_event_gesture_palm_cover_s *)calloc(1, sizeof(*ev)); + if (!ev) return; + + ev->mode = mode; + + ev->duration = duration; + ev->cx = cx; + ev->cy = cy; + ev->size = size; + ev->pressure = wl_fixed_to_int(pressure); + + ecore_event_add(EFL_UTIL_EVENT_GESTURE_PALM_COVER, ev, NULL, NULL); +} +/* LCOV_EXCL_STOP */ + +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) +{ + _eflutil_defaultqueue.wl.gesture.request_notified = error; +} + +static efl_util_error_e +_efl_util_gesture_convert_error(int ret) +{ + switch (ret) + { + case TIZEN_GESTURE_ERROR_NONE: + return EFL_UTIL_ERROR_NONE; + case TIZEN_GESTURE_ERROR_INVALID_DATA: + return EFL_UTIL_ERROR_INVALID_PARAMETER; + case TIZEN_GESTURE_ERROR_NO_PERMISSION: + return EFL_UTIL_ERROR_PERMISSION_DENIED; + case TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES: + return EFL_UTIL_ERROR_OUT_OF_MEMORY; + case TIZEN_GESTURE_ERROR_GRABBED_ALREADY: + return EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE; + case TIZEN_GESTURE_ERROR_NOT_SUPPORTED: + return EFL_UTIL_ERROR_NOT_SUPPORTED; + default : + return EFL_UTIL_ERROR_NONE; + } +} + +/* LCOV_EXCL_START */ +static efl_util_error_e +_efl_util_gesture_verify_request_notified() +{ + int ret = EFL_UTIL_ERROR_NONE; + + while (_eflutil_defaultqueue.wl.gesture.request_notified == -1) + wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); + + ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified); + _eflutil_defaultqueue.wl.gesture.request_notified = -1; + + return ret; +} + +static int +_efl_util_gesture_grab_edge_swipe(efl_util_gesture_data data, Eina_Bool grabbed) +{ + int ret = EFL_UTIL_ERROR_NONE; + Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; + Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = NULL; + unsigned int fingers = 0; + unsigned int edge = 0; + unsigned int edge_size = 0; + unsigned int start_point = 0; + unsigned int end_point = 0; + + base_data = (Efl_Util_Gesture_Common_Grab_Data *)data; + + EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_SWIPE, + EFL_UTIL_ERROR_INVALID_PARAMETER); + + edge_swipe_data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)data; + + fingers = edge_swipe_data->fingers; + edge = edge_swipe_data->edge; + edge_size = edge_swipe_data->edge_size; + start_point = edge_swipe_data->start_point; + end_point = edge_swipe_data->end_point; + + if (grabbed) + tizen_gesture_grab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point); + else + tizen_gesture_ungrab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point); + + ret = _efl_util_gesture_verify_request_notified(); + + return ret; +} + +static int +_efl_util_gesture_grab_edge_drag(efl_util_gesture_data data, Eina_Bool grabbed) +{ + int ret = EFL_UTIL_ERROR_NONE; + Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; + Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = NULL; + unsigned int fingers = 0; + unsigned int edge = 0; + unsigned int edge_size = 0; + unsigned int start_point = 0; + unsigned int end_point = 0; + + base_data = (Efl_Util_Gesture_Common_Grab_Data *)data; + + EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_DRAG, + EFL_UTIL_ERROR_INVALID_PARAMETER); + + edge_drag_data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)data; + + fingers = edge_drag_data->fingers; + edge = edge_drag_data->edge; + edge_size = edge_drag_data->edge_size; + start_point = edge_drag_data->start_point; + end_point = edge_drag_data->end_point; + + if (grabbed) + tizen_gesture_grab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point); + else + tizen_gesture_ungrab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point); + + ret = _efl_util_gesture_verify_request_notified(); + + return ret; +} + +static int +_efl_util_gesture_grab_tap(efl_util_gesture_data data, Eina_Bool grabbed) +{ + int ret = EFL_UTIL_ERROR_NONE; + Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; + Efl_Util_Gesture_Tap_Grab_Data *tap_data = NULL; + unsigned int fingers = 0; + unsigned int repeats = 0; + + base_data = (Efl_Util_Gesture_Common_Grab_Data *)data; + + EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_TAP, + EFL_UTIL_ERROR_INVALID_PARAMETER); + + tap_data = (Efl_Util_Gesture_Tap_Grab_Data *)data; + + fingers = tap_data->fingers; + repeats = tap_data->repeats; + + if (grabbed) + tizen_gesture_grab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats); + else + tizen_gesture_ungrab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats); + + ret = _efl_util_gesture_verify_request_notified(); + + return ret; +} + +static int +_efl_util_gesture_grab_palm_cover(efl_util_gesture_data data, Eina_Bool grabbed) +{ + int ret = EFL_UTIL_ERROR_NONE; + Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; + + base_data = (Efl_Util_Gesture_Common_Grab_Data *)data; + + EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_PALM_COVER, + EFL_UTIL_ERROR_INVALID_PARAMETER); + + if (grabbed) + tizen_gesture_grab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto); + else + tizen_gesture_ungrab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto); + + ret = _efl_util_gesture_verify_request_notified(); + + return ret; +} +/* LCOV_EXCL_STOP */ + +API efl_util_gesture_h +efl_util_gesture_initialize(void) +{ + efl_util_gesture_h gesture_h = NULL; + + gesture_h = (efl_util_gesture_h)calloc(1, sizeof(struct _efl_util_gesture_h)); + if (!gesture_h) + { + set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */ + goto out; /* LCOV_EXCL_LINE */ + } + + if (_wl_init_default_queue() == (int)EINA_FALSE) + { + set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED); /* LCOV_EXCL_LINE */ + goto out; /* LCOV_EXCL_LINE */ + } + + while (!_eflutil_defaultqueue.wl.gesture.proto) + wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); /* LCOV_EXCL_LINE */ + + if (_eflutil_defaultqueue.wl.gesture.event_init <= 0) + { + if (ecore_event_init() <= 0) + { + set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED); /* LCOV_EXCL_LINE */ + goto out; /* LCOV_EXCL_LINE */ + } + EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = ecore_event_type_new(); + EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = ecore_event_type_new(); + EFL_UTIL_EVENT_GESTURE_TAP = ecore_event_type_new(); + EFL_UTIL_EVENT_GESTURE_PALM_COVER = ecore_event_type_new(); + } + _eflutil_defaultqueue.wl.gesture.event_init++; + gesture_h->init = EINA_TRUE; + + set_last_result(EFL_UTIL_ERROR_NONE); + return gesture_h; + +out: +/* LCOV_EXCL_START */ + if (gesture_h) + { + free(gesture_h); + gesture_h = NULL; + } + return gesture_h; +/* LCOV_EXCL_STOP */ +} + +API int +efl_util_gesture_deinitialize(efl_util_gesture_h gesture_h) +{ + EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER); + + free(gesture_h); + gesture_h = NULL; + + _eflutil_defaultqueue.wl.gesture.event_init--; + + if (_eflutil_defaultqueue.wl.gesture.event_init <= 0) + { + _eflutil_defaultqueue.wl.gesture.event_init = 0; + ecore_event_shutdown(); + EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = 0; + EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = 0; + EFL_UTIL_EVENT_GESTURE_TAP = 0; + EFL_UTIL_EVENT_GESTURE_PALM_COVER = 0; + } + + return EFL_UTIL_ERROR_NONE; +} + +API efl_util_gesture_data +efl_util_gesture_edge_swipe_new(efl_util_gesture_h gesture_h, unsigned int fingers, efl_util_gesture_edge_e edge) +{ + Efl_Util_Gesture_Edge_Swipe_Grab_Data *data; + + if (!gesture_h || gesture_h->init == EINA_FALSE) + { + set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); + return NULL; + } + + if (edge <= EFL_UTIL_GESTURE_EDGE_NONE || edge > EFL_UTIL_GESTURE_EDGE_LEFT) + { + set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); + return NULL; + } + + data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Edge_Swipe_Grab_Data)); + if (!data) + { + set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */ + return NULL; /* LCOV_EXCL_LINE */ + } + + data->base.type = TIZEN_GESTURE_TYPE_EDGE_SWIPE; + data->fingers = fingers; + data->edge = edge; + data->edge_size = EFL_UTIL_GESTURE_EDGE_SIZE_FULL; + + set_last_result(EFL_UTIL_ERROR_NONE); + + return (void *)data; +} + +API int +efl_util_gesture_edge_swipe_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data) +{ + if (!gesture_h || gesture_h->init == EINA_FALSE) + { + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + + if (!data) + { + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + + free(data); + data = NULL; + + return EFL_UTIL_ERROR_NONE; +} + +API int +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) +{ + Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = data; + + EINA_SAFETY_ON_NULL_RETURN_VAL(edge_swipe_data, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_swipe_data->base.type == TIZEN_GESTURE_TYPE_EDGE_SWIPE, + EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_size == EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, + EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(end_point > start_point, EFL_UTIL_ERROR_INVALID_PARAMETER); + + edge_swipe_data->edge_size = edge_size; + edge_swipe_data->start_point = start_point; + edge_swipe_data->end_point = end_point; + + return EFL_UTIL_ERROR_NONE; +} + +API efl_util_gesture_data +efl_util_gesture_edge_drag_new(efl_util_gesture_h gesture_h, unsigned int fingers, efl_util_gesture_edge_e edge) +{ + Efl_Util_Gesture_Edge_Drag_Grab_Data *data; + + if (!gesture_h || gesture_h->init == EINA_FALSE) + { + set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); + return NULL; + } + + if (edge <= EFL_UTIL_GESTURE_EDGE_NONE || edge > EFL_UTIL_GESTURE_EDGE_LEFT) + { + set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); + return NULL; + } + + data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Edge_Drag_Grab_Data)); + if (!data) + { + set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */ + return NULL; /* LCOV_EXCL_LINE */ + } + + data->base.type = TIZEN_GESTURE_TYPE_EDGE_DRAG; + data->fingers = fingers; + data->edge = edge; + data->edge_size = EFL_UTIL_GESTURE_EDGE_SIZE_FULL; + + set_last_result(EFL_UTIL_ERROR_NONE); + + return (void *)data; +} + +API int +efl_util_gesture_edge_drag_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data) +{ + if (!gesture_h || gesture_h->init == EINA_FALSE) + { + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + + if (!data) + { + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + + free(data); + data = NULL; + + return EFL_UTIL_ERROR_NONE; +} + +API int +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) +{ + Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = data; + + EINA_SAFETY_ON_NULL_RETURN_VAL(edge_drag_data, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_drag_data->base.type == TIZEN_GESTURE_TYPE_EDGE_DRAG, + EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_size == EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, + EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(end_point > start_point, EFL_UTIL_ERROR_INVALID_PARAMETER); + + edge_drag_data->edge_size = edge_size; + edge_drag_data->start_point = start_point; + edge_drag_data->end_point = end_point; + + return EFL_UTIL_ERROR_NONE; +} + +API efl_util_gesture_data +efl_util_gesture_tap_new(efl_util_gesture_h gesture_h, unsigned int fingers, unsigned int repeats) +{ + Efl_Util_Gesture_Tap_Grab_Data *data; + + if (!gesture_h || gesture_h->init == EINA_FALSE) + { + set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); + return NULL; + } + + if (fingers <= 1 || repeats <= 1) + { + set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED); + return NULL; + } + + data = (Efl_Util_Gesture_Tap_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Tap_Grab_Data)); + if (!data) + { + set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */ + return NULL; /* LCOV_EXCL_LINE */ + } + + data->base.type = TIZEN_GESTURE_TYPE_TAP; + data->fingers = fingers; + data->repeats = repeats; + + set_last_result(EFL_UTIL_ERROR_NONE); + + return (void *)data; +} + +API int +efl_util_gesture_tap_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data) +{ + if (!gesture_h || gesture_h->init == EINA_FALSE) + { + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + + if (!data) + { + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + + free(data); + data = NULL; + + return EFL_UTIL_ERROR_NONE; +} + +API efl_util_gesture_data +efl_util_gesture_palm_cover_new(efl_util_gesture_h gesture_h) +{ + Efl_Util_Gesture_Palm_Cover_Grab_Data *data; + + if (!gesture_h || gesture_h->init == EINA_FALSE) + { + set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); + return NULL; + } + + data = (Efl_Util_Gesture_Palm_Cover_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Palm_Cover_Grab_Data)); + if (!data) + { + set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */ + return NULL; /* LCOV_EXCL_LINE */ + } + + data->base.type = TIZEN_GESTURE_TYPE_PALM_COVER; + + set_last_result(EFL_UTIL_ERROR_NONE); + + return (void *)data; +} + +API int +efl_util_gesture_palm_cover_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data) +{ + if (!gesture_h || gesture_h->init == EINA_FALSE) + { + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + + if (!data) + { + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + + free(data); + data = NULL; + + return EFL_UTIL_ERROR_NONE; +} + +/* LCOV_EXCL_START */ +API int +efl_util_gesture_grab(efl_util_gesture_h gesture_h, efl_util_gesture_data data) +{ + int ret = EFL_UTIL_ERROR_NONE; + Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; + + base_data = (Efl_Util_Gesture_Common_Grab_Data *)data; + + EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER); + + switch (base_data->type) + { + case TIZEN_GESTURE_TYPE_EDGE_SWIPE: + ret = _efl_util_gesture_grab_edge_swipe(data, EINA_TRUE); + break; + case TIZEN_GESTURE_TYPE_EDGE_DRAG: + ret = _efl_util_gesture_grab_edge_drag(data, EINA_TRUE); + break; + case TIZEN_GESTURE_TYPE_TAP: + ret = _efl_util_gesture_grab_tap(data, EINA_TRUE); + break; + case TIZEN_GESTURE_TYPE_PALM_COVER: + ret = _efl_util_gesture_grab_palm_cover(data, EINA_TRUE); + break; + default: + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + + return ret; +} + +API int +efl_util_gesture_ungrab(efl_util_gesture_h gesture_h, efl_util_gesture_data data) +{ + int ret = EFL_UTIL_ERROR_NONE; + Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; + + base_data = (Efl_Util_Gesture_Common_Grab_Data *)data; + + EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER); + + switch (base_data->type) + { + case TIZEN_GESTURE_TYPE_EDGE_SWIPE: + ret = _efl_util_gesture_grab_edge_swipe(data, EINA_FALSE); + break; + case TIZEN_GESTURE_TYPE_EDGE_DRAG: + ret = _efl_util_gesture_grab_edge_drag(data, EINA_FALSE); + break; + case TIZEN_GESTURE_TYPE_TAP: + ret = _efl_util_gesture_grab_tap(data, EINA_FALSE); + break; + case TIZEN_GESTURE_TYPE_PALM_COVER: + ret = _efl_util_gesture_grab_palm_cover(data, EINA_FALSE); + break; + default: + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + + return ret; +} +/* LCOV_EXCL_STOP */ + +API int +efl_util_gesture_select(efl_util_gesture_h gesture_h, Evas_Object *window, efl_util_gesture_data data) +{ + Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; + Ecore_Wl2_Window *wlwin; + struct wl_surface *surface; + int ret; + + base_data = (Efl_Util_Gesture_Common_Grab_Data *)data; + + EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER); + + if (base_data->type != TIZEN_GESTURE_TYPE_PALM_COVER) + return EFL_UTIL_ERROR_NOT_SUPPORTED; + + wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window); + if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER; + + surface = ecore_wl2_window_surface_get(wlwin); + EINA_SAFETY_ON_NULL_RETURN_VAL(surface, + EFL_UTIL_ERROR_INVALID_PARAMETER); + + tizen_gesture_select_palm_cover(_eflutil_defaultqueue.wl.gesture.proto, surface); + + ret = _efl_util_gesture_verify_request_notified(); + + return ret; +} + +API int +efl_util_gesture_deselect(efl_util_gesture_h gesture_h, Evas_Object *window, efl_util_gesture_data data) +{ + Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; + Ecore_Wl2_Window *wlwin; + struct wl_surface *surface; + int ret; + + base_data = (Efl_Util_Gesture_Common_Grab_Data *)data; + + EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER); + + if (base_data->type != TIZEN_GESTURE_TYPE_PALM_COVER) + return EFL_UTIL_ERROR_NOT_SUPPORTED; + + wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window); + if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER; + + surface = ecore_wl2_window_surface_get(wlwin); + EINA_SAFETY_ON_NULL_RETURN_VAL(surface, + EFL_UTIL_ERROR_INVALID_PARAMETER); + + tizen_gesture_deselect_palm_cover(_eflutil_defaultqueue.wl.gesture.proto, surface); + + ret = _efl_util_gesture_verify_request_notified(); + + return ret; +} + +/* LCOV_EXCL_START */ +API int +efl_util_gesture_activate_set(efl_util_gesture_h gesture_h, unsigned int type, Eina_Bool active) +{ + int ret; + + EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_TRUE_RETURN_VAL(type == EFL_UTIL_GESTURE_TYPE_NONE, EFL_UTIL_ERROR_INVALID_PARAMETER); + + tizen_gesture_activate_set(_eflutil_defaultqueue.wl.gesture.proto, NULL, type, active); + + ret = _efl_util_gesture_verify_request_notified(); + + return ret; +} +/* LCOV_EXCL_STOP */ + +API int +efl_util_gesture_activate_set_on_window(efl_util_gesture_h gesture_h, Evas_Object *window, unsigned int type, Eina_Bool active) +{ + Ecore_Wl2_Window *wlwin; + struct wl_surface *surface; + int ret; + + EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_TRUE_RETURN_VAL(type == EFL_UTIL_GESTURE_TYPE_NONE, EFL_UTIL_ERROR_INVALID_PARAMETER); + + wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window); + if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER; + + surface = ecore_wl2_window_surface_get(wlwin); + EINA_SAFETY_ON_NULL_RETURN_VAL(surface, + EFL_UTIL_ERROR_INVALID_PARAMETER); + + tizen_gesture_activate_set(_eflutil_defaultqueue.wl.gesture.proto, surface, type, active); + + ret = _efl_util_gesture_verify_request_notified(); + + return ret; }