X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fefl_util.c;h=902b0db1c6daca7cc306c9b7964bec13fb4bab6c;hb=5c722ad18d2d3333d81c04201b08e5c80968df00;hp=98b9ce3bae595fc88bbe0bca64590d66bdf7f732;hpb=e066a10b772c40f06e1a633018a060c4b0756d0d;p=platform%2Fcore%2Fapi%2Fefl-util.git diff --git a/src/efl_util.c b/src/efl_util.c index 98b9ce3..902b0db 100644 --- a/src/efl_util.c +++ b/src/efl_util.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011 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. @@ -11,314 +11,3334 @@ * distributed under the License is distributed on an AS IS BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and - * limitations under the License. + * limitations under the License. */ - #define LOG_TAG "TIZEN_N_EFL_UTIL" #include #include #include #include +#include +#include +#include +#include +#include +#include +#include +#include #include +#include +#include + +#include +#include +#include +#include +#include -#if X11 -#include -#include +#include + +#include +#ifdef LOG_TAG +#undef LOG_TAG #endif -typedef struct _notification_error_cb_info +/* Determine Tizen profile at runtime */ +#include +typedef enum { + TIZEN_PROFILE_UNKNOWN = 0, + TIZEN_PROFILE_MOBILE = 0x1, + TIZEN_PROFILE_WEARABLE = 0x2, + TIZEN_PROFILE_TV = 0x4, + TIZEN_PROFILE_IVI = 0x8, + TIZEN_PROFILE_COMMON = 0x10, +} tizen_profile_t; +static tizen_profile_t profile = TIZEN_PROFILE_UNKNOWN; +static tizen_profile_t _get_tizen_profile() { - Evas_Object *window; - efl_util_notification_window_level_error_cb err_cb; - void *user_data; -} notification_error_cb_info; + char *profileName; + system_info_get_platform_string("http://tizen.org/feature/profile", &profileName); + switch (*profileName) { + case 'm': + case 'M': + profile = TIZEN_PROFILE_MOBILE; + break; + case 'w': + case 'W': + profile = TIZEN_PROFILE_WEARABLE; + break; + case 't': + case 'T': + profile = TIZEN_PROFILE_TV; + break; + case 'i': + case 'I': + profile = TIZEN_PROFILE_IVI; + break; + default: // common or unknown ==> ALL ARE COMMON. + profile = TIZEN_PROFILE_COMMON; + } + free(profileName); -Eina_List *_g_notification_error_cb_info_list; -static Ecore_Event_Handler* _noti_level_access_result_handler = NULL; -static int _noti_handler_count = 0; + return profile; +} +static inline tizen_profile_t get_tizen_profile() +{ + if (__builtin_expect(profile != TIZEN_PROFILE_UNKNOWN, 1)) + return profile; + return _get_tizen_profile(); +} -static notification_error_cb_info *_notification_error_cb_info_find(Evas_Object *window); -static Eina_Bool _efl_util_notification_info_add(Evas_Object *window, efl_util_notification_window_level_error_cb callback, void *user_data); -static Eina_Bool _efl_util_notification_info_del(Evas_Object *window); -#if X11 -static unsigned int _noti_level_access_result_atom = 0; +#define LOG_TAG "TIZEN_N_EFL_UTIL" +#define EFL_UTIL_INPUT_GENERATOR_DEFAULT_TIME_OUT 1000 +#define EFL_UTIL_INPUT_GENERATOR_DEFAULT_DISPATCH_TIME_OUT 10 +#define EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER 10 -static Eina_Bool _efl_util_client_message(void *data, int type, void *event); -static notification_error_cb_info *_notification_error_cb_info_find_by_xwin(unsigned int xwin); -#endif +typedef struct _Efl_Util_Wl_Surface_Lv_Info +{ + void *surface; /* wl_surface */ + int level; + Eina_Bool wait_for_done; + uint32_t state; +} Efl_Util_Wl_Surface_Lv_Info; +typedef struct _Efl_Util_Wl_Surface_Scr_Mode_Info +{ + void *surface; /* wl_surface */ + unsigned int mode; + Eina_Bool wait_for_done; + uint32_t state; +} Efl_Util_Wl_Surface_Scr_Mode_Info; -int efl_util_set_notification_window_level (Evas_Object* window, efl_util_notification_level_e level) -{ - EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); - EINA_SAFETY_ON_FALSE_RETURN_VAL(level >= EFL_UTIL_NOTIFICATION_LEVEL_1 && - level <= EFL_UTIL_NOTIFICATION_LEVEL_3, - EFL_UTIL_ERROR_INVALID_PARAMETER); - -#if X11 - Ecore_X_Window xwin = elm_win_xwindow_get(window); - if (xwin) - { - Ecore_X_Window_Type window_type; - 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(ecore_x_display_get(), xwin, - level); - return EFL_UTIL_ERROR_NONE; - } -#endif +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; -#if ECORE_WAYLAND_FOUND - Ecore_Wl_Window wl_win = elm_win_wl_window_get(window); - if (wl_win) - { - printf("not implemented for wayland yet\n"); - return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE; - } -#endif +typedef struct _Efl_Util_Wl_Output_Info +{ + struct wl_output *output; + int offset_x, offset_y, width, height; +} Efl_Util_Wl_Output_Info; - return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE; -} - - - -int efl_util_get_notification_window_level (Evas_Object* window, efl_util_notification_level_e* level) -{ - - 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 = 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 (ecore_x_display_get(), 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 - { - // fail to get window type - return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE; - } - - return EFL_UTIL_ERROR_NONE; - } -#endif +typedef struct _Efl_Util_Gesture_Common_Grab_Data +{ + int type; +} Efl_Util_Gesture_Common_Grab_Data; -#if ECORE_WAYLAND_FOUND - Ecore_Wl_Window wl_win = elm_win_wl_window_get(window); - if (wl_win) - { - printf("not implemented for wayland yet\n"); - return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE; - } -#endif - return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE; +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; + +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 _Efl_Util_Device_Info +{ + struct tizen_input_device *device; + Ecore_Device_Class clas; + Eina_Stringshare *name; +} Efl_Util_Device_Info; + +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 wl_event_queue *queue; + struct screenshooter *screenshooter; + 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 wl_seat *seat; + struct + { + unsigned int id; + struct tizen_display_policy *proto; + Eina_Hash *hash_brightness; + } display_policy; + } wl; +} Efl_Util_Data; + +typedef struct _Efl_Util_Data_Default_Queue +{ + /* wayland related stuffs */ + struct + { + 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 = +{ + { + EINA_FALSE, + NULL, NULL, NULL, + { 0, NULL, NULL, NULL }, /* tizen_policy protocol */ + { NULL, NULL, NULL, NULL, NULL, 0 }, /* screenshooter protocol */ + { NULL, -1, NULL, NULL, NULL, 0, 0 }, /* tizen_input_device_manager protocol */ + NULL, /* wl_seat protocol */ + { 0, NULL, NULL } /* display_policy protocol */ + }, +}; + +static Efl_Util_Data_Default_Queue _eflutil_defaultqueue = +{ + { + EINA_FALSE, + NULL, NULL, + { 0, NULL, -1, 0 } /* gesture protocol */ + }, +}; + + +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 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); +static void _cb_wl_tz_policy_transient_for_done(void *data, struct tizen_policy *tizen_policy, uint32_t child_id); +static void _cb_wl_tz_policy_scr_mode_done(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface, uint32_t mode, uint32_t state); +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_info(void *data, struct tizen_input_device *tizen_input_device EINA_UNUSED, const char *name, uint32_t clas, uint32_t subclas EINA_UNUSED, struct wl_array *axes EINA_UNUSED); +static void _cb_event_device(void *data EINA_UNUSED, struct tizen_input_device *tizen_input_device EINA_UNUSED, unsigned int serial EINA_UNUSED, const char *name EINA_UNUSED, uint32_t time EINA_UNUSED); +static void _cb_axis(void *data EINA_UNUSED, struct tizen_input_device *tizen_input_device EINA_UNUSED, uint32_t axis_type EINA_UNUSED, wl_fixed_t value EINA_UNUSED); + +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 = +{ + _cb_wl_reg_global, + _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, + _cb_wl_tz_policy_conformant_area, + _cb_wl_tz_policy_notification_done, + _cb_wl_tz_policy_transient_for_done, + _cb_wl_tz_policy_scr_mode_done, + _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, +}; + +static const struct tizen_input_device_listener _wl_tz_input_device_listener = +{ + _cb_device_info, + _cb_event_device, + _cb_axis, +}; + +struct tizen_input_device_manager_listener _wl_tz_devmgr_listener = +{ + _cb_device_add, + _cb_device_remove, + _cb_error, + _cb_block_expired, + _cb_max_touch_count +}; + +struct tizen_display_policy_listener _wl_tz_display_policy_listener = +{ + _cb_wl_tz_display_policy_brightness_done, +}; + +static const struct wl_registry_listener _wl_default_queue_reg_listener = +{ + _cb_wl_default_queue_reg_global, + _cb_wl_default_queue_reg_global_remove +}; + +struct tizen_gesture_listener _wl_tz_gesture_listener = +{ + _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 Eina_Bool +_wl_init(void) +{ + struct wl_display *display_wrapper = NULL; + struct wl_registry *reg = NULL; + + if (_eflutil.wl.init) return EINA_TRUE; + + ecore_wl2_init(); + + _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); + + display_wrapper = wl_proxy_create_wrapper(_eflutil.wl.dpy); + EINA_SAFETY_ON_NULL_GOTO(display_wrapper, fail); + + _eflutil.wl.queue = wl_display_create_queue(_eflutil.wl.dpy); + EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.queue, fail); + + wl_proxy_set_queue((struct wl_proxy *)display_wrapper, _eflutil.wl.queue); + + reg = wl_display_get_registry(display_wrapper); + wl_proxy_wrapper_destroy(display_wrapper); + display_wrapper = NULL; + EINA_SAFETY_ON_NULL_GOTO(reg, fail); + + wl_registry_add_listener(reg, &_wl_reg_listener, NULL); + + _eflutil.wl.init = EINA_TRUE; + + return EINA_TRUE; +fail: + if (display_wrapper) + wl_proxy_wrapper_destroy(display_wrapper); + + if (_eflutil.wl.queue) + { + wl_event_queue_destroy(_eflutil.wl.queue); + _eflutil.wl.queue = NULL; + } + + ecore_wl2_shutdown(); + return EINA_FALSE; } -int efl_util_set_notification_window_level_error_cb(Evas_Object *window, efl_util_notification_window_level_error_cb callback, void *user_data) +static Eina_Bool +_wl_init_default_queue(void) { - Eina_Bool ret = EINA_FALSE; + struct wl_display *display_wrapper = NULL; + struct wl_registry *reg = NULL; - EINA_SAFETY_ON_NULL_RETURN_VAL(window, - EFL_UTIL_ERROR_INVALID_PARAMETER); - EINA_SAFETY_ON_NULL_RETURN_VAL(callback, - EFL_UTIL_ERROR_INVALID_PARAMETER); + if (_eflutil_defaultqueue.wl.init) return EINA_TRUE; - ret = _efl_util_notification_info_add(window, callback, user_data); - if (ret) - { -#if X11 - if (!_noti_level_access_result_atom) - _noti_level_access_result_atom = ecore_x_atom_get("_E_NOTIFICATION_LEVEL_ACCESS_RESULT"); + if (ecore_wl2_init() <= 0) return EINA_FALSE; - if (!_noti_level_access_result_handler) - _noti_level_access_result_handler = ecore_event_handler_add(ECORE_X_EVENT_CLIENT_MESSAGE, _efl_util_client_message, NULL); - _noti_handler_count++; + _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); - return EFL_UTIL_ERROR_NONE; -#endif + display_wrapper = wl_proxy_create_wrapper(_eflutil_defaultqueue.wl.dpy); + EINA_SAFETY_ON_NULL_GOTO(display_wrapper, fail); -#if ECORE_WAYLAND_FOUND - printf("not implemented for wayland yet\n"); - return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE; -#endif - } + reg = wl_display_get_registry(display_wrapper); + wl_proxy_wrapper_destroy(display_wrapper); + display_wrapper = NULL; + EINA_SAFETY_ON_NULL_GOTO(reg, fail); + + wl_registry_add_listener(reg, &_wl_default_queue_reg_listener, NULL); + + _eflutil_defaultqueue.wl.init = EINA_TRUE; + + return EINA_TRUE; +fail: + + ecore_wl2_shutdown(); + return EINA_FALSE; +} + +static void +_cb_wl_output_geometry(void *data, struct wl_output *wl_output, int x, int y, + int physical_width, int physical_height, int subpixel, + const char *make, const char *model, int transform) +{ + Efl_Util_Wl_Output_Info *output = wl_output_get_user_data(wl_output); + if (wl_output == output->output) + { + output->offset_x = x; + output->offset_y = y; + } +} + +static void +_cb_wl_output_mode(void *data, struct wl_output *wl_output, uint32_t flags, + int width, int height, int refresh) +{ + Efl_Util_Wl_Output_Info *output = wl_output_get_user_data(wl_output); + if (wl_output == output->output && (flags & WL_OUTPUT_MODE_CURRENT)) + { + output->width = width; + output->height = height; + } +} + +static void +_cb_wl_output_done(void *data, struct wl_output *wl_output) +{ +} + +static void +_cb_wl_output_scale(void *data, struct wl_output *wl_output, int32_t factor) +{ +} + +static const struct wl_output_listener output_listener = +{ + _cb_wl_output_geometry, + _cb_wl_output_mode, + _cb_wl_output_done, + _cb_wl_output_scale +}; + +static void +_cb_wl_screenshot_done(void *data, struct screenshooter *screenshooter) +{ + Eina_Bool *shot_done = (Eina_Bool*)data; + if (shot_done) + *shot_done = EINA_TRUE; +} + +static const struct screenshooter_listener screenshooter_listener = +{ + _cb_wl_screenshot_done +}; - return EFL_UTIL_ERROR_OUT_OF_MEMORY; +static void +_cb_tz_screenshot_format(void *data, struct tizen_screenshooter *tz_screenshooter, uint32_t format) +{ } -int efl_util_unset_notification_window_level_error_cb(Evas_Object *window) +static void +_cb_tz_screenshot_noti(void *data, struct tizen_screenshooter *tz_screenshooter, uint32_t noti) { - Eina_Bool ret = EINA_FALSE; + _eflutil.wl.shot.noti = noti; +} - EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); +static const struct tizen_screenshooter_listener tz_screenshooter_listener = +{ + _cb_tz_screenshot_format, + _cb_tz_screenshot_noti +}; - ret = _efl_util_notification_info_del(window); - if (ret) - { - _noti_handler_count--; - if (_noti_handler_count == 0) - { - if (_noti_level_access_result_handler) - { - ecore_event_handler_del(_noti_level_access_result_handler); - _noti_level_access_result_handler = NULL; - } - } - return EFL_UTIL_ERROR_NONE; - } +static void +_cb_seat_capabilities(void *data, struct wl_seat *seat, enum wl_seat_capability caps) +{ +} - return EFL_UTIL_ERROR_INVALID_PARAMETER; +static void +_cb_seat_name(void *data, struct wl_seat *seat EINA_UNUSED, const char *name) +{ } -#if X11 -static Eina_Bool _efl_util_client_message(void *data, int type, void *event) +static const struct wl_seat_listener _seat_listener = +{ + _cb_seat_capabilities, + _cb_seat_name, +}; + +static void +_cb_wl_reg_global(void *data, + struct wl_registry *reg, + unsigned int id, + const char *interface, + unsigned int version) { - Ecore_X_Event_Client_Message *ev; + if (!strcmp(interface, "tizen_policy")) + { + struct tizen_policy *proto; + proto = wl_registry_bind(reg, + id, + &tizen_policy_interface, + 7); + if (!proto) return; + + tizen_policy_add_listener(proto, + &_wl_tz_policy_listener, + NULL); + + _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) + { + Efl_Util_Wl_Output_Info *output = calloc(1, sizeof(Efl_Util_Wl_Output_Info)); + EINA_SAFETY_ON_NULL_RETURN(output); + + _eflutil.wl.shot.output_list = eina_list_append(_eflutil.wl.shot.output_list, output); - ev = event; - if (!ev) return ECORE_CALLBACK_PASS_ON; + output->output = wl_registry_bind(reg, id, &wl_output_interface, version); + wl_output_add_listener(output->output, &output_listener, output); + } + else if(strcmp(interface, "wl_seat") == 0) + { + _eflutil.wl.seat = wl_registry_bind(reg, id, &wl_seat_interface, version); + wl_seat_add_listener(_eflutil.wl.seat, &_seat_listener, NULL); + } + else if (strcmp(interface, "tizen_input_device_manager") == 0) + { + _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; - if (ev->message_type == _noti_level_access_result_atom) - { - Ecore_X_Window xwin; - xwin = ev->win; + tizen_display_policy_add_listener(_eflutil.wl.display_policy.proto, + &_wl_tz_display_policy_listener, + NULL); - notification_error_cb_info *cb_info = NULL; - cb_info = _notification_error_cb_info_find_by_xwin(xwin); - if (cb_info) - { - int access = ev->data.l[1]; - if (access == 0) // permission denied - { - if (cb_info->err_cb) - { - cb_info->err_cb(cb_info->window, EFL_UTIL_ERROR_PERMISSION_DENIED, cb_info->user_data); - } - } - } - } + _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 id) +{ + /* 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 */ - return ECORE_CALLBACK_PASS_ON; +static void +_cb_wl_default_queue_reg_global(void *data, + struct wl_registry *reg, + unsigned int id, + const char *interface, + unsigned int version) +{ + 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 */ -static notification_error_cb_info *_notification_error_cb_info_find_by_xwin(unsigned int xwin) + +static void +_cb_wl_reg_screenshooter_global(void *data, + struct wl_registry *reg, + unsigned int name, + const char *interface, + unsigned int version) { - Eina_List *l; - notification_error_cb_info* temp; - unsigned int temp_xwin; + 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_screenshooter") == 0) + { + _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); - EINA_LIST_FOREACH(_g_notification_error_cb_info_list, l, temp) - { - if (temp->window) - { - temp_xwin = elm_win_xwindow_get(temp->window); - if (xwin == temp_xwin) - { - return temp; - } - } - } + 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) +{ } -#endif -static notification_error_cb_info *_notification_error_cb_info_find(Evas_Object *window) +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) +{ +} +/* LCOV_EXCL_STOP */ + +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) +{ + Efl_Util_Wl_Surface_Lv_Info *lv_info; + + lv_info = eina_hash_find(_eflutil.wl.policy.hash_noti_lv, &surface); + if (lv_info) + { + lv_info->level = level; + lv_info->wait_for_done = EINA_FALSE; + lv_info->state = state; + } +} + +/* 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, + struct tizen_policy *tizen_policy, + struct wl_surface *surface, + uint32_t mode, + uint32_t state) +{ + Efl_Util_Wl_Surface_Scr_Mode_Info *scr_mode_info; + + scr_mode_info = eina_hash_find(_eflutil.wl.policy.hash_scr_mode, &surface); + if (scr_mode_info) + { + scr_mode_info->mode = mode; + scr_mode_info->wait_for_done = EINA_FALSE; + scr_mode_info->state = state; + } +} + +/* 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) +{ +} + +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) +{ +} +/* 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) +{ + Efl_Util_Wl_Surface_Lv_Info *lv_info; + + lv_info = data; + if (EINA_UNLIKELY(!lv_info)) + return; + + eina_hash_del(_eflutil.wl.policy.hash_noti_lv, &lv_info->surface, lv_info); +} + +API int +efl_util_set_notification_window_level(Evas_Object *window, + efl_util_notification_level_e level) +{ + Eina_Bool res; + + EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL((level >= EFL_UTIL_NOTIFICATION_LEVEL_NONE) && + (level <= EFL_UTIL_NOTIFICATION_LEVEL_TOP), + EFL_UTIL_ERROR_INVALID_PARAMETER); + + Elm_Win_Type type; + Ecore_Wl2_Window *wlwin; + struct wl_surface *surface; + Efl_Util_Wl_Surface_Lv_Info *lv_info; + Ecore_Wl2_Window_Type wl_type; + + res = _wl_init(); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); + + 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_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_wl2_window_surface_get(wlwin); + EINA_SAFETY_ON_NULL_RETURN_VAL(surface, + EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE); + + lv_info = eina_hash_find(_eflutil.wl.policy.hash_noti_lv, &surface); + if (!lv_info) + { + lv_info = calloc(1, sizeof(Efl_Util_Wl_Surface_Lv_Info)); + EINA_SAFETY_ON_NULL_RETURN_VAL(lv_info, EFL_UTIL_ERROR_OUT_OF_MEMORY); + + lv_info->surface = surface; + lv_info->level = (int)level; + lv_info->wait_for_done = EINA_TRUE; + lv_info->state = TIZEN_POLICY_ERROR_STATE_NONE; + eina_hash_add(_eflutil.wl.policy.hash_noti_lv, + &surface, + lv_info); + + evas_object_event_callback_add(window, EVAS_CALLBACK_DEL, + _cb_window_del, lv_info); + } + else + { + lv_info->level = (int)level; + lv_info->wait_for_done = EINA_TRUE; + lv_info->state = TIZEN_POLICY_ERROR_STATE_NONE; + } + + + tizen_policy_set_notification_level(_eflutil.wl.policy.proto, + surface, (int)level); + + if (lv_info->wait_for_done) + { + int count = 0; + while (lv_info->wait_for_done && (count < 3)) + { + ecore_wl2_display_flush(_eflutil.wl.wl2_display); + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + count++; + } + + if (lv_info->wait_for_done) + { + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + else + { + if (lv_info->state == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED) + { + return EFL_UTIL_ERROR_PERMISSION_DENIED; + } + } + } + + return EFL_UTIL_ERROR_NONE; +} + +API int +efl_util_get_notification_window_level(Evas_Object *window, + efl_util_notification_level_e *level) +{ + Eina_Bool res; + + EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(level, EFL_UTIL_ERROR_INVALID_PARAMETER); + + Elm_Win_Type type; + Ecore_Wl2_Window *wlwin; + struct wl_surface *surface; + Efl_Util_Wl_Surface_Lv_Info *lv_info; + Ecore_Wl2_Window_Type wl_type; + + res = _wl_init(); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); + + 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_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_wl2_window_surface_get(wlwin); + EINA_SAFETY_ON_NULL_RETURN_VAL(surface, + EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE); + + lv_info = eina_hash_find(_eflutil.wl.policy.hash_noti_lv, &surface); + if (lv_info) + { + if (lv_info->wait_for_done) + { + int count = 0; + while ((lv_info->wait_for_done) && (count < 3)) + { + ecore_wl2_display_flush(_eflutil.wl.wl2_display); + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + count++; + } + + if (lv_info->wait_for_done) + { + *level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT; + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + } + + switch (lv_info->level) + { + 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; + case TIZEN_POLICY_LEVEL_HIGH: *level = EFL_UTIL_NOTIFICATION_LEVEL_HIGH; break; + case TIZEN_POLICY_LEVEL_TOP: *level = EFL_UTIL_NOTIFICATION_LEVEL_TOP; break; + default: *level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT; + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + return EFL_UTIL_ERROR_NONE; + } + else + *level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT; + + return EFL_UTIL_ERROR_NONE; +} + +API int +efl_util_set_window_opaque_state(Evas_Object *window, + int opaque) +{ + Eina_Bool res; + + EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(((opaque >= 0) && (opaque <= 1)), + EFL_UTIL_ERROR_INVALID_PARAMETER); + + Ecore_Wl2_Window *wlwin; + struct wl_surface *surface; + + if (!_eflutil.wl.policy.proto) + { + int ret = 0; + + res = _wl_init(); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); + + while (!_eflutil.wl.policy.proto && ret != -1) + ret = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + + EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.policy.proto, EFL_UTIL_ERROR_INVALID_PARAMETER); + } + + wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window); + if (!wlwin) + return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE; + + 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; +} + +API int +efl_util_set_window_screen_mode(Evas_Object *window, + efl_util_screen_mode_e mode) +{ + EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(((mode >= EFL_UTIL_SCREEN_MODE_DEFAULT) && + (mode <= EFL_UTIL_SCREEN_MODE_ALWAYS_ON)), + EFL_UTIL_ERROR_INVALID_PARAMETER); + + Ecore_Wl2_Window *wlwin; + struct wl_surface *surface; + Efl_Util_Wl_Surface_Scr_Mode_Info *scr_mode_info; + Eina_Bool res; + + res = _wl_init(); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); + + 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_wl2_window_surface_get(wlwin); + EINA_SAFETY_ON_NULL_RETURN_VAL(surface, + EFL_UTIL_ERROR_INVALID_PARAMETER); + + scr_mode_info = eina_hash_find(_eflutil.wl.policy.hash_scr_mode, &surface); + if (!scr_mode_info) + { + scr_mode_info = calloc(1, sizeof(Efl_Util_Wl_Surface_Scr_Mode_Info)); + EINA_SAFETY_ON_NULL_RETURN_VAL(scr_mode_info, EFL_UTIL_ERROR_OUT_OF_MEMORY); + + scr_mode_info->surface = surface; + scr_mode_info->mode = (unsigned int)mode; + scr_mode_info->wait_for_done = EINA_TRUE; + scr_mode_info->state = TIZEN_POLICY_ERROR_STATE_NONE; + + eina_hash_add(_eflutil.wl.policy.hash_scr_mode, + &surface, + scr_mode_info); + } + else + { + scr_mode_info->mode = (unsigned int)mode; + scr_mode_info->wait_for_done = EINA_TRUE; + scr_mode_info->state = TIZEN_POLICY_ERROR_STATE_NONE; + } + + tizen_policy_set_window_screen_mode(_eflutil.wl.policy.proto, + surface, (unsigned int)mode); + if (scr_mode_info->wait_for_done) + { + int count = 0; + while (scr_mode_info->wait_for_done && (count < 3)) + { + ecore_wl2_display_flush(_eflutil.wl.wl2_display); + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + count++; + } + + if (scr_mode_info->wait_for_done) + { + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + else + { + if (scr_mode_info->state == TIZEN_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_get_window_screen_mode(Evas_Object *window, + efl_util_screen_mode_e *mode) { - Eina_List *l; - notification_error_cb_info* temp; + EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(mode, EFL_UTIL_ERROR_INVALID_PARAMETER); - EINA_LIST_FOREACH(_g_notification_error_cb_info_list, l, temp) - { - if (temp->window == window) - { - return temp; - } - } + Ecore_Wl2_Window *wlwin; + struct wl_surface *surface; + Efl_Util_Wl_Surface_Scr_Mode_Info *scr_mode_info; + Eina_Bool res; - return NULL; + res = _wl_init(); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); + + 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_wl2_window_surface_get(wlwin); + EINA_SAFETY_ON_NULL_RETURN_VAL(surface, + EFL_UTIL_ERROR_INVALID_PARAMETER); + + scr_mode_info = eina_hash_find(_eflutil.wl.policy.hash_scr_mode, &surface); + if (scr_mode_info) + { + if (scr_mode_info->wait_for_done) + { + while (scr_mode_info->wait_for_done) + { + ecore_wl2_display_flush(_eflutil.wl.wl2_display); + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + } + } + + switch (scr_mode_info->mode) + { + case TIZEN_POLICY_MODE_DEFAULT: *mode = EFL_UTIL_SCREEN_MODE_DEFAULT; break; + case TIZEN_POLICY_MODE_ALWAYS_ON: *mode = EFL_UTIL_SCREEN_MODE_ALWAYS_ON; break; + default: *mode = EFL_UTIL_SCREEN_MODE_DEFAULT; + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + return EFL_UTIL_ERROR_NONE; + } + else + { + *mode = EFL_UTIL_SCREEN_MODE_DEFAULT; + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + } + else + return EFL_UTIL_ERROR_INVALID_PARAMETER; +} + +API int +efl_util_set_window_brightness(Evas_Object *window, int brightness) +{ + 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_FALSE_RETURN_VAL(brightness <= 100, EFL_UTIL_ERROR_INVALID_PARAMETER); + + res = _wl_init(); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); + + 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); + + 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 < 3)) + { + 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; } -static Eina_Bool _efl_util_notification_info_add(Evas_Object *window, efl_util_notification_window_level_error_cb callback, void *user_data) +API int +efl_util_get_window_brightness(Evas_Object *window, int *brightness) { - notification_error_cb_info* _err_info = _notification_error_cb_info_find(window); + Ecore_Wl2_Window *wlwin; + struct wl_surface *surface; + Efl_Util_Wl_Surface_Brightness_Info *brightness_info; + Eina_Bool res; - if (_err_info) - { - _g_notification_error_cb_info_list = eina_list_remove(_g_notification_error_cb_info_list, _err_info); - free(_err_info); - _err_info = NULL; - } + EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(brightness, EFL_UTIL_ERROR_INVALID_PARAMETER); - _err_info = (notification_error_cb_info*)calloc(1, sizeof(notification_error_cb_info)); - if (!_err_info) - { - return EINA_FALSE; - } - _err_info->window = window; - _err_info->err_cb = callback; - _err_info->user_data = user_data; + res = _wl_init(); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER); - _g_notification_error_cb_info_list = eina_list_append(_g_notification_error_cb_info_list, _err_info); + wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window); + if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER; - return EINA_TRUE; + 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; +}; + +static Eina_Bool +_efl_util_input_check_wait_device_full(void) +{ + Eina_List *l, *ll, *l_next; + Efl_Util_Device_Info *dev, *wait_dev; + int wait_cnt = 0; + + wait_cnt = eina_list_count(_eflutil.wl.devmgr.wait_devices); + if (wait_cnt <= 0) return EINA_TRUE; + + EINA_LIST_FOREACH(_eflutil.wl.devmgr.devices, l, dev) + { + EINA_LIST_FOREACH_SAFE(_eflutil.wl.devmgr.wait_devices, ll, l_next, wait_dev) + { + if ((dev->clas == wait_dev->clas) && + (!strncmp(dev->name, wait_dev->name, eina_stringshare_strlen(wait_dev->name)))) + { + eina_stringshare_del(wait_dev->name); + _eflutil.wl.devmgr.wait_devices = eina_list_remove_list(_eflutil.wl.devmgr.wait_devices, ll); + free(wait_dev); + + wait_cnt--; + if (wait_cnt <= 0) return EINA_TRUE; + + break; + } + } + } + + return EINA_FALSE; } -static Eina_Bool _efl_util_notification_info_del(Evas_Object *window) +static Eina_Bool +_efl_util_input_check_wait_device(const char *name, unsigned int type) { - notification_error_cb_info* _err_info = _notification_error_cb_info_find(window); - if (!_err_info) - { - return EINA_FALSE; - } + Eina_List *l, *l_next; + Efl_Util_Device_Info *wait_dev; + int wait_cnt = 0; + + wait_cnt = eina_list_count(_eflutil.wl.devmgr.wait_devices); + if (wait_cnt <= 0) return EINA_TRUE; + + EINA_LIST_FOREACH_SAFE(_eflutil.wl.devmgr.wait_devices, l, l_next, wait_dev) + { + if ((type == wait_dev->clas) && + (!strncmp(name, wait_dev->name, eina_stringshare_strlen(wait_dev->name)))) + { + eina_stringshare_del(wait_dev->name); + _eflutil.wl.devmgr.wait_devices = eina_list_remove_list(_eflutil.wl.devmgr.wait_devices, l); + free(wait_dev); + + wait_cnt--; + if (wait_cnt <= 0) return EINA_TRUE; + + break; + } + } + + return EINA_FALSE; +} + +static void +_cb_device_info(void *data, struct tizen_input_device *tizen_input_device EINA_UNUSED, const char *name, uint32_t clas, uint32_t subclas EINA_UNUSED, struct wl_array *axes EINA_UNUSED) +{ + Efl_Util_Device_Info *dev; + + if (!(dev = data)) return; + dev->clas = (Ecore_Device_Class)clas; + dev->name = eina_stringshare_add(name); + + if (_eflutil.wl.devmgr.wait_timer && + _efl_util_input_check_wait_device(name, clas)) + { + wl_event_source_remove(_eflutil.wl.devmgr.wait_timer); + _eflutil.wl.devmgr.wait_timer = NULL; + } +} + +/* LCOV_EXCL_START */ +static void +_cb_event_device(void *data EINA_UNUSED, struct tizen_input_device *tizen_input_device EINA_UNUSED, unsigned int serial EINA_UNUSED, const char *name EINA_UNUSED, uint32_t time EINA_UNUSED) +{ + ; +} + +static void +_cb_axis(void *data EINA_UNUSED, struct tizen_input_device *tizen_input_device EINA_UNUSED, uint32_t axis_type EINA_UNUSED, wl_fixed_t value EINA_UNUSED) +{ + ; +} +/* 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, + struct wl_seat *seat EINA_UNUSED) +{ + Efl_Util_Device_Info *dev; + + EINA_SAFETY_ON_NULL_RETURN(device); + + dev = (Efl_Util_Device_Info *)calloc(1, sizeof(Efl_Util_Device_Info)); + EINA_SAFETY_ON_NULL_RETURN(dev); + + dev->device = device; + tizen_input_device_add_listener(device, &_wl_tz_input_device_listener, dev); + + _eflutil.wl.devmgr.devices = eina_list_append(_eflutil.wl.devmgr.devices, dev); +} + +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, + struct wl_seat *seat EINA_UNUSED) +{ + Eina_List *l, *l_next; + Efl_Util_Device_Info *dev; + + EINA_LIST_FOREACH_SAFE(_eflutil.wl.devmgr.devices, l, l_next, dev) + { + if (dev->device == device) + { + if (dev->name) eina_stringshare_del(dev->name); + tizen_input_device_release(dev->device); + + _eflutil.wl.devmgr.devices = eina_list_remove_list(_eflutil.wl.devmgr.devices, l); + free(dev); + + break; + } + } +} + +static void +_cb_error(void *data EINA_UNUSED, + struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED, + uint32_t errorcode) +{ + _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) +{ + ; +} +/* 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) +{ + switch (ret) + { + case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE: + return EFL_UTIL_ERROR_NONE; + case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_PERMISSION: + return EFL_UTIL_ERROR_PERMISSION_DENIED; + case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_SYSTEM_RESOURCES: + 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; + } +} + +/* LCOV_EXCL_START */ +static int +_timer_wait(void *data) +{ + Efl_Util_Device_Info *dev; + + _eflutil.wl.devmgr.request_notified = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_SYSTEM_RESOURCES; + + if (eina_list_count(_eflutil.wl.devmgr.wait_devices) > 0) + { + EINA_LIST_FREE(_eflutil.wl.devmgr.wait_devices, dev) + { + eina_stringshare_del(dev->name); + dev->name = NULL; + } + } + + wl_event_source_remove(_eflutil.wl.devmgr.wait_timer); + _eflutil.wl.devmgr.wait_timer = NULL; + + return 1; +} +/* LCOV_EXCL_STOP */ + +static void +_efl_util_input_initialize_wait_device(void) +{ + struct wl_event_loop *loop; + int ret = -1; + + if (_efl_util_input_check_wait_device_full()) return; + + loop = wl_event_loop_create(); + _eflutil.wl.devmgr.wait_timer = wl_event_loop_add_timer(loop, _timer_wait, NULL); + if (_eflutil.wl.devmgr.wait_timer) + { + ret = wl_event_source_timer_update(_eflutil.wl.devmgr.wait_timer, + EFL_UTIL_INPUT_GENERATOR_DEFAULT_TIME_OUT); + if (ret != 0) + { + _timer_wait(NULL); + return; + } + } + + while (_eflutil.wl.devmgr.wait_timer) + { + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + ret = wl_event_loop_dispatch(loop, EFL_UTIL_INPUT_GENERATOR_DEFAULT_DISPATCH_TIME_OUT); + if (ret != 0) _timer_wait(NULL); + } +} + +static void +_efl_util_input_initialize_append_device(const char *name, Ecore_Device_Class clas) +{ + Efl_Util_Device_Info *dev; + + dev = (Efl_Util_Device_Info *)calloc(1, sizeof(Efl_Util_Device_Info)); + EINA_SAFETY_ON_NULL_RETURN(dev); + + dev->name = eina_stringshare_add(name); + dev->clas = clas; + + _eflutil.wl.devmgr.wait_devices = eina_list_append(_eflutil.wl.devmgr.wait_devices, dev); +} + +static void +_efl_util_input_initialize_add_wait_device(const char *name, unsigned int dev_type) +{ + EINA_SAFETY_ON_NULL_RETURN(name); + + if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN) + _efl_util_input_initialize_append_device(name, ECORE_DEVICE_CLASS_TOUCH); + + if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD) + _efl_util_input_initialize_append_device(name, ECORE_DEVICE_CLASS_KEYBOARD); + + if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER) + _efl_util_input_initialize_append_device(name, ECORE_DEVICE_CLASS_MOUSE); +} + +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; + unsigned int clas = 0x0; + + 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; + } + + inputgen_h = (efl_util_inputgen_h)calloc(1, sizeof(struct _efl_util_inputgen_h)); + if (!inputgen_h) + { + set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); + goto out; + } + + inputgen_h->init_type |= dev_type; + + 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, 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; + +out: + if (inputgen_h) + { + free(inputgen_h); + inputgen_h = NULL; + } + return NULL; +} + +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; + unsigned int clas = 0x0; + + 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; + } + + inputgen_h = (efl_util_inputgen_h)calloc(1, sizeof(struct _efl_util_inputgen_h)); + if (!inputgen_h) + { + set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); + goto out; + } + + inputgen_h->init_type |= dev_type; + strncpy(inputgen_h->name, name, 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_with_name(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name); + + 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; + +out: + if (inputgen_h) + { + free(inputgen_h); + inputgen_h = NULL; + } + return NULL; +} + +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; + unsigned int clas = 0x0; + + 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; + } + + inputgen_h = (efl_util_inputgen_h)calloc(1, sizeof(struct _efl_util_inputgen_h)); + if (!inputgen_h) + { + set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); + goto out; + } + + inputgen_h->init_type |= dev_type; + 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_with_name(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name); + + 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) + { + _efl_util_input_initialize_add_wait_device(inputgen_h->name, dev_type); + _efl_util_input_initialize_wait_device(); + if (_eflutil.wl.devmgr.request_notified != -1) + { + 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; + +out: + if (inputgen_h) + { + free(inputgen_h); + inputgen_h = NULL; + } + return NULL; +} + +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; + + 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, 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; + + return ret; +} + +API int +efl_util_input_generate_key(efl_util_inputgen_h inputgen_h, const char *key_name, int pressed) +{ + int ret = EFL_UTIL_ERROR_NONE; + + EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_NULL_RETURN_VAL(key_name, EFL_UTIL_ERROR_INVALID_PARAMETER); + 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); + + 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); + + 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_touch(efl_util_inputgen_h inputgen_h, int idx, + efl_util_input_touch_type_e touch_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(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 (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) + { + 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; + } + + tizen_input_device_manager_generate_touch(_eflutil.wl.devmgr.devicemgr, type, x, y, idx); + + 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; +} + +static int +_efl_util_input_generate_touch_axis_send(unsigned int type, double value) +{ + int ret; + + tizen_input_device_manager_generate_axis(_eflutil.wl.devmgr.devicemgr, type, wl_fixed_from_double(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; +} + +static void +_efl_util_input_generate_touch_axis_cleanup(efl_util_inputgen_h inputgen_h, int idx) +{ + int i; + if (idx >= 0) + { + 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; + } + else + { + for (i = 0; i < EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER; i++) + { + 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; + } + } +} + +static int +_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) +{ + int ret = EFL_UTIL_ERROR_NONE; + + if (!inputgen_h->axis_info) + { + 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); + } + + if (inputgen_h->axis_info[idx].radius_x != radius_x) + { + 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; + } + if (inputgen_h->axis_info[idx].radius_y != radius_y) + { + 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 (inputgen_h->axis_info[idx].pressure != pressure) + { + 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 (inputgen_h->axis_info[idx].angle != angle) + { + 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; + } + if (inputgen_h->axis_info[idx].palm != palm) + { + 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; + } + + return ret; +} + +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; + + 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); + + 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(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; + } + + 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); + + tizen_input_device_manager_generate_touch(_eflutil.wl.devmgr.devicemgr, type, x, y, idx); + + 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_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); + + 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; + } + + tizen_input_device_manager_generate_pointer(_eflutil.wl.devmgr.devicemgr, type, x, y, buttons); + + 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) + { + 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; + } + + 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*/ + } + + shot_mutex_init = EINA_TRUE; + + return EINA_TRUE; +} + +static Eina_Bool +_screenshot_mutex_destory(void) +{ + if (!shot_mutex_init) + return EINA_TRUE; + + if (pthread_mutex_destroy(&shot_lock)) + { + fprintf(stderr, "[screenshot] fail: mutex destory"); /*LCOV_EXCL_LINE*/ + return EINA_FALSE; /*LCOV_EXCL_LINE*/ + } + + shot_mutex_init = EINA_FALSE; + + return EINA_TRUE; +} + +void +_screenshot_mutex_lock(void) +{ + if (!_screenshot_mutex_init()) + return; + + pthread_mutex_lock(&shot_lock); +} + +void +_screenshot_mutex_unlock(void) +{ + pthread_mutex_unlock(&shot_lock); +} + +API efl_util_screenshot_h +efl_util_screenshot_initialize(int width, int height) +{ + efl_util_screenshot_h screenshot = NULL; + struct wl_display *display_wrapper = NULL; + struct wl_registry *reg = NULL; + int ret = 0; + + if (width <= 0 || height <= 0) + { + set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); + return NULL; + } + + _screenshot_mutex_lock(); + + if (!g_screenshot) + { + screenshot = calloc(1, sizeof(struct _efl_util_screenshot_h)); + EINA_SAFETY_ON_NULL_GOTO(screenshot, fail_memory); + } + + if (!_eflutil.wl.shot.screenshooter) + { + ret = _wl_init(); + if (ret == (int)EINA_FALSE) + { + set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); + _screenshot_mutex_unlock(); + if (screenshot) + free(screenshot); + return NULL; + } + wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + + display_wrapper = wl_proxy_create_wrapper(_eflutil.wl.dpy); + EINA_SAFETY_ON_NULL_GOTO(display_wrapper, fail_memory); + + _eflutil.wl.shot.queue = wl_display_create_queue(_eflutil.wl.dpy); + EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.queue, fail_memory); + + wl_proxy_set_queue((struct wl_proxy *)display_wrapper, _eflutil.wl.shot.queue); + + reg = wl_display_get_registry(display_wrapper); + wl_proxy_wrapper_destroy(display_wrapper); + display_wrapper = NULL; + EINA_SAFETY_ON_NULL_GOTO(reg, fail_init); + + wl_registry_add_listener(reg, &_wl_reg_screenshooter_listener, NULL); + + ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue); + EINA_SAFETY_ON_TRUE_GOTO(ret == -1, fail_init); + EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.screenshooter, fail_init); + EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tz_screenshooter, fail_init); + + _eflutil.wl.shot.tbm_client = wayland_tbm_client_init(_eflutil.wl.dpy); + EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tbm_client, fail_init); + + wl_registry_destroy(reg); + reg = NULL; + } + + if (_eflutil.wl.shot.noti == 0) + { + fprintf(stderr, "[screenshot] fail: privilege error\n"); /* LCOV_EXCL_LINE */ + goto fail_init; + } + + 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); + + _screenshot_mutex_unlock(); + + return g_screenshot; + } + + screenshot->width = width; + screenshot->height = height; + screenshot->auto_rotation = EINA_TRUE; + + screenshot->bufmgr = wayland_tbm_client_get_bufmgr(_eflutil.wl.shot.tbm_client); + EINA_SAFETY_ON_NULL_GOTO(screenshot->bufmgr, fail_init); + + g_screenshot = screenshot; + set_last_result(EFL_UTIL_ERROR_NONE); + + screenshooter_set_user_data(_eflutil.wl.shot.screenshooter, &screenshot->shot_done); + + _screenshot_mutex_unlock(); + + return g_screenshot; + +/* LCOV_EXCL_START */ +fail_memory: + if (display_wrapper) + wl_proxy_wrapper_destroy(display_wrapper); + set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); + if (screenshot) + free(screenshot); + _screenshot_mutex_unlock(); + return NULL; + +fail_init: + if (reg) + wl_registry_destroy(reg); + if (screenshot) + { + _screenshot_mutex_unlock(); + efl_util_screenshot_deinitialize(screenshot); + } + if (_eflutil.wl.shot.noti == 0) + set_last_result(EFL_UTIL_ERROR_PERMISSION_DENIED); + else + set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL); + return NULL; +/* LCOV_EXCL_STOP */ +} + +API int +efl_util_screenshot_deinitialize(efl_util_screenshot_h screenshot) +{ + _screenshot_mutex_lock(); + + if (!screenshot) + { + _screenshot_mutex_unlock(); + _screenshot_mutex_destory(); + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + + free(screenshot); + g_screenshot = NULL; + + 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.screenshooter) + { + screenshooter_destroy(_eflutil.wl.shot.screenshooter); + _eflutil.wl.shot.screenshooter = NULL; + } + if (_eflutil.wl.shot.tz_screenshooter) + { + tizen_screenshooter_destroy(_eflutil.wl.shot.tz_screenshooter); + _eflutil.wl.shot.tz_screenshooter = NULL; + } + + if (_eflutil.wl.shot.queue) + { + wl_event_queue_destroy(_eflutil.wl.shot.queue); + _eflutil.wl.shot.queue = NULL; + } + + _screenshot_mutex_unlock(); + _screenshot_mutex_destory(); + + return EFL_UTIL_ERROR_NONE; +} + + +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; + + _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"); /* 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"); /* 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"); /* LCOV_EXCL_LINE */ + goto fail; + } + + screenshooter_shoot(_eflutil.wl.shot.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.shot.queue); + + if (ret == -1) + { + fprintf(stderr, "[screenshot] fail: screenshooter_shoot\n"); /* LCOV_EXCL_LINE */ + goto fail; + } + + 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) + 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; +} + +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; +} + +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 int +_efl_util_gesture_grab_edge_swipe(efl_util_gesture_data data) +{ + 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; + + tizen_gesture_grab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point); + + 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_ungrab_edge_swipe(efl_util_gesture_data data) +{ + 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; + + tizen_gesture_ungrab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point); + + 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_drag(efl_util_gesture_data data) +{ + 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; + + tizen_gesture_grab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point); + + 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_ungrab_edge_drag(efl_util_gesture_data data) +{ + 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; + + tizen_gesture_ungrab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point); + + 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_tap(efl_util_gesture_data data) +{ + 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; + + tizen_gesture_grab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats); + + 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_ungrab_tap(efl_util_gesture_data data) +{ + 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; + + tizen_gesture_ungrab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats); + + 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_palm_cover(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(_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); + + tizen_gesture_grab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto); + + 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_ungrab_palm_cover(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(_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); + + tizen_gesture_ungrab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto); + + 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; +} +/* 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); + break; + case TIZEN_GESTURE_TYPE_EDGE_DRAG: + ret = _efl_util_gesture_grab_edge_drag(data); + break; + case TIZEN_GESTURE_TYPE_TAP: + ret = _efl_util_gesture_grab_tap(data); + break; + case TIZEN_GESTURE_TYPE_PALM_COVER: + ret = _efl_util_gesture_grab_palm_cover(data); + 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_ungrab_edge_swipe(data); + break; + case TIZEN_GESTURE_TYPE_EDGE_DRAG: + ret = _efl_util_gesture_ungrab_edge_drag(data); + break; + case TIZEN_GESTURE_TYPE_TAP: + ret = _efl_util_gesture_ungrab_tap(data); + break; + case TIZEN_GESTURE_TYPE_PALM_COVER: + ret = _efl_util_gesture_ungrab_palm_cover(data); + 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); + + 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; +} + +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); + + 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; +} + +/* 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); + + 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; +} +/* 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); + + while (_eflutil_defaultqueue.wl.gesture.request_notified == -1) + wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); - _g_notification_error_cb_info_list = eina_list_remove(_g_notification_error_cb_info_list, _err_info); - free(_err_info); + ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified); + _eflutil_defaultqueue.wl.gesture.request_notified = -1; - return EINA_TRUE; + return ret; }