/*
- * 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.
* 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 _GNU_SOURCE
#define LOG_TAG "TIZEN_N_EFL_UTIL"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <xf86drm.h>
+#include <tbm_bufmgr.h>
+#include <tbm_surface.h>
+#include <tbm_surface_internal.h>
#include <Elementary.h>
+#include <Ecore_Evas.h>
+#include <pthread.h>
-#if X11
-#include <Ecore_X.h>
-#include <utilX.h>
+#include <Ecore_Wl2.h>
+#include <wayland-client.h>
+#include <wayland-tbm-client.h>
+#include <tizen-extension-client-protocol.h>
+
+#include <efl_util_screenshot_extension.h>
+
+#include <dlog.h>
+#ifdef LOG_TAG
+#undef LOG_TAG
#endif
-#if WAYLAND
-#include <Ecore_Wayland.h>
-#include <wayland-client.h>
-#include "tizen_notification-client-protocol.h"
-#endif
+#define LOG_TAG "TIZEN_N_EFL_UTIL"
+#define EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER 10
+
+#define NUM_EVENT_WAIT_DONE_COUNT 10
+
+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;
+
+typedef struct _Efl_Util_Wl_Surface_Brightness_Info
+{
+ void *surface; /* wl_surface */
+ int brightness;
+ Eina_Bool wait_for_done;
+ uint32_t state;
+} Efl_Util_Wl_Surface_Brightness_Info;
+
+typedef struct _Efl_Util_Wl_Output_Info
+{
+ struct wl_output *output;
+ int offset_x, offset_y, width, height;
+} Efl_Util_Wl_Output_Info;
+
+typedef struct _Efl_Util_Gesture_Common_Grab_Data
+{
+ int type;
+} Efl_Util_Gesture_Common_Grab_Data;
+
+typedef struct _Efl_Util_Gesture_Edge_Swipe_Grab_Data
+{
+ Efl_Util_Gesture_Common_Grab_Data base;
+
+ unsigned int fingers;
+ efl_util_gesture_edge_e edge;
+ efl_util_gesture_edge_size_e edge_size;
+ unsigned int start_point;
+ unsigned int end_point;
+} Efl_Util_Gesture_Edge_Swipe_Grab_Data;
+
+typedef struct _Efl_Util_Gesture_Edge_Drag_Grab_Data
+{
+ Efl_Util_Gesture_Common_Grab_Data base;
+
+ unsigned int fingers;
+ efl_util_gesture_edge_e edge;
+ efl_util_gesture_edge_size_e edge_size;
+ unsigned int start_point;
+ unsigned int end_point;
+} Efl_Util_Gesture_Edge_Drag_Grab_Data;
+
+typedef struct _Efl_Util_Gesture_Tap_Grab_Data
+{
+ Efl_Util_Gesture_Common_Grab_Data base;
+
+ unsigned int fingers;
+ unsigned int repeats;
+} Efl_Util_Gesture_Tap_Grab_Data;
+
+typedef struct _Efl_Util_Gesture_Palm_Cover_Grab_Data
+{
+ Efl_Util_Gesture_Common_Grab_Data base;
+} Efl_Util_Gesture_Palm_Cover_Grab_Data;
+
+typedef struct _E_Devicemgr_Inputgen_Touch_Axis
+{
+ double radius_x;
+ double radius_y;
+ double pressure;
+ double angle;
+ double palm;
+} E_Devicemgr_Inputgen_Touch_Axis;
+
+typedef struct _Efl_Util_Data
+{
+ /* wayland related stuffs */
+ struct
+ {
+ Eina_Bool init;
+ Ecore_Wl2_Display *wl2_display;
+ struct wl_display *dpy;
+ struct wl_event_queue *queue;
+
+ struct
+ {
+ unsigned int id;
+ struct tizen_policy *proto;
+ Eina_Hash *hash_noti_lv;
+ Eina_Hash *hash_scr_mode;
+ } policy;
+ struct
+ {
+ struct wl_event_queue *queue;
+ struct tizen_screenshooter *tz_screenshooter;
+ struct wayland_tbm_client *tbm_client;
+ Eina_List *output_list;
+ uint32_t noti;
+ } shot;
+ struct
+ {
+ struct tizen_input_device_manager *devicemgr;
+ int request_notified;
+ Eina_List *devices;
+ Eina_List *wait_devices;
+ struct wl_event_source *wait_timer;
+ int max_touch_count;
+ int request_touch_count;
+ } devmgr;
+ struct
+ {
+ unsigned int id;
+ struct tizen_display_policy *proto;
+ Eina_Hash *hash_brightness;
+ } display_policy;
+ } wl;
+} 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;
+ struct
+ {
+ efl_util_gesture_edge_swipe_cb func;
+ void *data;
+ } edge_swipe_cb;
+ struct
+ {
+ efl_util_gesture_edge_drag_cb func;
+ void *data;
+ } edge_drag_cb;
+ struct
+ {
+ efl_util_gesture_tap_cb func;
+ void *data;
+ } tap_cb;
+ struct
+ {
+ efl_util_gesture_palm_cover_cb func;
+ void *data;
+ } palm_cover_cb;
+ } 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, 0 }, /* screenshooter protocol */
+ { NULL, -1, NULL, NULL, NULL, 0, 0 }, /* tizen_input_device_manager 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_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,
+};
+
+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;
+}
+
+static Eina_Bool
+_wl_init_default_queue(void)
+{
+ struct wl_display *display_wrapper = NULL;
+ struct wl_registry *reg = NULL;
+
+ if (_eflutil_defaultqueue.wl.init) return EINA_TRUE;
+
+ if (ecore_wl2_init() <= 0) return EINA_FALSE;
+
+ _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);
+
+ display_wrapper = wl_proxy_create_wrapper(_eflutil_defaultqueue.wl.dpy);
+ EINA_SAFETY_ON_NULL_GOTO(display_wrapper, fail);
+
+ 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_tz_screenshot_format(void *data, struct tizen_screenshooter *tz_screenshooter, uint32_t format)
+{
+}
+
+static void
+_cb_tz_screenshot_noti(void *data, struct tizen_screenshooter *tz_screenshooter, uint32_t noti)
+{
+ _eflutil.wl.shot.noti = noti;
+}
+
+static void
+_cb_tz_screenshot_done(void *data, struct tizen_screenshooter *tz_screenshooter)
+{
+ Eina_Bool *shot_done = (Eina_Bool*)data;
+ if (shot_done)
+ *shot_done = EINA_TRUE;
+}
+
+static const struct tizen_screenshooter_listener tz_screenshooter_listener =
+{
+ _cb_tz_screenshot_format,
+ _cb_tz_screenshot_noti,
+ _cb_tz_screenshot_done,
+};
+
+static void
+_cb_wl_reg_global(void *data,
+ struct wl_registry *reg,
+ unsigned int id,
+ const char *interface,
+ unsigned int version)
+{
+ 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);
+
+ output->output = wl_registry_bind(reg, id, &wl_output_interface, version);
+ wl_output_add_listener(output->output, &output_listener, output);
+ }
+ 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;
+
+ tizen_display_policy_add_listener(_eflutil.wl.display_policy.proto,
+ &_wl_tz_display_policy_listener,
+ NULL);
+
+ _eflutil.wl.display_policy.hash_brightness = eina_hash_pointer_new(free);
+ _eflutil.wl.display_policy.id = id;
+ }
+}
+/* LCOV_EXCL_START */
+static void
+_cb_wl_reg_global_remove(void *data,
+ struct wl_registry *reg,
+ unsigned int 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 */
+
+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 void
+_cb_wl_reg_screenshooter_global(void *data,
+ struct wl_registry *reg,
+ unsigned int name,
+ const char *interface,
+ unsigned int version)
+{
+ if (strcmp(interface, "tizen_screenshooter") == 0)
+ {
+ _eflutil.wl.shot.tz_screenshooter = wl_registry_bind(reg, name, &tizen_screenshooter_interface, version);
+ tizen_screenshooter_add_listener(_eflutil.wl.shot.tz_screenshooter, &tz_screenshooter_listener, NULL);
+
+ wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
+ }
+}
+
+/* LCOV_EXCL_START */
+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)
+{
+}
+/* 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;
+ int ret_dispatch = 0;
+
+ 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 && (ret_dispatch != -1))
+ ret_dispatch = 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;
+ ret_dispatch = 0;
+ while (lv_info->wait_for_done && (count < NUM_EVENT_WAIT_DONE_COUNT) && (ret_dispatch != -1))
+ {
+ ecore_wl2_display_flush(_eflutil.wl.wl2_display);
+ ret_dispatch = 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;
+ int ret_dispatch = 0;
+
+ 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 && (ret_dispatch != -1))
+ ret_dispatch = 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;
+ ret_dispatch = 0;
+ while ((lv_info->wait_for_done) && (count < NUM_EVENT_WAIT_DONE_COUNT) && (ret_dispatch != -1))
+ {
+ ecore_wl2_display_flush(_eflutil.wl.wl2_display);
+ ret_dispatch = 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;
+ int ret_dispatch = 0;
+
+ 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 && (ret_dispatch != -1))
+ ret_dispatch = 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;
+ ret_dispatch = 0;
+ while (scr_mode_info->wait_for_done && (count < NUM_EVENT_WAIT_DONE_COUNT) && (ret_dispatch != -1))
+ {
+ ecore_wl2_display_flush(_eflutil.wl.wl2_display);
+ ret_dispatch = 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_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(mode, 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;
+ int ret_dispatch = 0;
+
+ 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 && (ret_dispatch != -1))
+ ret_dispatch = 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)
+ {
+ ret_dispatch = 0;
+ while (scr_mode_info->wait_for_done && (ret_dispatch != -1))
+ {
+ ecore_wl2_display_flush(_eflutil.wl.wl2_display);
+ ret_dispatch = 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;
+ int ret_dispatch = 0;
+
+ 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 && (ret_dispatch != -1))
+ ret_dispatch = 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;
+ ret_dispatch = 0;
+ while (brightness_info->wait_for_done && (count < NUM_EVENT_WAIT_DONE_COUNT) && (ret_dispatch != -1))
+ {
+ ecore_wl2_display_flush(_eflutil.wl.wl2_display);
+ ret_dispatch = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+ count++;
+ }
+
+ if (brightness_info->wait_for_done)
+ {
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+ else
+ {
+ if (brightness_info->state == TIZEN_DISPLAY_POLICY_ERROR_STATE_PERMISSION_DENIED)
+ {
+ return EFL_UTIL_ERROR_PERMISSION_DENIED;
+ }
+ }
+ }
+ return EFL_UTIL_ERROR_NONE;
+ }
+ else
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+}
+
+API int
+efl_util_get_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;
+ int ret_dispatch = 0;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(brightness, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ res = _wl_init();
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
+ if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
+
+ while (!_eflutil.wl.display_policy.proto && (ret_dispatch != -1))
+ ret_dispatch = 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)
+ {
+ ret_dispatch = 0;
+ while (brightness_info->wait_for_done && (ret_dispatch != -1))
+ {
+ ecore_wl2_display_flush(_eflutil.wl.wl2_display);
+ ret_dispatch = 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 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)
+{
+ ;
+}
+
+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)
+{
+ ;
+}
+
+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;
+ }
+}
+
+static efl_util_inputgen_h
+_efl_util_input_create_inputgen(unsigned int dev_type, const char *name, int *ret, int with_name)
+{
+ efl_util_inputgen_h inputgen_h = NULL;
+ unsigned int clas = 0x0;
+ int ret_dispatch = 0;
+
+ 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 (with_name)
+ {
+ if (name) strncpy(inputgen_h->name, name, 31);
+ else strncpy(inputgen_h->name, "Input Generator", 31);
+ }
+
+ *ret = _wl_init();
+ if (*ret == (int)EINA_FALSE)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ goto out;
+ }
+
+ if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
+ clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN;
+ if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
+ clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD;
+ if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
+ clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE;
+
+ while (!_eflutil.wl.devmgr.devicemgr && (ret_dispatch != -1))
+ ret_dispatch = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ if (with_name == 2)
+ tizen_input_device_manager_init_generator_with_sync(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name);
+ else if (with_name == 1)
+ tizen_input_device_manager_init_generator_with_name(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name);
+ else
+ tizen_input_device_manager_init_generator(_eflutil.wl.devmgr.devicemgr, clas);
+
+ ret_dispatch = 0;
+ while ((_eflutil.wl.devmgr.request_notified == -1) && (ret_dispatch != -1))
+ ret_dispatch = 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(unsigned int dev_type)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ efl_util_inputgen_h inputgen_h = NULL;
+
+ inputgen_h = _efl_util_input_create_inputgen(dev_type, NULL, &ret, 0);
+ if (!inputgen_h)
+ return NULL;
+
+ return inputgen_h;
+}
+
+API efl_util_inputgen_h
+efl_util_input_initialize_generator_with_name(unsigned int dev_type, const char *name)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ efl_util_inputgen_h inputgen_h = NULL;
+
+ inputgen_h = _efl_util_input_create_inputgen(dev_type, name, &ret, 1);
+ if (!inputgen_h)
+ return NULL;
+
+ return inputgen_h;
+}
+
+API efl_util_inputgen_h
+efl_util_input_initialize_generator_with_sync(unsigned int dev_type, const char *name)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ efl_util_inputgen_h inputgen_h = NULL;
+
+ inputgen_h = _efl_util_input_create_inputgen(dev_type, name, &ret, 2);
+ if (!inputgen_h)
+ return NULL;
+
+ return inputgen_h;
+}
+
+API int
+efl_util_input_set_touch_count(int max_count)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ int ret_dispatch = 0;
+
+ ret = _wl_init();
+ if (ret == (int)EINA_FALSE)
+ {
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ while (!_eflutil.wl.devmgr.devicemgr && (ret_dispatch != -1))
+ ret_dispatch = 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);
+
+ ret_dispatch = 0;
+ while ((_eflutil.wl.devmgr.request_notified == -1) && (ret_dispatch != -1))
+ ret_dispatch = 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;
+ int ret_dispatch = 0;
+ 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) && (ret_dispatch != -1))
+ ret_dispatch = 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;
+ int ret_dispatch = 0;
+
+ 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) && (ret_dispatch != -1))
+ ret_dispatch = 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;
+ int ret_dispatch = 0;
+ 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 (_eflutil.wl.devmgr.request_touch_count != 0 &&
+ _eflutil.wl.devmgr.max_touch_count != _eflutil.wl.devmgr.request_touch_count)
+ ret_dispatch = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ 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) && (ret_dispatch != -1))
+ ret_dispatch = 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;
+ int ret_dispatch = 0;
+
+ tizen_input_device_manager_generate_axis(_eflutil.wl.devmgr.devicemgr, type, wl_fixed_from_double(value));
+
+ while ((_eflutil.wl.devmgr.request_notified == -1) && (ret_dispatch != -1))
+ ret_dispatch = 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;
+ int ret_dispatch = 0;
+ 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) && (ret_dispatch != -1))
+ ret_dispatch = 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;
+ int ret_dispatch = 0;
+ 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) && (ret_dispatch != -1))
+ ret_dispatch = 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;
+ int ret_dispatch = 0;
+ 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) && (ret_dispatch != -1))
+ ret_dispatch = 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);
+}
+
+static Eina_Bool
+_efl_util_wl_screenshooter_init()
+{
+ struct wl_display *display_wrapper = NULL;
+ struct wl_registry *registry = NULL;
+ int ret = 0;
+
+ if (_wl_init() == EINA_FALSE)
+ return EINA_FALSE;
+
+ wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ display_wrapper = wl_proxy_create_wrapper(_eflutil.wl.dpy);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(display_wrapper, EINA_FALSE);
+
+ _eflutil.wl.shot.queue = wl_display_create_queue(_eflutil.wl.dpy);
+ EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.queue, fail_create_queue);
+
+ wl_proxy_set_queue((struct wl_proxy *)display_wrapper, _eflutil.wl.shot.queue);
+
+ registry = wl_display_get_registry(display_wrapper);
+ EINA_SAFETY_ON_NULL_GOTO(registry, fail_get_registry);
+
+ wl_registry_add_listener(registry, &_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_roundtrip);
+ EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tz_screenshooter, fail_roundtrip);
+
+ _eflutil.wl.shot.tbm_client = wayland_tbm_client_init(_eflutil.wl.dpy);
+ EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tbm_client, fail_tbm_client_init);
+
+ wl_registry_destroy(registry);
+ wl_proxy_wrapper_destroy(display_wrapper);
+
+ if (_eflutil.wl.shot.noti == 0)
+ {
+ fprintf(stderr, "[screenshot] fail: privilege error\n"); /* LCOV_EXCL_LINE */
+ return EINA_FALSE;
+ }
+
+ return EINA_TRUE;
+
+fail_tbm_client_init:
+ tizen_screenshooter_destroy(_eflutil.wl.shot.tz_screenshooter);
+ _eflutil.wl.shot.tz_screenshooter = NULL;
+fail_roundtrip:
+ wl_registry_destroy(registry);
+fail_get_registry:
+ wl_event_queue_destroy(_eflutil.wl.shot.queue);
+ _eflutil.wl.shot.queue = NULL;
+fail_create_queue:
+ wl_proxy_wrapper_destroy(display_wrapper);
+
+ return EINA_FALSE;
+}
+
+static void
+_efl_util_wl_screenshooter_deinit()
+{
+ if (_eflutil.wl.shot.tbm_client)
+ {
+ wayland_tbm_client_deinit(_eflutil.wl.shot.tbm_client);
+ _eflutil.wl.shot.tbm_client = NULL;
+ }
+
+ if (_eflutil.wl.shot.tz_screenshooter)
+ {
+ tizen_screenshooter_destroy(_eflutil.wl.shot.tz_screenshooter);
+ _eflutil.wl.shot.tz_screenshooter = NULL;
+ }
+
+ if (_eflutil.wl.shot.queue)
+ {
+ wl_event_queue_destroy(_eflutil.wl.shot.queue);
+ _eflutil.wl.shot.queue = NULL;
+ }
+}
+
+API efl_util_screenshot_h
+efl_util_screenshot_initialize(int width, int height)
+{
+ efl_util_screenshot_h screenshot = NULL;
+
+ if (width <= 0 || height <= 0)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ return NULL;
+ }
+
+ _screenshot_mutex_lock();
+
+ 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 = calloc(1, sizeof(struct _efl_util_screenshot_h));
+ if (screenshot == NULL)
+ {
+ set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
+
+ _screenshot_mutex_unlock();
+
+ return NULL;
+ }
+
+ if (!_eflutil.wl.shot.tz_screenshooter)
+ {
+ if (_efl_util_wl_screenshooter_init() == EINA_FALSE)
+ {
+ if (_eflutil.wl.shot.noti == 0)
+ set_last_result(EFL_UTIL_ERROR_PERMISSION_DENIED);
+ else
+ set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL);
+
+ free(screenshot);
+
+ _screenshot_mutex_unlock();
+
+ return NULL;
+ }
+ }
+
+ 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_get_bufmgr);
+
+ g_screenshot = screenshot;
+ set_last_result(EFL_UTIL_ERROR_NONE);
+
+ tizen_screenshooter_set_user_data(_eflutil.wl.shot.tz_screenshooter, &screenshot->shot_done);
+
+ _screenshot_mutex_unlock();
+
+ return g_screenshot;
+
+/* LCOV_EXCL_START */
+fail_get_bufmgr:
+ set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL);
+ _screenshot_mutex_unlock();
+ efl_util_screenshot_deinitialize(screenshot);
+
+ return NULL;
+/* LCOV_EXCL_STOP */
+}
+
+API int
+efl_util_screenshot_deinitialize(efl_util_screenshot_h screenshot)
+{
+ _screenshot_mutex_lock();
+
+ if (!screenshot)
+ {
+ _screenshot_mutex_unlock();
+ _screenshot_mutex_destory();
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ free(screenshot);
+ g_screenshot = NULL;
+
+ _efl_util_wl_screenshooter_deinit();
+
+ _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;
+ }
+
+ tizen_screenshooter_shoot(_eflutil.wl.shot.tz_screenshooter, output->output, buffer);
+
+ screenshot->shot_done = EINA_FALSE;
+
+ while (!screenshot->shot_done && ret != -1)
+ ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
+
+ if (ret == -1)
+ {
+ fprintf(stderr, "[screenshot] fail: tizen_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;
+}
+
+/* LCOV_EXCL_START */
+struct _efl_util_screenmirror_h
+{
+ struct tizen_screenmirror *tz_screenmirror;
+ pthread_t thread;
+ int width;
+ int height;
+
+ tbm_bufmgr bufmgr;
+ Eina_List *buffer_list;
+
+ Eina_Bool mirror_working;
+ Eina_Bool cb_start;
+ Eina_Bool cb_stop;
+ Eina_Bool cb_content;
+ efl_util_screenmirror_handler user_func;
+ void *user_data;
+};
+
+typedef struct _efl_util_mirror_buffer efl_util_mirror_buffer;
+struct _efl_util_mirror_buffer
+{
+ struct wl_buffer *buffer;
+ int w, h;
+ tbm_surface_h t_surface;
+};
+
+static efl_util_screenmirror_h g_screenmirror;
+
+static void *
+_efl_util_screenmirror_loop(void *data)
+{
+ efl_util_screenmirror_h screenmirror;
+ int ret = 0;
+
+ screenmirror = (efl_util_screenmirror_h)data;
+
+ while (1)
+ {
+ if (!screenmirror->mirror_working)
+ break;
+
+ ret = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
+ if (ret == -1)
+ {
+ fprintf(stderr, "[screenmirror] fail: dispatch_queue\n");
+ break;
+ }
+ }
+
+ return NULL;
+}
+
+static efl_util_mirror_buffer *
+_efl_util_create_mirror_buffer(efl_util_screenmirror_h screenmirror)
+{
+ efl_util_mirror_buffer *mbuffer;
+
+ mbuffer = calloc(1, sizeof(struct _efl_util_mirror_buffer));
+ EINA_SAFETY_ON_NULL_RETURN_VAL(mbuffer, NULL);
+
+ mbuffer->w = screenmirror->width;
+ mbuffer->h = screenmirror->height;
+
+ mbuffer->t_surface = tbm_surface_internal_create_with_flags(mbuffer->w,
+ mbuffer->h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
+ EINA_SAFETY_ON_NULL_GOTO(mbuffer->t_surface, fail_create_surface);
+
+ mbuffer->buffer = wayland_tbm_client_create_buffer(_eflutil.wl.shot.tbm_client, mbuffer->t_surface);
+ EINA_SAFETY_ON_NULL_GOTO(mbuffer->buffer, fail_create_buffer);
+
+ return mbuffer;
+
+fail_create_buffer:
+ tbm_surface_destroy(mbuffer->t_surface);
+fail_create_surface:
+ free(mbuffer);
+
+ return NULL;
+}
+
+static void
+_efl_util_destroy_mirror_buffer(efl_util_mirror_buffer *mbuffer)
+{
+ EINA_SAFETY_ON_NULL_RETURN(mbuffer);
+
+ if (mbuffer->buffer)
+ wl_buffer_destroy(mbuffer->buffer);
+
+ free(mbuffer);
+}
+
+static void
+_efl_util_screenmirror_handle_dequeued(void *data,
+ struct tizen_screenmirror *tz_screenmirror, struct wl_buffer *buffer)
+{
+ efl_util_screenmirror_h screenmirror;
+ efl_util_mirror_buffer *mbuffer;
+ Eina_List *l, *ll;
+
+ screenmirror = (efl_util_screenmirror_h)data;
+ screenmirror->cb_start = EINA_TRUE;
+
+ EINA_LIST_FOREACH_SAFE(screenmirror->buffer_list, l, ll, mbuffer)
+ {
+ if (mbuffer->buffer == buffer)
+ {
+ if (mbuffer->w != screenmirror->width || mbuffer->h != screenmirror->height ||
+ !screenmirror->mirror_working)
+ tbm_surface_destroy(mbuffer->t_surface);
+ else
+ screenmirror->user_func(screenmirror, mbuffer->t_surface, screenmirror->user_data);
+
+ screenmirror->buffer_list = eina_list_remove_list(screenmirror->buffer_list, l);
+ _efl_util_destroy_mirror_buffer(mbuffer);
+
+ break;
+ }
+ }
+
+ mbuffer = _efl_util_create_mirror_buffer(screenmirror);
+ if (mbuffer == NULL)
+ {
+ fprintf(stderr, "[screenmirror] fail: buffer create\n");
+ return;
+ }
+ screenmirror->buffer_list = eina_list_append(screenmirror->buffer_list, mbuffer);
+ tizen_screenmirror_queue(screenmirror->tz_screenmirror, mbuffer->buffer);
+}
+
+static void
+_efl_util_screenmirror_handle_content(void *data,
+ struct tizen_screenmirror *tz_screenmirror, uint32_t content)
+{
+ efl_util_screenmirror_h screenmirror = NULL;
+
+ screenmirror = (efl_util_screenmirror_h)data;
+ screenmirror->cb_content = EINA_TRUE;
+}
+
+static void
+_efl_util_screenmirror_handle_stop(void *data, struct tizen_screenmirror *tz_screenmirror)
+{
+ efl_util_screenmirror_h screenmirror = NULL;
+
+ screenmirror = (efl_util_screenmirror_h)data;
+ screenmirror->cb_stop = EINA_TRUE;
+}
+
+static const struct tizen_screenmirror_listener efl_util_screenmirror_listener = {
+ _efl_util_screenmirror_handle_dequeued,
+ _efl_util_screenmirror_handle_content,
+ _efl_util_screenmirror_handle_stop
+};
+
+API efl_util_screenmirror_h
+efl_util_screenmirror_initialize(int width, int height)
+{
+ efl_util_screenmirror_h screenmirror = NULL;
+ efl_util_mirror_buffer *mbuffer;
+ Efl_Util_Wl_Output_Info *output;
+ int ret = 0, i;
+
+ if (width <= 0 || height <= 0)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ return NULL;
+ }
+
+ _screenshot_mutex_lock();
+
+ if (g_screenmirror)
+ {
+ if (g_screenmirror->mirror_working)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_OPERATION);
+ _screenshot_mutex_unlock();
+ return NULL;
+ }
+ else
+ {
+ g_screenmirror->width = width;
+ g_screenmirror->height = height;
+ set_last_result(EFL_UTIL_ERROR_NONE);
+ _screenshot_mutex_unlock();
+ return g_screenmirror;
+ }
+ }
+
+ screenmirror = calloc(1, sizeof(struct _efl_util_screenmirror_h));
+ if (screenmirror == NULL)
+ {
+ set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
+ _screenshot_mutex_unlock();
+ return NULL;
+ }
+
+ if (!_eflutil.wl.shot.tz_screenshooter)
+ {
+ if (_efl_util_wl_screenshooter_init() == EINA_FALSE)
+ {
+ if (_eflutil.wl.shot.noti == 0)
+ set_last_result(EFL_UTIL_ERROR_PERMISSION_DENIED);
+ else
+ set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL);
+
+ goto fail_wl_init;
+ }
+ }
+
+ output = eina_list_nth(_eflutil.wl.shot.output_list, 0);
+ if (!output)
+ {
+ set_last_result(EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE);
+ fprintf(stderr, "[screenmirror] fail: no output for screenmirror\n");
+ goto fail_get_output;
+ }
+
+ screenmirror->tz_screenmirror = tizen_screenshooter_get_screenmirror(_eflutil.wl.shot.tz_screenshooter, output->output);
+ wl_proxy_set_queue((struct wl_proxy *)screenmirror->tz_screenmirror, _eflutil.wl.shot.queue);
+ tizen_screenmirror_add_listener(screenmirror->tz_screenmirror, &efl_util_screenmirror_listener, screenmirror);
+ tizen_screenmirror_set_stretch(screenmirror->tz_screenmirror, TIZEN_SCREENMIRROR_STRETCH_KEEP_RATIO);
+ screenmirror->width = width;
+ screenmirror->height = height;
+
+ g_screenmirror = screenmirror;
+
+ for (i = 0; i < 1; i++)
+ {
+ mbuffer = _efl_util_create_mirror_buffer(screenmirror);
+ if (mbuffer)
+ {
+ screenmirror->buffer_list = eina_list_append(screenmirror->buffer_list, mbuffer);
+ tizen_screenmirror_queue(screenmirror->tz_screenmirror, mbuffer->buffer);
+ }
+ else
+ fprintf(stderr, "[screenmirror] fail: buffer create %d\n", i);
+ }
+ while (!screenmirror->cb_content && ret != -1)
+ ret = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
+
+ _screenshot_mutex_unlock();
+
+ return screenmirror;
+
+fail_get_output:
+fail_wl_init:
+ free(screenmirror);
+ _screenshot_mutex_unlock();
+ return NULL;
+}
+
+API int
+efl_util_screenmirror_deinitialize(efl_util_screenmirror_h screenmirror)
+{
+ efl_util_mirror_buffer *mbuffer;
+ Eina_List *l;
+
+ _screenshot_mutex_lock();
+
+ if (!screenmirror || (screenmirror != g_screenmirror))
+ {
+ _screenshot_mutex_unlock();
+ _screenshot_mutex_destory();
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ if (screenmirror->mirror_working)
+ {
+ fprintf(stderr, "[screenmirror] fail: execute stop before deinit\n");
+ _screenshot_mutex_unlock();
+ _screenshot_mutex_destory();
+ return EFL_UTIL_ERROR_INVALID_OPERATION;
+ }
+
+ EINA_LIST_FOREACH(screenmirror->buffer_list, l, mbuffer)
+ {
+ tbm_surface_destroy(mbuffer->t_surface);
+ _efl_util_destroy_mirror_buffer(mbuffer);
+ }
+ eina_list_free(screenmirror->buffer_list);
+
+ tizen_screenmirror_destroy(screenmirror->tz_screenmirror);
+ free(screenmirror);
+ g_screenmirror = NULL;
+
+ _efl_util_wl_screenshooter_deinit();
+
+ _screenshot_mutex_unlock();
+ _screenshot_mutex_destory();
+
+ return EFL_UTIL_ERROR_NONE;
+}
+
+API int
+efl_util_screenmirror_set_handler(efl_util_screenmirror_h screenmirror,
+ efl_util_screenmirror_handler func, void *data)
+{
+ _screenshot_mutex_lock();
+
+ if (!screenmirror || (screenmirror != g_screenmirror) || !func)
+ {
+ _screenshot_mutex_unlock();
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+ screenmirror->user_func = func;
+ screenmirror->user_data = data;
+
+ _screenshot_mutex_unlock();
+
+ return EFL_UTIL_ERROR_NONE;
+}
+
+API int
+efl_util_screenmirror_start(efl_util_screenmirror_h screenmirror)
+{
+ int ret = 0;
+
+ _screenshot_mutex_lock();
+
+ if (!screenmirror || (screenmirror != g_screenmirror))
+ {
+ _screenshot_mutex_unlock();
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+ else if (!screenmirror->user_func)
+ {
+ _screenshot_mutex_unlock();
+ return EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL;
+ }
+ else if (screenmirror->mirror_working)
+ {
+ _screenshot_mutex_unlock();
+ return EFL_UTIL_ERROR_NONE;
+ }
+
+ screenmirror->cb_start = EINA_FALSE;
+ screenmirror->mirror_working = EINA_TRUE;
+ tizen_screenmirror_start(screenmirror->tz_screenmirror);
+ while (!screenmirror->cb_start && ret != -1)
+ ret = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
+ if (ret == -1)
+ {
+ fprintf(stderr, "[screenmirror] fail: tizen_screenmirror_start\n");
+ _screenshot_mutex_unlock();
+ return EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL;
+ }
+
+ ret = pthread_create(&screenmirror->thread, NULL, _efl_util_screenmirror_loop, screenmirror);
+ if (ret < 0)
+ {
+ fprintf(stderr, "[screenmirror] fail: thread create fail\n");
+ _screenshot_mutex_unlock();
+ return EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL;
+ }
+
+ pthread_setname_np(screenmirror->thread, "e_util_mirror");
+
+ _screenshot_mutex_unlock();
+
+ return EFL_UTIL_ERROR_NONE;
+}
+
+API int
+efl_util_screenmirror_stop(efl_util_screenmirror_h screenmirror)
+{
+ int ret = 0;
+
+ _screenshot_mutex_lock();
+
+ if (!screenmirror || (screenmirror != g_screenmirror))
+ {
+ _screenshot_mutex_unlock();
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+ else if (!screenmirror->mirror_working)
+ {
+ _screenshot_mutex_unlock();
+ return EFL_UTIL_ERROR_NONE;
+ }
+ screenmirror->mirror_working = EINA_FALSE;
+ pthread_join(screenmirror->thread, NULL);
+ tizen_screenmirror_stop(screenmirror->tz_screenmirror);
+ screenmirror->cb_stop = EINA_FALSE;
+
+ while (!screenmirror->cb_stop && ret != -1)
+ ret = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
+ if (ret == -1)
+ {
+ fprintf(stderr, "[screenmirror] fail: tizen_screenmirror_stop\n");
+ _screenshot_mutex_unlock();
+ return EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL;
+ }
+
+ _screenshot_mutex_unlock();
+
+ return EFL_UTIL_ERROR_NONE;
+}
+/* LCOV_EXCL_STOP */
+
+struct _efl_util_gesture_h
+{
+ Eina_Bool init;
+};
+
+API int EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = 0;
+API int EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = 0;
+API int EFL_UTIL_EVENT_GESTURE_TAP = 0;
+API int EFL_UTIL_EVENT_GESTURE_PALM_COVER = 0;
+
+/* LCOV_EXCL_START */
+static void
+_cb_gesture_edge_swipe_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t fingers EINA_UNUSED, uint32_t edge EINA_UNUSED, uint32_t edge_size EINA_UNUSED, uint32_t start_point EINA_UNUSED, uint32_t end_point EINA_UNUSED, uint32_t error)
+{
+ LOGD("");
+ _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)
+{
+ LOGD("");
+ 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);
+
+ if (_eflutil_defaultqueue.wl.gesture.edge_swipe_cb.func)
+ _eflutil_defaultqueue.wl.gesture.edge_swipe_cb.func(_eflutil_defaultqueue.wl.gesture.edge_swipe_cb.data, mode, fingers, sx, sy, 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)
+{
+ LOGD("");
+ _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)
+{
+ LOGD("");
+ 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);
+
+ if (_eflutil_defaultqueue.wl.gesture.edge_drag_cb.func)
+ _eflutil_defaultqueue.wl.gesture.edge_drag_cb.func(_eflutil_defaultqueue.wl.gesture.edge_drag_cb.data, mode, fingers, cx, cy, 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 repeat EINA_UNUSED, uint32_t error)
+{
+ LOGD("");
+ _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)
+{
+ LOGD("");
+ 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);
+
+ if (_eflutil_defaultqueue.wl.gesture.tap_cb.func)
+ _eflutil_defaultqueue.wl.gesture.tap_cb.func(_eflutil_defaultqueue.wl.gesture.tap_cb.data, mode, fingers, repeats);
+}
+/* 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)
+{
+ LOGD("");
+ _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)
+{
+ LOGD("");
+ 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);
+
+ if (_eflutil_defaultqueue.wl.gesture.palm_cover_cb.func)
+ _eflutil_defaultqueue.wl.gesture.palm_cover_cb.func(_eflutil_defaultqueue.wl.gesture.palm_cover_cb.data, mode, duration, cx, cy, size, pressure);
+}
+/* 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)
+{
+ LOGD("");
+ _eflutil_defaultqueue.wl.gesture.request_notified = error;
+}
+
+static efl_util_error_e
+_efl_util_gesture_convert_error(int ret)
+{
+ switch (ret)
+ {
+ case TIZEN_GESTURE_ERROR_NONE:
+ return EFL_UTIL_ERROR_NONE;
+ case TIZEN_GESTURE_ERROR_INVALID_DATA:
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ case TIZEN_GESTURE_ERROR_NO_PERMISSION:
+ return EFL_UTIL_ERROR_PERMISSION_DENIED;
+ case TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES:
+ return EFL_UTIL_ERROR_OUT_OF_MEMORY;
+ case TIZEN_GESTURE_ERROR_GRABBED_ALREADY:
+ return EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE;
+ case TIZEN_GESTURE_ERROR_NOT_SUPPORTED:
+ return EFL_UTIL_ERROR_NOT_SUPPORTED;
+ default :
+ return EFL_UTIL_ERROR_NONE;
+ }
+}
+
+/* LCOV_EXCL_START */
+static efl_util_error_e
+_efl_util_gesture_verify_request_notified()
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
+ wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
+
+ ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
+ _eflutil_defaultqueue.wl.gesture.request_notified = -1;
+
+ return ret;
+}
+
+static int
+_efl_util_gesture_grab_edge_swipe(efl_util_gesture_data data, Eina_Bool grabbed)
+{
+ LOGD("");
+ int ret = EFL_UTIL_ERROR_NONE;
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+ Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = NULL;
+ unsigned int fingers = 0;
+ unsigned int edge = 0;
+ unsigned int edge_size = 0;
+ unsigned int start_point = 0;
+ unsigned int end_point = 0;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_SWIPE,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ edge_swipe_data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)data;
+
+ fingers = edge_swipe_data->fingers;
+ edge = edge_swipe_data->edge;
+ edge_size = edge_swipe_data->edge_size;
+ start_point = edge_swipe_data->start_point;
+ end_point = edge_swipe_data->end_point;
+
+ if (grabbed)
+ tizen_gesture_grab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
+ else
+ tizen_gesture_ungrab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
+
+ ret = _efl_util_gesture_verify_request_notified();
+
+ return ret;
+}
-typedef struct _notification_error_cb_info
+static int
+_efl_util_gesture_grab_edge_drag(efl_util_gesture_data data, Eina_Bool grabbed)
{
- Evas_Object *window;
- efl_util_notification_window_level_error_cb err_cb;
- void *user_data;
-} notification_error_cb_info;
+ LOGD("");
+ int ret = EFL_UTIL_ERROR_NONE;
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+ Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = NULL;
+ unsigned int fingers = 0;
+ unsigned int edge = 0;
+ unsigned int edge_size = 0;
+ unsigned int start_point = 0;
+ unsigned int end_point = 0;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_DRAG,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ edge_drag_data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)data;
+
+ fingers = edge_drag_data->fingers;
+ edge = edge_drag_data->edge;
+ edge_size = edge_drag_data->edge_size;
+ start_point = edge_drag_data->start_point;
+ end_point = edge_drag_data->end_point;
+
+ if (grabbed)
+ tizen_gesture_grab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
+ else
+ tizen_gesture_ungrab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
+
+ ret = _efl_util_gesture_verify_request_notified();
+
+ return ret;
+}
-Eina_List *_g_notification_error_cb_info_list;
-static Ecore_Event_Handler* _noti_level_access_result_handler = NULL;
-static int _noti_handler_count = 0;
+static int
+_efl_util_gesture_grab_tap(efl_util_gesture_data data, Eina_Bool grabbed)
+{
+ LOGD("");
+ 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;
-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);
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
-#if X11
-static unsigned int _noti_level_access_result_atom = 0;
+ 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);
-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
+ tap_data = (Efl_Util_Gesture_Tap_Grab_Data *)data;
-#if WAYLAND
-typedef struct _Surface_Level
-{
- struct wl_surface *surface;
- int32_t level;
- Eina_Bool wait_set_level_done;
-} Surface_Level;
+ fingers = tap_data->fingers;
+ repeats = tap_data->repeats;
-static void _cb_handle_registry_global(void *data, struct wl_registry *registry, unsigned int name, const char *interface, unsigned int version);
-static void _cb_handle_registry_global_remove(void *data, struct wl_registry *registry, unsigned int name);
-static void _notification_set_level_done(void *data, struct tizen_notification *tizen_notification, struct wl_surface *surface, int32_t level, uint32_t error_state);
-static notification_error_cb_info *_notification_error_cb_info_find_by_wl_surface(struct wl_surface *surface);
+ if (grabbed)
+ tizen_gesture_grab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats);
+ else
+ tizen_gesture_ungrab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats);
-static const struct wl_registry_listener _registry_listener =
-{
- _cb_handle_registry_global,
- _cb_handle_registry_global_remove
-};
+ ret = _efl_util_gesture_verify_request_notified();
-struct tizen_notification_listener _tizen_notification_listener =
+ return ret;
+}
+
+static int
+_efl_util_gesture_grab_palm_cover(efl_util_gesture_data data, Eina_Bool grabbed)
{
- _notification_set_level_done,
-};
+ LOGD("");
+ int ret = EFL_UTIL_ERROR_NONE;
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
-static struct tizen_notification *_tizen_notification = NULL;
-static Eina_Bool _efl_util_init_done = EINA_FALSE;
-static Eina_Hash *hash_surface_levels = NULL;
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
-static void
-_cb_handle_registry_global(void *data, struct wl_registry *registry, unsigned int name, const char *interface, unsigned int version)
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_PALM_COVER,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ if (grabbed)
+ tizen_gesture_grab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto);
+ else
+ tizen_gesture_ungrab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto);
+
+ ret = _efl_util_gesture_verify_request_notified();
+
+ return ret;
+}
+/* LCOV_EXCL_STOP */
+
+API efl_util_gesture_h
+efl_util_gesture_initialize(void)
{
- if (!strcmp(interface, "tizen_notification"))
+ LOGD("");
+ efl_util_gesture_h gesture_h = NULL;
+
+ gesture_h = (efl_util_gesture_h)calloc(1, sizeof(struct _efl_util_gesture_h));
+ if (!gesture_h)
{
- _tizen_notification = wl_registry_bind(registry, name, &tizen_notification_interface, 1);
- if (!_tizen_notification) return;
- tizen_notification_add_listener(_tizen_notification, &_tizen_notification_listener, NULL);
- _efl_util_init_done = EINA_TRUE;
- hash_surface_levels = eina_hash_pointer_new(free);
+ set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
+ goto out; /* LCOV_EXCL_LINE */
}
-}
-# define _FREE_FUNC(_h, _fn) do { if (_h) { _fn((void*)_h); _h = NULL; } } while (0)
-static void
-_cb_handle_registry_global_remove(void *data, struct wl_registry *registry, unsigned int name)
-{
- _tizen_notification = NULL;
- _efl_util_init_done = EINA_FALSE;
- _FREE_FUNC(hash_surface_levels, eina_hash_free);
- /* no-op */
-}
+ if (_wl_init_default_queue() == (int)EINA_FALSE)
+ {
+ set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED); /* LCOV_EXCL_LINE */
+ goto out; /* LCOV_EXCL_LINE */
+ }
-static void
-_notification_set_level_done(void *data,
- struct tizen_notification *tizen_notification,
- struct wl_surface *surface,
- int32_t level,
- uint32_t error_state)
-{
- Surface_Level *sl;
- notification_error_cb_info *cb_info = NULL;
- efl_util_error_e error_cb_state = EFL_UTIL_ERROR_NONE;
+ while (!_eflutil_defaultqueue.wl.gesture.proto)
+ wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); /* LCOV_EXCL_LINE */
- if (hash_surface_levels)
+ if (_eflutil_defaultqueue.wl.gesture.event_init <= 0)
{
- sl = eina_hash_find(hash_surface_levels, &surface);
- if (sl)
+ if (ecore_event_init() <= 0)
{
- sl->level = level;
- sl->wait_set_level_done = EINA_FALSE;
+ 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;
- cb_info = _notification_error_cb_info_find_by_wl_surface(surface);
- if (cb_info)
+ set_last_result(EFL_UTIL_ERROR_NONE);
+ return gesture_h;
+
+out:
+/* LCOV_EXCL_START */
+ if (gesture_h)
{
- switch (error_state)
- {
- case TIZEN_NOTIFICATION_ERROR_STATE_NONE:
- error_cb_state = EFL_UTIL_ERROR_NONE;
- break;
- case TIZEN_NOTIFICATION_ERROR_STATE_PERMISSION_DENIED:
- default:
- error_cb_state = EFL_UTIL_ERROR_PERMISSION_DENIED;
- break;
- }
- if (cb_info->err_cb)
- cb_info->err_cb(cb_info->window, error_cb_state , cb_info->user_data);
+ free(gesture_h);
+ gesture_h = NULL;
}
+ return gesture_h;
+/* LCOV_EXCL_STOP */
}
-static void
-_efl_util_wl_init(void)
+API int
+efl_util_gesture_deinitialize(efl_util_gesture_h gesture_h)
{
- static Eina_Bool init = EINA_FALSE;
- if (!init)
+ LOGD("");
+ 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)
{
- wl_registry_add_listener(wl_display_get_registry(ecore_wl_display_get()),
- &_registry_listener, NULL);
- init = EINA_TRUE;
+ _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;
}
- while (!_efl_util_init_done)
- wl_display_dispatch(ecore_wl_display_get());
+
+ return EFL_UTIL_ERROR_NONE;
}
-#endif
-int
-efl_util_set_notification_window_level(Evas_Object *window, efl_util_notification_level_e level)
+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)
{
- 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);
+ LOGD("");
+ Efl_Util_Gesture_Edge_Swipe_Grab_Data *data;
-#if X11
- Ecore_X_Window xwin = elm_win_xwindow_get(window);
- if (xwin)
+ if (!gesture_h || gesture_h->init == EINA_FALSE)
{
- 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;
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ return NULL;
+ }
- utilx_set_system_notification_level(ecore_x_display_get(), xwin,
- level);
- return EFL_UTIL_ERROR_NONE;
+ if (edge <= EFL_UTIL_GESTURE_EDGE_NONE || edge > EFL_UTIL_GESTURE_EDGE_LEFT)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ return NULL;
}
-#endif
-#if WAYLAND
- Ecore_Wl_Window *wl_win = elm_win_wl_window_get(window);
- if (wl_win)
+ data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Edge_Swipe_Grab_Data));
+ if (!data)
{
- _efl_util_wl_init();
+ set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
+ return NULL; /* LCOV_EXCL_LINE */
+ }
- if (hash_surface_levels)
- {
- Surface_Level *sl;
- struct wl_surface *surface = ecore_wl_window_surface_get(wl_win);
- sl = eina_hash_find(hash_surface_levels, &surface);
- if (!sl)
- {
- sl = calloc(1, sizeof(Surface_Level));
- if (sl)
- {
- sl->surface = surface;
- sl->level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT;
- sl->wait_set_level_done = EINA_TRUE;
- eina_hash_add(hash_surface_levels, &surface, sl);
- }
- }
- else
- {
- sl->wait_set_level_done = EINA_TRUE;
- }
- }
+ data->base.type = TIZEN_GESTURE_TYPE_EDGE_SWIPE;
+ data->fingers = fingers;
+ data->edge = edge;
+ data->edge_size = EFL_UTIL_GESTURE_EDGE_SIZE_FULL;
- //Add notification window type check
- tizen_notification_set_level(_tizen_notification,
- ecore_wl_window_surface_get(wl_win),
- level);
- return EFL_UTIL_ERROR_NONE;
- }
-#endif
+ set_last_result(EFL_UTIL_ERROR_NONE);
- return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE;
+ return (void *)data;
}
-int
-efl_util_get_notification_window_level(Evas_Object *window, efl_util_notification_level_e *level)
+API int
+efl_util_gesture_edge_swipe_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
{
+ LOGD("");
+ if (!gesture_h || gesture_h->init == EINA_FALSE)
+ {
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
- 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 (!data)
{
- 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;
- }
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
- utilx_level = utilx_get_system_notification_level (ecore_x_display_get(), xwin);
+ free(data);
+ data = NULL;
- 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;
- }
+ return EFL_UTIL_ERROR_NONE;
+}
- }
- else
- {
- // fail to get window type
- return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE;
- }
+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)
+{
+ LOGD("");
+ Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = data;
- return EFL_UTIL_ERROR_NONE;
- }
-#endif
+ 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);
-#if WAYLAND
- Ecore_Wl_Window *wl_win = elm_win_wl_window_get(window);
- if (wl_win)
- {
- Surface_Level *sl;
- struct wl_surface *surface = ecore_wl_window_surface_get(wl_win);
+ edge_swipe_data->edge_size = edge_size;
+ edge_swipe_data->start_point = start_point;
+ edge_swipe_data->end_point = end_point;
- sl = eina_hash_find(hash_surface_levels, &surface);
- if (sl)
- {
- if (sl->wait_set_level_done)
- {
- if (ecore_wl_window_shell_surface_get(wl_win) ||
- ecore_wl_window_xdg_surface_get(wl_win))
- {
- while (sl->wait_set_level_done)
- {
- ecore_wl_flush();
- wl_display_dispatch(ecore_wl_display_get());
- }
- }
- else
- {
- *level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT;
- return EFL_UTIL_ERROR_INVALID_PARAMETER;
- }
- }
-
- switch (sl->level)
- {
- case TIZEN_NOTIFICATION_LEVEL_1:
- *level = EFL_UTIL_NOTIFICATION_LEVEL_1;
- break;
- case TIZEN_NOTIFICATION_LEVEL_2:
- *level = EFL_UTIL_NOTIFICATION_LEVEL_2;
- break;
- case TIZEN_NOTIFICATION_LEVEL_3:
- *level = EFL_UTIL_NOTIFICATION_LEVEL_3;
- break;
- case TIZEN_NOTIFICATION_LEVEL_NONE:
- *level = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
- break;
- case TIZEN_NOTIFICATION_LEVEL_DEFAULT:
- *level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT;
- break;
- case TIZEN_NOTIFICATION_LEVEL_MEDIUM:
- *level = EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM;
- break;
- case TIZEN_NOTIFICATION_LEVEL_HIGH:
- *level = EFL_UTIL_NOTIFICATION_LEVEL_HIGH;
- break;
- case TIZEN_NOTIFICATION_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;
- }
- }
-#endif
- return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE;
+ return EFL_UTIL_ERROR_NONE;
}
-int
-efl_util_set_notification_window_level_error_cb(Evas_Object *window, efl_util_notification_window_level_error_cb callback, void *user_data)
+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)
{
- Eina_Bool ret = EINA_FALSE;
+ LOGD("");
+ Efl_Util_Gesture_Edge_Drag_Grab_Data *data;
- 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 (!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;
+ }
- ret = _efl_util_notification_info_add(window, callback, user_data);
- if (ret)
+ data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Edge_Drag_Grab_Data));
+ if (!data)
{
-#if X11
- if (!_noti_level_access_result_atom)
- _noti_level_access_result_atom = ecore_x_atom_get("_E_NOTIFICATION_LEVEL_ACCESS_RESULT");
+ set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
+ return NULL; /* LCOV_EXCL_LINE */
+ }
- 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++;
+ data->base.type = TIZEN_GESTURE_TYPE_EDGE_DRAG;
+ data->fingers = fingers;
+ data->edge = edge;
+ data->edge_size = EFL_UTIL_GESTURE_EDGE_SIZE_FULL;
- return EFL_UTIL_ERROR_NONE;
-#endif
+ set_last_result(EFL_UTIL_ERROR_NONE);
-#if WAYLAND
- return EFL_UTIL_ERROR_NONE;
-#endif
- }
- return EFL_UTIL_ERROR_OUT_OF_MEMORY;
+ return (void *)data;
}
-int
-efl_util_unset_notification_window_level_error_cb(Evas_Object *window)
+API int
+efl_util_gesture_edge_drag_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
{
- Eina_Bool ret = EINA_FALSE;
-
- EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ LOGD("");
+ if (!gesture_h || gesture_h->init == EINA_FALSE)
+ {
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
- ret = _efl_util_notification_info_del(window);
- if (ret)
+ if (!data)
{
- _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;
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
}
- return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ free(data);
+ data = NULL;
+
+ return EFL_UTIL_ERROR_NONE;
}
-#if X11
-static Eina_Bool
-_efl_util_client_message(void *data, int type, void *event)
+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)
{
- Ecore_X_Event_Client_Message *ev;
+ LOGD("");
+ 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);
- ev = event;
- if (!ev) return ECORE_CALLBACK_PASS_ON;
+ 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)
+{
+ LOGD("");
+ Efl_Util_Gesture_Tap_Grab_Data *data;
- if (ev->message_type == _noti_level_access_result_atom)
+ if (!gesture_h || gesture_h->init == EINA_FALSE)
{
- Ecore_X_Window xwin;
- xwin = ev->win;
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ return 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);
- }
- }
- }
+ if (fingers <= 1 || repeats <= 1)
+ {
+ set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED);
+ return NULL;
}
- return ECORE_CALLBACK_PASS_ON;
+ 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;
}
-static notification_error_cb_info *
-_notification_error_cb_info_find_by_xwin(unsigned int xwin)
+API int
+efl_util_gesture_tap_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
{
- Eina_List *l;
- notification_error_cb_info* temp;
- unsigned int temp_xwin;
+ LOGD("");
+ if (!gesture_h || gesture_h->init == EINA_FALSE)
+ {
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
- EINA_LIST_FOREACH(_g_notification_error_cb_info_list, l, temp)
+ if (!data)
{
- if (temp->window)
- {
- temp_xwin = elm_win_xwindow_get(temp->window);
- if (xwin == temp_xwin)
- {
- return temp;
- }
- }
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
}
- return NULL;
+ free(data);
+ data = NULL;
+
+ return EFL_UTIL_ERROR_NONE;
}
-#endif
-#if WAYLAND
-static notification_error_cb_info *
-_notification_error_cb_info_find_by_wl_surface(struct wl_surface *surface)
+API efl_util_gesture_data
+efl_util_gesture_palm_cover_new(efl_util_gesture_h gesture_h)
{
- Eina_List *l;
- notification_error_cb_info* temp;
- struct wl_surface *temp_surface;
+ LOGD("");
+ Efl_Util_Gesture_Palm_Cover_Grab_Data *data;
- EINA_LIST_FOREACH(_g_notification_error_cb_info_list, l, temp)
+ if (!gesture_h || gesture_h->init == EINA_FALSE)
{
- if (temp->window)
- {
- temp_surface = ecore_wl_window_surface_get(elm_win_wl_window_get(temp->window));
- if (surface == temp_surface)
- {
- return temp;
- }
- }
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ return NULL;
}
- 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;
}
-#endif
-static notification_error_cb_info *
-_notification_error_cb_info_find(Evas_Object *window)
+API int
+efl_util_gesture_palm_cover_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
{
- Eina_List *l;
- notification_error_cb_info* temp;
+ LOGD("");
+ if (!gesture_h || gesture_h->init == EINA_FALSE)
+ {
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
- EINA_LIST_FOREACH(_g_notification_error_cb_info_list, l, temp)
+ if (!data)
{
- if (temp->window == window)
- {
- return temp;
- }
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
}
- return NULL;
+ free(data);
+ data = NULL;
+
+ return EFL_UTIL_ERROR_NONE;
}
-static Eina_Bool
-_efl_util_notification_info_add(Evas_Object *window, efl_util_notification_window_level_error_cb callback, void *user_data)
+/* LCOV_EXCL_START */
+API int
+efl_util_gesture_grab(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
{
- notification_error_cb_info* _err_info = _notification_error_cb_info_find(window);
+ LOGD("");
+ int ret = EFL_UTIL_ERROR_NONE;
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
- if (_err_info)
+ 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)
{
- _g_notification_error_cb_info_list = eina_list_remove(_g_notification_error_cb_info_list, _err_info);
- free(_err_info);
- _err_info = NULL;
+ case TIZEN_GESTURE_TYPE_EDGE_SWIPE:
+ ret = _efl_util_gesture_grab_edge_swipe(data, EINA_TRUE);
+ break;
+ case TIZEN_GESTURE_TYPE_EDGE_DRAG:
+ ret = _efl_util_gesture_grab_edge_drag(data, EINA_TRUE);
+ break;
+ case TIZEN_GESTURE_TYPE_TAP:
+ ret = _efl_util_gesture_grab_tap(data, EINA_TRUE);
+ break;
+ case TIZEN_GESTURE_TYPE_PALM_COVER:
+ ret = _efl_util_gesture_grab_palm_cover(data, EINA_TRUE);
+ break;
+ default:
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
}
- _err_info = (notification_error_cb_info*)calloc(1, sizeof(notification_error_cb_info));
- if (!_err_info)
+ return ret;
+}
+
+API int
+efl_util_gesture_ungrab(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
+{
+ LOGD("");
+ 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)
{
- return EINA_FALSE;
+ case TIZEN_GESTURE_TYPE_EDGE_SWIPE:
+ ret = _efl_util_gesture_grab_edge_swipe(data, EINA_FALSE);
+ break;
+ case TIZEN_GESTURE_TYPE_EDGE_DRAG:
+ ret = _efl_util_gesture_grab_edge_drag(data, EINA_FALSE);
+ break;
+ case TIZEN_GESTURE_TYPE_TAP:
+ ret = _efl_util_gesture_grab_tap(data, EINA_FALSE);
+ break;
+ case TIZEN_GESTURE_TYPE_PALM_COVER:
+ ret = _efl_util_gesture_grab_palm_cover(data, EINA_FALSE);
+ break;
+ default:
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
}
- _err_info->window = window;
- _err_info->err_cb = callback;
- _err_info->user_data = user_data;
- _g_notification_error_cb_info_list = eina_list_append(_g_notification_error_cb_info_list, _err_info);
+ return ret;
+}
+/* LCOV_EXCL_STOP */
- return EINA_TRUE;
+API int
+efl_util_gesture_select(efl_util_gesture_h gesture_h, Evas_Object *window, efl_util_gesture_data data)
+{
+ LOGD("");
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+ Ecore_Wl2_Window *wlwin;
+ struct wl_surface *surface;
+ int ret;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ if (base_data->type != TIZEN_GESTURE_TYPE_PALM_COVER)
+ return EFL_UTIL_ERROR_NOT_SUPPORTED;
+
+ wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
+ if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
+
+ surface = ecore_wl2_window_surface_get(wlwin);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ tizen_gesture_select_palm_cover(_eflutil_defaultqueue.wl.gesture.proto, surface);
+
+ ret = _efl_util_gesture_verify_request_notified();
+
+ return ret;
}
-static Eina_Bool
-_efl_util_notification_info_del(Evas_Object *window)
+API int
+efl_util_gesture_deselect(efl_util_gesture_h gesture_h, Evas_Object *window, efl_util_gesture_data data)
{
- notification_error_cb_info* _err_info = _notification_error_cb_info_find(window);
- if (!_err_info)
- {
- return EINA_FALSE;
- }
+ LOGD("");
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+ Ecore_Wl2_Window *wlwin;
+ struct wl_surface *surface;
+ int ret;
- _g_notification_error_cb_info_list = eina_list_remove(_g_notification_error_cb_info_list, _err_info);
- free(_err_info);
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
- return EINA_TRUE;
+ EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ if (base_data->type != TIZEN_GESTURE_TYPE_PALM_COVER)
+ return EFL_UTIL_ERROR_NOT_SUPPORTED;
+
+ wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
+ if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
+
+ surface = ecore_wl2_window_surface_get(wlwin);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ tizen_gesture_deselect_palm_cover(_eflutil_defaultqueue.wl.gesture.proto, surface);
+
+ ret = _efl_util_gesture_verify_request_notified();
+
+ return ret;
+}
+
+/* LCOV_EXCL_START */
+API int
+efl_util_gesture_activate_set(efl_util_gesture_h gesture_h, unsigned int type, Eina_Bool active)
+{
+ LOGD("");
+ int ret;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_TRUE_RETURN_VAL(type == EFL_UTIL_GESTURE_TYPE_NONE, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ tizen_gesture_activate_set(_eflutil_defaultqueue.wl.gesture.proto, NULL, type, active);
+
+ ret = _efl_util_gesture_verify_request_notified();
+
+ return ret;
+}
+/* LCOV_EXCL_STOP */
+
+API int
+efl_util_gesture_activate_set_on_window(efl_util_gesture_h gesture_h, Evas_Object *window, unsigned int type, Eina_Bool active)
+{
+ LOGD("");
+ Ecore_Wl2_Window *wlwin;
+ struct wl_surface *surface;
+ int ret;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_TRUE_RETURN_VAL(type == EFL_UTIL_GESTURE_TYPE_NONE, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
+ if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
+
+ surface = ecore_wl2_window_surface_get(wlwin);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ tizen_gesture_activate_set(_eflutil_defaultqueue.wl.gesture.proto, surface, type, active);
+
+ ret = _efl_util_gesture_verify_request_notified();
+
+ return ret;
+}
+
+API int efl_util_gesture_edge_swipe_cb_set(efl_util_gesture_h gesture_h, efl_util_gesture_edge_swipe_cb cb_func, void *data)
+{
+ LOGD("");
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ 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);
+
+ _eflutil_defaultqueue.wl.gesture.edge_swipe_cb.func = cb_func;
+ _eflutil_defaultqueue.wl.gesture.edge_swipe_cb.data = data;
+
+ return ret;
+}
+
+API int efl_util_gesture_edge_drag_cb_set(efl_util_gesture_h gesture_h, efl_util_gesture_edge_drag_cb cb_func, void *data)
+{
+ LOGD("");
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ 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);
+
+ _eflutil_defaultqueue.wl.gesture.edge_drag_cb.func = cb_func;
+ _eflutil_defaultqueue.wl.gesture.edge_drag_cb.data = data;
+
+ return ret;
+}
+
+API int efl_util_gesture_tap_cb_set(efl_util_gesture_h gesture_h, efl_util_gesture_tap_cb cb_func, void *data)
+{
+ LOGD("");
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ 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);
+
+ _eflutil_defaultqueue.wl.gesture.tap_cb.func = cb_func;
+ _eflutil_defaultqueue.wl.gesture.tap_cb.data = data;
+
+ return ret;
+}
+
+API int efl_util_gesture_palm_cover_cb_set(efl_util_gesture_h gesture_h, efl_util_gesture_palm_cover_cb cb_func, void *data)
+{
+ LOGD("");
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ 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);
+
+ _eflutil_defaultqueue.wl.gesture.palm_cover_cb.func = cb_func;
+ _eflutil_defaultqueue.wl.gesture.palm_cover_cb.data = data;
+
+ return ret;
}