X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fefl_util.c;h=0f7794d1e37aa5ffbac94a4ba77ad303314d0ca0;hb=10a3cb4c1743f190bf772a76ed03c239ad01d285;hp=c1a2f38d867a4cd7e8a2a28c13788853859d47fb;hpb=dd8db293009d6dfef373e9f0f26bc76a910ca543;p=platform%2Fcore%2Fapi%2Fefl-util.git diff --git a/src/efl_util.c b/src/efl_util.c index c1a2f38..0f7794d 100644 --- a/src/efl_util.c +++ b/src/efl_util.c @@ -14,6 +14,8 @@ * limitations under the License. */ +#define _GNU_SOURCE + #define LOG_TAG "TIZEN_N_EFL_UTIL" #include @@ -36,7 +38,6 @@ #include #include #include -#include #include @@ -45,56 +46,10 @@ #undef LOG_TAG #endif -/* Determine Tizen profile at runtime */ -#include -typedef enum { - TIZEN_PROFILE_UNKNOWN = 0, - TIZEN_PROFILE_MOBILE = 0x1, - TIZEN_PROFILE_WEARABLE = 0x2, - TIZEN_PROFILE_TV = 0x4, - TIZEN_PROFILE_IVI = 0x8, - TIZEN_PROFILE_COMMON = 0x10, -} tizen_profile_t; -static tizen_profile_t profile = TIZEN_PROFILE_UNKNOWN; -static tizen_profile_t _get_tizen_profile() -{ - char *profileName; - system_info_get_platform_string("http://tizen.org/feature/profile", &profileName); - switch (*profileName) { - case 'm': - case 'M': - profile = TIZEN_PROFILE_MOBILE; - break; - case 'w': - case 'W': - profile = TIZEN_PROFILE_WEARABLE; - break; - case 't': - case 'T': - profile = TIZEN_PROFILE_TV; - break; - case 'i': - case 'I': - profile = TIZEN_PROFILE_IVI; - break; - default: // common or unknown ==> ALL ARE COMMON. - profile = TIZEN_PROFILE_COMMON; - } - free(profileName); - - return profile; -} -static inline tizen_profile_t get_tizen_profile() -{ - if (__builtin_expect(profile != TIZEN_PROFILE_UNKNOWN, 1)) - return profile; - return _get_tizen_profile(); -} - - #define LOG_TAG "TIZEN_N_EFL_UTIL" -#define EFL_UTIL_INPUT_GENERATOR_DEFAULT_TIME_OUT 1000 -#define EFL_UTIL_INPUT_GENERATOR_DEFAULT_DISPATCH_TIME_OUT 10 +#define EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER 10 + +#define NUM_EVENT_WAIT_DONE_COUNT 10 typedef struct _Efl_Util_Wl_Surface_Lv_Info { @@ -166,12 +121,14 @@ typedef struct _Efl_Util_Gesture_Palm_Cover_Grab_Data Efl_Util_Gesture_Common_Grab_Data base; } Efl_Util_Gesture_Palm_Cover_Grab_Data; -typedef struct _Efl_Util_Device_Info +typedef struct _E_Devicemgr_Inputgen_Touch_Axis { - struct tizen_input_device *device; - Ecore_Device_Class clas; - Eina_Stringshare *name; -} Efl_Util_Device_Info; + double radius_x; + double radius_y; + double pressure; + double angle; + double palm; +} E_Devicemgr_Inputgen_Touch_Axis; typedef struct _Efl_Util_Data { @@ -193,7 +150,6 @@ typedef struct _Efl_Util_Data struct { struct wl_event_queue *queue; - struct screenshooter *screenshooter; struct tizen_screenshooter *tz_screenshooter; struct wayland_tbm_client *tbm_client; Eina_List *output_list; @@ -206,6 +162,8 @@ typedef struct _Efl_Util_Data Eina_List *devices; Eina_List *wait_devices; struct wl_event_source *wait_timer; + int max_touch_count; + int request_touch_count; } devmgr; struct { @@ -242,8 +200,8 @@ static Efl_Util_Data _eflutil = EINA_FALSE, NULL, NULL, NULL, { 0, NULL, NULL, NULL }, /* tizen_policy protocol */ - { NULL, NULL, NULL, NULL, NULL, 0 }, /* screenshooter protocol */ - { NULL, -1 }, /* tizen_input_device_manager 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 */ }, }; @@ -279,14 +237,11 @@ static void _cb_wl_conformant_region(void *data, struct tizen static void _cb_wl_tz_display_policy_brightness_done(void *data, struct tizen_display_policy *tizen_display_policy, struct wl_surface *surface_resource, int32_t brightness, uint32_t state); -static void _cb_device_info(void *data, struct tizen_input_device *tizen_input_device EINA_UNUSED, const char *name, uint32_t clas, uint32_t subclas EINA_UNUSED, struct wl_array *axes EINA_UNUSED); -static void _cb_event_device(void *data EINA_UNUSED, struct tizen_input_device *tizen_input_device EINA_UNUSED, unsigned int serial EINA_UNUSED, const char *name EINA_UNUSED, uint32_t time EINA_UNUSED); -static void _cb_axis(void *data EINA_UNUSED, struct tizen_input_device *tizen_input_device EINA_UNUSED, uint32_t axis_type EINA_UNUSED, wl_fixed_t value EINA_UNUSED); - static void _cb_device_add(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED, uint32_t serial EINA_UNUSED, const char *identifier EINA_UNUSED, struct tizen_input_device *device EINA_UNUSED, struct wl_seat *seat EINA_UNUSED); static void _cb_device_remove(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED, uint32_t serial EINA_UNUSED, const char *identifier EINA_UNUSED, struct tizen_input_device *device EINA_UNUSED, struct wl_seat *seat EINA_UNUSED); static void _cb_error(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED, uint32_t errorcode); static void _cb_block_expired(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED); +static void _cb_max_touch_count(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED, uint32_t serial EINA_UNUSED, int32_t max_count EINA_UNUSED, struct wl_seat *seat EINA_UNUSED); static void _cb_gesture_edge_swipe_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t fingers EINA_UNUSED, uint32_t edge EINA_UNUSED, uint32_t edge_size EINA_UNUSED, uint32_t start_point EINA_UNUSED, uint32_t end_point EINA_UNUSED, uint32_t error); static void _cb_gesture_edge_swipe(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t mode, uint32_t fingers, int sx, int sy, uint32_t edge); @@ -325,19 +280,13 @@ struct tizen_policy_listener _wl_tz_policy_listener = _cb_wl_conformant_region, }; -static const struct tizen_input_device_listener _wl_tz_input_device_listener = -{ - _cb_device_info, - _cb_event_device, - _cb_axis, -}; - struct tizen_input_device_manager_listener _wl_tz_devmgr_listener = { _cb_device_add, _cb_device_remove, _cb_error, - _cb_block_expired + _cb_block_expired, + _cb_max_touch_count }; struct tizen_display_policy_listener _wl_tz_display_policy_listener = @@ -440,8 +389,6 @@ _wl_init_default_queue(void) return EINA_TRUE; fail: - if (display_wrapper) - wl_proxy_wrapper_destroy(display_wrapper); ecore_wl2_shutdown(); return EINA_FALSE; @@ -491,33 +438,29 @@ static const struct wl_output_listener output_listener = }; static void -_cb_wl_screenshot_done(void *data, struct screenshooter *screenshooter) +_cb_tz_screenshot_format(void *data, struct tizen_screenshooter *tz_screenshooter, uint32_t format) { - Eina_Bool *shot_done = (Eina_Bool*)data; - if (shot_done) - *shot_done = EINA_TRUE; } -static const struct screenshooter_listener screenshooter_listener = -{ - _cb_wl_screenshot_done -}; - static void -_cb_tz_screenshot_format(void *data, struct tizen_screenshooter *tz_screenshooter, uint32_t format) +_cb_tz_screenshot_noti(void *data, struct tizen_screenshooter *tz_screenshooter, uint32_t noti) { + _eflutil.wl.shot.noti = noti; } static void -_cb_tz_screenshot_noti(void *data, struct tizen_screenshooter *tz_screenshooter, uint32_t noti) +_cb_tz_screenshot_done(void *data, struct tizen_screenshooter *tz_screenshooter) { - _eflutil.wl.shot.noti = noti; + 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_noti, + _cb_tz_screenshot_done, }; static void @@ -634,12 +577,7 @@ _cb_wl_reg_screenshooter_global(void *data, const char *interface, unsigned int version) { - if (strcmp(interface, "screenshooter") == 0) - { - _eflutil.wl.shot.screenshooter = wl_registry_bind(reg, name, &screenshooter_interface, version); - screenshooter_add_listener(_eflutil.wl.shot.screenshooter, &screenshooter_listener, NULL); - } - else if (strcmp(interface, "tizen_screenshooter") == 0) + 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); @@ -833,7 +771,7 @@ efl_util_set_notification_window_level(Evas_Object *window, if (lv_info->wait_for_done) { int count = 0; - while (lv_info->wait_for_done && (count < 3)) + while (lv_info->wait_for_done && (count < NUM_EVENT_WAIT_DONE_COUNT)) { ecore_wl2_display_flush(_eflutil.wl.wl2_display); wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); @@ -898,7 +836,7 @@ efl_util_get_notification_window_level(Evas_Object *window, if (lv_info->wait_for_done) { int count = 0; - while ((lv_info->wait_for_done) && (count < 3)) + while ((lv_info->wait_for_done) && (count < NUM_EVENT_WAIT_DONE_COUNT)) { ecore_wl2_display_flush(_eflutil.wl.wl2_display); wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); @@ -1023,7 +961,7 @@ efl_util_set_window_screen_mode(Evas_Object *window, if (scr_mode_info->wait_for_done) { int count = 0; - while (scr_mode_info->wait_for_done && (count < 3)) + while (scr_mode_info->wait_for_done && (count < NUM_EVENT_WAIT_DONE_COUNT)) { ecore_wl2_display_flush(_eflutil.wl.wl2_display); wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); @@ -1156,7 +1094,7 @@ efl_util_set_window_brightness(Evas_Object *window, int brightness) if (brightness_info->wait_for_done) { int count = 0; - while (brightness_info->wait_for_done && (count < 3)) + while (brightness_info->wait_for_done && (count < NUM_EVENT_WAIT_DONE_COUNT)) { ecore_wl2_display_flush(_eflutil.wl.wl2_display); wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); @@ -1229,98 +1167,9 @@ struct _efl_util_inputgen_h { unsigned int init_type; char name[32]; + E_Devicemgr_Inputgen_Touch_Axis *axis_info; }; -static Eina_Bool -_efl_util_input_check_wait_device_full(void) -{ - Eina_List *l, *ll, *l_next; - Efl_Util_Device_Info *dev, *wait_dev; - int wait_cnt = 0; - - wait_cnt = eina_list_count(_eflutil.wl.devmgr.wait_devices); - if (wait_cnt <= 0) return EINA_TRUE; - - EINA_LIST_FOREACH(_eflutil.wl.devmgr.devices, l, dev) - { - EINA_LIST_FOREACH_SAFE(_eflutil.wl.devmgr.wait_devices, ll, l_next, wait_dev) - { - if ((dev->clas == wait_dev->clas) && - (!strncmp(dev->name, wait_dev->name, eina_stringshare_strlen(wait_dev->name)))) - { - eina_stringshare_del(wait_dev->name); - _eflutil.wl.devmgr.wait_devices = eina_list_remove_list(_eflutil.wl.devmgr.wait_devices, ll); - free(wait_dev); - - wait_cnt--; - if (wait_cnt <= 0) return EINA_TRUE; - - break; - } - } - } - - return EINA_FALSE; -} - -static Eina_Bool -_efl_util_input_check_wait_device(const char *name, unsigned int type) -{ - Eina_List *l, *l_next; - Efl_Util_Device_Info *wait_dev; - int wait_cnt = 0; - - wait_cnt = eina_list_count(_eflutil.wl.devmgr.wait_devices); - if (wait_cnt <= 0) return EINA_TRUE; - - EINA_LIST_FOREACH_SAFE(_eflutil.wl.devmgr.wait_devices, l, l_next, wait_dev) - { - if ((type == wait_dev->clas) && - (!strncmp(name, wait_dev->name, eina_stringshare_strlen(wait_dev->name)))) - { - eina_stringshare_del(wait_dev->name); - _eflutil.wl.devmgr.wait_devices = eina_list_remove_list(_eflutil.wl.devmgr.wait_devices, l); - free(wait_dev); - - wait_cnt--; - if (wait_cnt <= 0) return EINA_TRUE; - - break; - } - } - - return EINA_FALSE; -} - -static void -_cb_device_info(void *data, struct tizen_input_device *tizen_input_device EINA_UNUSED, const char *name, uint32_t clas, uint32_t subclas EINA_UNUSED, struct wl_array *axes EINA_UNUSED) -{ - Efl_Util_Device_Info *dev; - - if (!(dev = data)) return; - dev->clas = (Ecore_Device_Class)clas; - dev->name = eina_stringshare_add(name); - - if (_eflutil.wl.devmgr.wait_timer && - _efl_util_input_check_wait_device(name, clas)) - { - wl_event_source_remove(_eflutil.wl.devmgr.wait_timer); - _eflutil.wl.devmgr.wait_timer = NULL; - } -} - -/* LCOV_EXCL_START */ -static void -_cb_event_device(void *data EINA_UNUSED, struct tizen_input_device *tizen_input_device EINA_UNUSED, unsigned int serial EINA_UNUSED, const char *name EINA_UNUSED, uint32_t time EINA_UNUSED) -{ - ; -} - -static void -_cb_axis(void *data EINA_UNUSED, struct tizen_input_device *tizen_input_device EINA_UNUSED, uint32_t axis_type EINA_UNUSED, wl_fixed_t value EINA_UNUSED) -{ - ; -} /* LCOV_EXCL_STOP */ static void @@ -1331,17 +1180,7 @@ _cb_device_add(void *data EINA_UNUSED, struct tizen_input_device *device, struct wl_seat *seat EINA_UNUSED) { - Efl_Util_Device_Info *dev; - - EINA_SAFETY_ON_NULL_RETURN(device); - - dev = (Efl_Util_Device_Info *)calloc(1, sizeof(Efl_Util_Device_Info)); - EINA_SAFETY_ON_NULL_RETURN(dev); - - dev->device = device; - tizen_input_device_add_listener(device, &_wl_tz_input_device_listener, dev); - - _eflutil.wl.devmgr.devices = eina_list_append(_eflutil.wl.devmgr.devices, dev); + ; } static void @@ -1352,22 +1191,7 @@ _cb_device_remove(void *data EINA_UNUSED, struct tizen_input_device *device, struct wl_seat *seat EINA_UNUSED) { - Eina_List *l, *l_next; - Efl_Util_Device_Info *dev; - - EINA_LIST_FOREACH_SAFE(_eflutil.wl.devmgr.devices, l, l_next, dev) - { - if (dev->device == device) - { - if (dev->name) eina_stringshare_del(dev->name); - tizen_input_device_release(dev->device); - - _eflutil.wl.devmgr.devices = eina_list_remove_list(_eflutil.wl.devmgr.devices, l); - free(dev); - - break; - } - } + ; } static void @@ -1387,6 +1211,16 @@ _cb_block_expired(void *data 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) { @@ -1400,94 +1234,16 @@ _efl_util_input_convert_input_generator_error(int ret) return EFL_UTIL_ERROR_OUT_OF_MEMORY; case TIZEN_INPUT_DEVICE_MANAGER_ERROR_INVALID_PARAMETER: return EFL_UTIL_ERROR_INVALID_PARAMETER; + case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NOT_ALLOWED: + return EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE; default : return EFL_UTIL_ERROR_NONE; } } -/* LCOV_EXCL_START */ -static int -_timer_wait(void *data) -{ - Efl_Util_Device_Info *dev; - - _eflutil.wl.devmgr.request_notified = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_SYSTEM_RESOURCES; - - if (eina_list_count(_eflutil.wl.devmgr.wait_devices) > 0) - { - EINA_LIST_FREE(_eflutil.wl.devmgr.wait_devices, dev) - { - eina_stringshare_del(dev->name); - dev->name = NULL; - } - } - - wl_event_source_remove(_eflutil.wl.devmgr.wait_timer); - _eflutil.wl.devmgr.wait_timer = NULL; - - return 1; -} -/* LCOV_EXCL_STOP */ - -static void -_efl_util_input_initialize_wait_device(void) -{ - struct wl_event_loop *loop; - int ret = -1; - - if (_efl_util_input_check_wait_device_full()) return; - - loop = wl_event_loop_create(); - _eflutil.wl.devmgr.wait_timer = wl_event_loop_add_timer(loop, _timer_wait, NULL); - if (_eflutil.wl.devmgr.wait_timer) - { - ret = wl_event_source_timer_update(_eflutil.wl.devmgr.wait_timer, - EFL_UTIL_INPUT_GENERATOR_DEFAULT_TIME_OUT); - if (ret != 0) _timer_wait(NULL); - return; - } - - while (_eflutil.wl.devmgr.wait_timer) - { - wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - ret = wl_event_loop_dispatch(loop, EFL_UTIL_INPUT_GENERATOR_DEFAULT_DISPATCH_TIME_OUT); - if (ret != 0) _timer_wait(NULL); - } -} - -static void -_efl_util_input_initialize_append_device(const char *name, Ecore_Device_Class clas) -{ - Efl_Util_Device_Info *dev; - - dev = (Efl_Util_Device_Info *)calloc(1, sizeof(Efl_Util_Device_Info)); - EINA_SAFETY_ON_NULL_RETURN(dev); - - dev->name = eina_stringshare_add(name); - dev->clas = clas; - - _eflutil.wl.devmgr.wait_devices = eina_list_append(_eflutil.wl.devmgr.wait_devices, dev); -} - -static void -_efl_util_input_initialize_add_wait_device(const char *name, unsigned int dev_type) -{ - EINA_SAFETY_ON_NULL_RETURN(name); - - if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN) - _efl_util_input_initialize_append_device(name, ECORE_DEVICE_CLASS_TOUCH); - - if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD) - _efl_util_input_initialize_append_device(name, ECORE_DEVICE_CLASS_KEYBOARD); - - if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER) - _efl_util_input_initialize_append_device(name, ECORE_DEVICE_CLASS_MOUSE); -} - -API efl_util_inputgen_h -efl_util_input_initialize_generator(unsigned int dev_type) +static efl_util_inputgen_h +_efl_util_input_create_inputgen(unsigned int dev_type, const char *name, int *ret, int with_name) { - int ret = EFL_UTIL_ERROR_NONE; efl_util_inputgen_h inputgen_h = NULL; unsigned int clas = 0x0; @@ -1508,9 +1264,14 @@ efl_util_input_initialize_generator(unsigned int dev_type) } 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) + *ret = _wl_init(); + if (*ret == (int)EINA_FALSE) { set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); goto out; @@ -1526,16 +1287,22 @@ efl_util_input_initialize_generator(unsigned int dev_type) while (!_eflutil.wl.devmgr.devicemgr) wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - tizen_input_device_manager_init_generator(_eflutil.wl.devmgr.devicemgr, clas); + if (with_name == 2) + tizen_input_device_manager_init_generator_with_sync(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name); + else if (with_name == 1) + tizen_input_device_manager_init_generator_with_name(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name); + else + tizen_input_device_manager_init_generator(_eflutil.wl.devmgr.devicemgr, clas); + while (_eflutil.wl.devmgr.request_notified == -1) wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified); + *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) + set_last_result(*ret); + if (*ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE) goto out; return inputgen_h; @@ -1550,69 +1317,29 @@ out: } API efl_util_inputgen_h -efl_util_input_initialize_generator_with_name(unsigned int dev_type, const char *name) +efl_util_input_initialize_generator(unsigned int dev_type) { int ret = EFL_UTIL_ERROR_NONE; efl_util_inputgen_h inputgen_h = NULL; - unsigned int clas = 0x0; - - if (!dev_type || - dev_type & ~(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN - | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD - | EFL_UTIL_INPUT_DEVTYPE_POINTER)) - { - set_last_result(EFL_UTIL_ERROR_NO_SUCH_DEVICE); - goto out; - } - inputgen_h = (efl_util_inputgen_h)calloc(1, sizeof(struct _efl_util_inputgen_h)); + inputgen_h = _efl_util_input_create_inputgen(dev_type, NULL, &ret, 0); if (!inputgen_h) - { - set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); - goto out; - } - - inputgen_h->init_type |= dev_type; - strncpy(inputgen_h->name, name, 31); - - ret = _wl_init(); - if (ret == (int)EINA_FALSE) - { - set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); - goto out; - } - - if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN) - clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN; - if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD) - clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD; - if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER) - clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE; - - while (!_eflutil.wl.devmgr.devicemgr) - wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - - tizen_input_device_manager_init_generator_with_name(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name); + return NULL; - while (_eflutil.wl.devmgr.request_notified == -1) - wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + return inputgen_h; +} - ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified); - _eflutil.wl.devmgr.request_notified = -1; +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; - set_last_result(ret); - if (ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE) - goto out; + inputgen_h = _efl_util_input_create_inputgen(dev_type, name, &ret, 1); + if (!inputgen_h) + return NULL; return inputgen_h; - -out: - if (inputgen_h) - { - free(inputgen_h); - inputgen_h = NULL; - } - return NULL; } API efl_util_inputgen_h @@ -1620,46 +1347,32 @@ efl_util_input_initialize_generator_with_sync(unsigned int dev_type, const char { int ret = EFL_UTIL_ERROR_NONE; efl_util_inputgen_h inputgen_h = NULL; - unsigned int clas = 0x0; - if (!dev_type || - dev_type & ~(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN - | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD - | EFL_UTIL_INPUT_DEVTYPE_POINTER)) - { - set_last_result(EFL_UTIL_ERROR_NO_SUCH_DEVICE); - goto out; - } - - inputgen_h = (efl_util_inputgen_h)calloc(1, sizeof(struct _efl_util_inputgen_h)); + inputgen_h = _efl_util_input_create_inputgen(dev_type, name, &ret, 2); if (!inputgen_h) - { - set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); - goto out; - } + return NULL; - inputgen_h->init_type |= dev_type; - if (name) strncpy(inputgen_h->name, name, 31); - else strncpy(inputgen_h->name, "Input Generator", 31); + return inputgen_h; +} + +API int +efl_util_input_set_touch_count(int max_count) +{ + int ret = EFL_UTIL_ERROR_NONE; ret = _wl_init(); if (ret == (int)EINA_FALSE) { - set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); - goto out; + return EFL_UTIL_ERROR_INVALID_PARAMETER; } - if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN) - clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN; - if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD) - clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD; - if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER) - clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE; - while (!_eflutil.wl.devmgr.devicemgr) wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - tizen_input_device_manager_init_generator_with_name(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name); + if (_eflutil.wl.devmgr.max_touch_count >= max_count) + return EFL_UTIL_ERROR_NONE; + + tizen_input_device_manager_set_touch_count(_eflutil.wl.devmgr.devicemgr, max_count); while (_eflutil.wl.devmgr.request_notified == -1) wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); @@ -1669,28 +1382,10 @@ efl_util_input_initialize_generator_with_sync(unsigned int dev_type, const char if (ret == EFL_UTIL_ERROR_NONE) { - _efl_util_input_initialize_add_wait_device(inputgen_h->name, dev_type); - _efl_util_input_initialize_wait_device(); - if (_eflutil.wl.devmgr.request_notified != -1) - { - ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified); - _eflutil.wl.devmgr.request_notified = -1; - } + _eflutil.wl.devmgr.request_touch_count = max_count; } - 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; + return ret; } API int @@ -1707,6 +1402,9 @@ efl_util_input_deinitialize_generator(efl_util_inputgen_h inputgen_h) 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; @@ -1758,7 +1456,10 @@ efl_util_input_generate_touch(efl_util_inputgen_h inputgen_h, int idx, 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_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER); + 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) { @@ -1786,6 +1487,146 @@ efl_util_input_generate_touch(efl_util_inputgen_h inputgen_h, int idx, return ret; } +static int +_efl_util_input_generate_touch_axis_send(unsigned int type, double value) +{ + int ret; + + tizen_input_device_manager_generate_axis(_eflutil.wl.devmgr.devicemgr, type, wl_fixed_from_double(value)); + + while (_eflutil.wl.devmgr.request_notified == -1) + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + + ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified); + _eflutil.wl.devmgr.request_notified = -1; + + return ret; +} + +static void +_efl_util_input_generate_touch_axis_cleanup(efl_util_inputgen_h inputgen_h, int idx) +{ + int i; + if (idx >= 0) + { + inputgen_h->axis_info[idx].radius_x = 1.0; + inputgen_h->axis_info[idx].radius_y = 1.0; + inputgen_h->axis_info[idx].pressure = 1.0; + inputgen_h->axis_info[idx].angle = 0.0; + inputgen_h->axis_info[idx].palm = 0.0; + } + else + { + for (i = 0; i < EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER; i++) + { + inputgen_h->axis_info[i].radius_x = 1.0; + inputgen_h->axis_info[i].radius_y = 1.0; + inputgen_h->axis_info[i].pressure = 1.0; + inputgen_h->axis_info[i].angle = 0.0; + inputgen_h->axis_info[i].palm = 0.0; + } + } +} + +static int +_efl_util_input_generate_touch_axis_process(efl_util_inputgen_h inputgen_h, int idx, double radius_x, + double radius_y, double pressure, double angle, double palm) +{ + int ret = EFL_UTIL_ERROR_NONE; + + if (!inputgen_h->axis_info) + { + inputgen_h->axis_info = calloc(EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER, + sizeof(E_Devicemgr_Inputgen_Touch_Axis)); + _efl_util_input_generate_touch_axis_cleanup(inputgen_h, -1); + } + + if (inputgen_h->axis_info[idx].radius_x != radius_x) + { + ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_RADIUS_X, radius_x); + if (ret != EFL_UTIL_ERROR_NONE) return ret; + inputgen_h->axis_info[idx].radius_x = radius_x; + } + if (inputgen_h->axis_info[idx].radius_y != radius_y) + { + ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_RADIUS_Y, radius_y); + if (ret != EFL_UTIL_ERROR_NONE) return ret; + inputgen_h->axis_info[idx].radius_y = radius_y; + } + if (inputgen_h->axis_info[idx].pressure != pressure) + { + ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_PRESSURE, pressure); + if (ret != EFL_UTIL_ERROR_NONE) return ret; + inputgen_h->axis_info[idx].pressure = pressure; + } + if (inputgen_h->axis_info[idx].angle != angle) + { + ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_ANGLE, angle); + if (ret != EFL_UTIL_ERROR_NONE) return ret; + inputgen_h->axis_info[idx].angle = angle; + } + if (inputgen_h->axis_info[idx].palm != palm) + { + ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_PALM, palm); + if (ret != EFL_UTIL_ERROR_NONE) return ret; + inputgen_h->axis_info[idx].palm = palm; + } + + return ret; +} + +API int +efl_util_input_generate_touch_axis(efl_util_inputgen_h inputgen_h, int idx, + efl_util_input_touch_type_e touch_type, int x, int y, + double radius_x, double radius_y, + double pressure, double angle, double palm) +{ + int ret, version; + enum tizen_input_device_manager_pointer_event_type type; + + EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(idx >= 0, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL((x >= 0 && y >= 0), EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, EFL_UTIL_ERROR_NO_SUCH_DEVICE); + EINA_SAFETY_ON_FALSE_RETURN_VAL((radius_x >= 0.0 && radius_y >= 0.0), EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL((pressure >= 0.0 && palm >= 0.0), EFL_UTIL_ERROR_INVALID_PARAMETER); + + EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER); + version = tizen_input_device_manager_get_version(_eflutil.wl.devmgr.devicemgr); + EINA_SAFETY_ON_FALSE_RETURN_VAL((version >= 3), EFL_UTIL_ERROR_NOT_SUPPORTED); + + switch(touch_type) + { + case EFL_UTIL_INPUT_TOUCH_BEGIN: + type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_BEGIN; + break; + case EFL_UTIL_INPUT_TOUCH_UPDATE: + type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_UPDATE; + break; + case EFL_UTIL_INPUT_TOUCH_END: + type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_END; + break; + default: + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + + if (touch_type != EFL_UTIL_INPUT_TOUCH_END) + _efl_util_input_generate_touch_axis_process(inputgen_h, idx, radius_x, radius_y, pressure, angle, palm); + else + _efl_util_input_generate_touch_axis_cleanup(inputgen_h, idx); + + tizen_input_device_manager_generate_touch(_eflutil.wl.devmgr.devicemgr, type, x, y, idx); + + while (_eflutil.wl.devmgr.request_notified == -1) + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + + ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified); + _eflutil.wl.devmgr.request_notified = -1; + + return ret; +} + + API int efl_util_input_generate_pointer(efl_util_inputgen_h inputgen_h, int buttons, efl_util_input_pointer_type_e pointer_type, int x, int y) { @@ -1825,6 +1666,43 @@ efl_util_input_generate_pointer(efl_util_inputgen_h inputgen_h, int buttons, efl return ret; } +API int +efl_util_input_generate_wheel(efl_util_inputgen_h inputgen_h, efl_util_input_pointer_wheel_type_e wheel_type, int value) +{ + int ret, version; + enum tizen_input_device_manager_pointer_event_type type; + + EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER); + EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER, EFL_UTIL_ERROR_NO_SUCH_DEVICE); + + EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER); + version = tizen_input_device_manager_get_version(_eflutil.wl.devmgr.devicemgr); + EINA_SAFETY_ON_FALSE_RETURN_VAL((version >= 3), EFL_UTIL_ERROR_NOT_SUPPORTED); + + switch(wheel_type) + { + case EFL_UTIL_INPUT_POINTER_WHEEL_VERT: + type = TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_WHEEL; + break; + case EFL_UTIL_INPUT_POINTER_WHEEL_HORZ: + type = TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_HWHEEL; + break; + default: + return EFL_UTIL_ERROR_INVALID_PARAMETER; + } + + tizen_input_device_manager_generate_axis(_eflutil.wl.devmgr.devicemgr, type, wl_fixed_from_int(value)); + + while (_eflutil.wl.devmgr.request_notified == -1) + wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + + ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified); + _eflutil.wl.devmgr.request_notified = -1; + + return ret; +} + + struct _efl_util_screenshot_h { @@ -1893,72 +1771,98 @@ _screenshot_mutex_unlock(void) pthread_mutex_unlock(&shot_lock); } -API efl_util_screenshot_h -efl_util_screenshot_initialize(int width, int height) +static Eina_Bool +_efl_util_wl_screenshooter_init() { - efl_util_screenshot_h screenshot = NULL; struct wl_display *display_wrapper = NULL; - struct wl_registry *reg = NULL; + struct wl_registry *registry = NULL; int ret = 0; - if (width <= 0 || height <= 0) - { - set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); - return NULL; - } + if (_wl_init() == EINA_FALSE) + return EINA_FALSE; - _screenshot_mutex_lock(); + wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.queue); - if (!g_screenshot) - { - screenshot = calloc(1, sizeof(struct _efl_util_screenshot_h)); - EINA_SAFETY_ON_NULL_GOTO(screenshot, fail_memory); - } + display_wrapper = wl_proxy_create_wrapper(_eflutil.wl.dpy); + EINA_SAFETY_ON_NULL_RETURN_VAL(display_wrapper, EINA_FALSE); - if (!_eflutil.wl.shot.screenshooter) - { - ret = _wl_init(); - if (ret == (int)EINA_FALSE) - { - set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); - _screenshot_mutex_unlock(); - return NULL; - } - wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.queue); + _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); - display_wrapper = wl_proxy_create_wrapper(_eflutil.wl.dpy); - EINA_SAFETY_ON_NULL_GOTO(display_wrapper, fail_memory); + registry = wl_display_get_registry(display_wrapper); + EINA_SAFETY_ON_NULL_GOTO(registry, fail_get_registry); - _eflutil.wl.shot.queue = wl_display_create_queue(_eflutil.wl.dpy); - EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.queue, fail_memory); + wl_registry_add_listener(registry, &_wl_reg_screenshooter_listener, NULL); - wl_proxy_set_queue((struct wl_proxy *)display_wrapper, _eflutil.wl.shot.queue); + 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); - reg = wl_display_get_registry(display_wrapper); - wl_proxy_wrapper_destroy(display_wrapper); - display_wrapper = NULL; - EINA_SAFETY_ON_NULL_GOTO(reg, fail_init); + _eflutil.wl.shot.tbm_client = wayland_tbm_client_init(_eflutil.wl.dpy); + EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tbm_client, fail_tbm_client_init); + + wl_registry_destroy(registry); + wl_proxy_wrapper_destroy(display_wrapper); - wl_registry_add_listener(reg, &_wl_reg_screenshooter_listener, NULL); + 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; +} - ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue); - EINA_SAFETY_ON_TRUE_GOTO(ret == -1, fail_init); - EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.screenshooter, fail_init); - EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tz_screenshooter, fail_init); +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; + } - _eflutil.wl.shot.tbm_client = wayland_tbm_client_init(_eflutil.wl.dpy); - EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tbm_client, fail_init); + if (_eflutil.wl.shot.tz_screenshooter) + { + tizen_screenshooter_destroy(_eflutil.wl.shot.tz_screenshooter); + _eflutil.wl.shot.tz_screenshooter = NULL; + } - wl_registry_destroy(reg); - reg = NULL; + if (_eflutil.wl.shot.queue) + { + wl_event_queue_destroy(_eflutil.wl.shot.queue); + _eflutil.wl.shot.queue = NULL; } +} - if (_eflutil.wl.shot.noti == 0) +API efl_util_screenshot_h +efl_util_screenshot_initialize(int width, int height) +{ + efl_util_screenshot_h screenshot = NULL; + + if (width <= 0 || height <= 0) { - fprintf(stderr, "[screenshot] fail: privilege error\n"); /* LCOV_EXCL_LINE */ - goto fail_init; + 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) @@ -1973,39 +1877,55 @@ efl_util_screenshot_initialize(int width, int height) 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_init); + EINA_SAFETY_ON_NULL_GOTO(screenshot->bufmgr, fail_get_bufmgr); g_screenshot = screenshot; set_last_result(EFL_UTIL_ERROR_NONE); - screenshooter_set_user_data(_eflutil.wl.shot.screenshooter, &screenshot->shot_done); + tizen_screenshooter_set_user_data(_eflutil.wl.shot.tz_screenshooter, &screenshot->shot_done); _screenshot_mutex_unlock(); return g_screenshot; /* LCOV_EXCL_START */ -fail_memory: - if (display_wrapper) - wl_proxy_wrapper_destroy(display_wrapper); - set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); +fail_get_bufmgr: + set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL); _screenshot_mutex_unlock(); - return NULL; + efl_util_screenshot_deinitialize(screenshot); -fail_init: - if (reg) - wl_registry_destroy(reg); - if (screenshot) - { - _screenshot_mutex_unlock(); - efl_util_screenshot_deinitialize(screenshot); - } - set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL); return NULL; /* LCOV_EXCL_STOP */ } @@ -2025,139 +1945,519 @@ efl_util_screenshot_deinitialize(efl_util_screenshot_h screenshot) free(screenshot); g_screenshot = NULL; - if (_eflutil.wl.shot.tbm_client) + _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)) { - wayland_tbm_client_deinit(_eflutil.wl.shot.tbm_client); - _eflutil.wl.shot.tbm_client = NULL; + set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); + _screenshot_mutex_unlock(); + return NULL; } - if (_eflutil.wl.shot.screenshooter) + output = eina_list_nth(_eflutil.wl.shot.output_list, 0); + if (!output) { - screenshooter_destroy(_eflutil.wl.shot.screenshooter); - _eflutil.wl.shot.screenshooter = NULL; + fprintf(stderr, "[screenshot] fail: no output for screenshot\n"); /* LCOV_EXCL_LINE */ + goto fail; } - if (_eflutil.wl.shot.tz_screenshooter) + + t_surface = tbm_surface_create(screenshot->width, screenshot->height, TBM_FORMAT_XRGB8888); + if (!t_surface) { - tizen_screenshooter_destroy(_eflutil.wl.shot.tz_screenshooter); - _eflutil.wl.shot.tz_screenshooter = NULL; + fprintf(stderr, "[screenshot] fail: tbm_surface_create\n"); /* LCOV_EXCL_LINE */ + goto fail; } - if (_eflutil.wl.shot.queue) + buffer = wayland_tbm_client_create_buffer(_eflutil.wl.shot.tbm_client, t_surface); + if (!buffer) { - wl_event_queue_destroy(_eflutil.wl.shot.queue); - _eflutil.wl.shot.queue = NULL; + 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(); - _screenshot_mutex_destory(); return EFL_UTIL_ERROR_NONE; } - -API tbm_surface_h -efl_util_screenshot_take_tbm_surface(efl_util_screenshot_h screenshot) +API int +efl_util_screenmirror_start(efl_util_screenmirror_h screenmirror) { - 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)) + if (!screenmirror || (screenmirror != g_screenmirror)) { - set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER); _screenshot_mutex_unlock(); - return NULL; + return EFL_UTIL_ERROR_INVALID_PARAMETER; } - - output = eina_list_nth(_eflutil.wl.shot.output_list, 0); - if (!output) + else if (!screenmirror->user_func) { - fprintf(stderr, "[screenshot] fail: no output for screenshot\n"); /* LCOV_EXCL_LINE */ - goto fail; + _screenshot_mutex_unlock(); + return EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL; } - - t_surface = tbm_surface_create(screenshot->width, screenshot->height, TBM_FORMAT_XRGB8888); - if (!t_surface) + else if (screenmirror->mirror_working) { - fprintf(stderr, "[screenshot] fail: tbm_surface_create\n"); /* LCOV_EXCL_LINE */ - goto fail; + _screenshot_mutex_unlock(); + return EFL_UTIL_ERROR_NONE; } - buffer = wayland_tbm_client_create_buffer(_eflutil.wl.shot.tbm_client, t_surface); - if (!buffer) + 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, "[screenshot] fail: create wl_buffer for screenshot\n"); /* LCOV_EXCL_LINE */ - goto fail; + fprintf(stderr, "[screenmirror] fail: tizen_screenmirror_start\n"); + _screenshot_mutex_unlock(); + return EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL; } - screenshooter_shoot(_eflutil.wl.shot.screenshooter, output->output, buffer); - - screenshot->shot_done = EINA_FALSE; - while (!screenshot->shot_done && ret != -1) - ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue); - - if (ret == -1) + ret = pthread_create(&screenmirror->thread, NULL, _efl_util_screenmirror_loop, screenmirror); + if (ret < 0) { - fprintf(stderr, "[screenshot] fail: screenshooter_shoot\n"); /* LCOV_EXCL_LINE */ - goto fail; + fprintf(stderr, "[screenmirror] fail: thread create fail\n"); + _screenshot_mutex_unlock(); + return EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_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); + pthread_setname_np(screenmirror->thread, "e_util_mirror"); _screenshot_mutex_unlock(); - return NULL; + return EFL_UTIL_ERROR_NONE; } API int -efl_util_screenshot_set_auto_rotation(efl_util_screenshot_h screenshot, int set) +efl_util_screenmirror_stop(efl_util_screenmirror_h screenmirror) { - 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; + int ret = 0; - tizen_screenshooter_set_oneshot_auto_rotation(_eflutil.wl.shot.tz_screenshooter, g_screenshot->auto_rotation); + _screenshot_mutex_lock(); - return EFL_UTIL_ERROR_NONE; -} + 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; -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; + 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; + } - *set = g_screenshot->auto_rotation; + _screenshot_mutex_unlock(); return EFL_UTIL_ERROR_NONE; } +/* LCOV_EXCL_STOP */ struct _efl_util_gesture_h { @@ -2297,34 +2597,10 @@ _efl_util_gesture_convert_error(int ret) } /* LCOV_EXCL_START */ -static int -_efl_util_gesture_grab_edge_swipe(efl_util_gesture_data data) +static efl_util_error_e +_efl_util_gesture_verify_request_notified() { int ret = EFL_UTIL_ERROR_NONE; - Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; - Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = NULL; - unsigned int fingers = 0; - unsigned int edge = 0; - unsigned int edge_size = 0; - unsigned int start_point = 0; - unsigned int end_point = 0; - - base_data = (Efl_Util_Gesture_Common_Grab_Data *)data; - - EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER); - EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER); - EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_SWIPE, - EFL_UTIL_ERROR_INVALID_PARAMETER); - - edge_swipe_data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)data; - - fingers = edge_swipe_data->fingers; - edge = edge_swipe_data->edge; - edge_size = edge_swipe_data->edge_size; - start_point = edge_swipe_data->start_point; - end_point = edge_swipe_data->end_point; - - tizen_gesture_grab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point); while (_eflutil_defaultqueue.wl.gesture.request_notified == -1) wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); @@ -2336,7 +2612,7 @@ _efl_util_gesture_grab_edge_swipe(efl_util_gesture_data data) } static int -_efl_util_gesture_ungrab_edge_swipe(efl_util_gesture_data data) +_efl_util_gesture_grab_edge_swipe(efl_util_gesture_data data, Eina_Bool grabbed) { int ret = EFL_UTIL_ERROR_NONE; Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; @@ -2362,57 +2638,18 @@ _efl_util_gesture_ungrab_edge_swipe(efl_util_gesture_data data) start_point = edge_swipe_data->start_point; end_point = edge_swipe_data->end_point; - tizen_gesture_ungrab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point); - - while (_eflutil_defaultqueue.wl.gesture.request_notified == -1) - wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); - - ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified); - _eflutil_defaultqueue.wl.gesture.request_notified = -1; - - return ret; -} - -static int -_efl_util_gesture_grab_edge_drag(efl_util_gesture_data data) -{ - int ret = EFL_UTIL_ERROR_NONE; - Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; - Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = NULL; - unsigned int fingers = 0; - unsigned int edge = 0; - unsigned int edge_size = 0; - unsigned int start_point = 0; - unsigned int end_point = 0; - - base_data = (Efl_Util_Gesture_Common_Grab_Data *)data; - - EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER); - EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER); - EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_DRAG, - EFL_UTIL_ERROR_INVALID_PARAMETER); - - edge_drag_data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)data; - - fingers = edge_drag_data->fingers; - edge = edge_drag_data->edge; - edge_size = edge_drag_data->edge_size; - start_point = edge_drag_data->start_point; - end_point = edge_drag_data->end_point; - - tizen_gesture_grab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point); - - while (_eflutil_defaultqueue.wl.gesture.request_notified == -1) - wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); + 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_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified); - _eflutil_defaultqueue.wl.gesture.request_notified = -1; + ret = _efl_util_gesture_verify_request_notified(); return ret; } static int -_efl_util_gesture_ungrab_edge_drag(efl_util_gesture_data data) +_efl_util_gesture_grab_edge_drag(efl_util_gesture_data data, Eina_Bool grabbed) { int ret = EFL_UTIL_ERROR_NONE; Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; @@ -2438,52 +2675,18 @@ _efl_util_gesture_ungrab_edge_drag(efl_util_gesture_data data) start_point = edge_drag_data->start_point; end_point = edge_drag_data->end_point; - tizen_gesture_ungrab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point); - - while (_eflutil_defaultqueue.wl.gesture.request_notified == -1) - wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); - - ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified); - _eflutil_defaultqueue.wl.gesture.request_notified = -1; - - return ret; -} - - -static int -_efl_util_gesture_grab_tap(efl_util_gesture_data data) -{ - int ret = EFL_UTIL_ERROR_NONE; - Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; - Efl_Util_Gesture_Tap_Grab_Data *tap_data = NULL; - unsigned int fingers = 0; - unsigned int repeats = 0; - - base_data = (Efl_Util_Gesture_Common_Grab_Data *)data; - - EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER); - EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER); - EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_TAP, - EFL_UTIL_ERROR_INVALID_PARAMETER); - - tap_data = (Efl_Util_Gesture_Tap_Grab_Data *)data; - - fingers = tap_data->fingers; - repeats = tap_data->repeats; - - tizen_gesture_grab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats); - - while (_eflutil_defaultqueue.wl.gesture.request_notified == -1) - wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); + 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_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified); - _eflutil_defaultqueue.wl.gesture.request_notified = -1; + ret = _efl_util_gesture_verify_request_notified(); return ret; } static int -_efl_util_gesture_ungrab_tap(efl_util_gesture_data data) +_efl_util_gesture_grab_tap(efl_util_gesture_data data, Eina_Bool grabbed) { int ret = EFL_UTIL_ERROR_NONE; Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; @@ -2503,43 +2706,18 @@ _efl_util_gesture_ungrab_tap(efl_util_gesture_data data) fingers = tap_data->fingers; repeats = tap_data->repeats; - tizen_gesture_ungrab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats); - - while (_eflutil_defaultqueue.wl.gesture.request_notified == -1) - wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); - - ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified); - _eflutil_defaultqueue.wl.gesture.request_notified = -1; - - return ret; -} - -static int -_efl_util_gesture_grab_palm_cover(efl_util_gesture_data data) -{ - int ret = EFL_UTIL_ERROR_NONE; - Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; - - base_data = (Efl_Util_Gesture_Common_Grab_Data *)data; - - EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER); - EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER); - EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_PALM_COVER, - EFL_UTIL_ERROR_INVALID_PARAMETER); - - tizen_gesture_grab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto); - - while (_eflutil_defaultqueue.wl.gesture.request_notified == -1) - wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); + if (grabbed) + tizen_gesture_grab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats); + else + tizen_gesture_ungrab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats); - ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified); - _eflutil_defaultqueue.wl.gesture.request_notified = -1; + ret = _efl_util_gesture_verify_request_notified(); return ret; } static int -_efl_util_gesture_ungrab_palm_cover(efl_util_gesture_data data) +_efl_util_gesture_grab_palm_cover(efl_util_gesture_data data, Eina_Bool grabbed) { int ret = EFL_UTIL_ERROR_NONE; Efl_Util_Gesture_Common_Grab_Data *base_data = NULL; @@ -2551,13 +2729,12 @@ _efl_util_gesture_ungrab_palm_cover(efl_util_gesture_data data) EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_PALM_COVER, EFL_UTIL_ERROR_INVALID_PARAMETER); - tizen_gesture_ungrab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto); - - while (_eflutil_defaultqueue.wl.gesture.request_notified == -1) - wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); + 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_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified); - _eflutil_defaultqueue.wl.gesture.request_notified = -1; + ret = _efl_util_gesture_verify_request_notified(); return ret; } @@ -2893,16 +3070,16 @@ efl_util_gesture_grab(efl_util_gesture_h gesture_h, efl_util_gesture_data data) switch (base_data->type) { case TIZEN_GESTURE_TYPE_EDGE_SWIPE: - ret = _efl_util_gesture_grab_edge_swipe(data); + 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); + ret = _efl_util_gesture_grab_edge_drag(data, EINA_TRUE); break; case TIZEN_GESTURE_TYPE_TAP: - ret = _efl_util_gesture_grab_tap(data); + ret = _efl_util_gesture_grab_tap(data, EINA_TRUE); break; case TIZEN_GESTURE_TYPE_PALM_COVER: - ret = _efl_util_gesture_grab_palm_cover(data); + ret = _efl_util_gesture_grab_palm_cover(data, EINA_TRUE); break; default: return EFL_UTIL_ERROR_INVALID_PARAMETER; @@ -2926,16 +3103,16 @@ efl_util_gesture_ungrab(efl_util_gesture_h gesture_h, efl_util_gesture_data data switch (base_data->type) { case TIZEN_GESTURE_TYPE_EDGE_SWIPE: - ret = _efl_util_gesture_ungrab_edge_swipe(data); + ret = _efl_util_gesture_grab_edge_swipe(data, EINA_FALSE); break; case TIZEN_GESTURE_TYPE_EDGE_DRAG: - ret = _efl_util_gesture_ungrab_edge_drag(data); + ret = _efl_util_gesture_grab_edge_drag(data, EINA_FALSE); break; case TIZEN_GESTURE_TYPE_TAP: - ret = _efl_util_gesture_ungrab_tap(data); + ret = _efl_util_gesture_grab_tap(data, EINA_FALSE); break; case TIZEN_GESTURE_TYPE_PALM_COVER: - ret = _efl_util_gesture_ungrab_palm_cover(data); + ret = _efl_util_gesture_grab_palm_cover(data, EINA_FALSE); break; default: return EFL_UTIL_ERROR_INVALID_PARAMETER; @@ -2972,11 +3149,7 @@ efl_util_gesture_select(efl_util_gesture_h gesture_h, Evas_Object *window, efl_u tizen_gesture_select_palm_cover(_eflutil_defaultqueue.wl.gesture.proto, surface); - while (_eflutil_defaultqueue.wl.gesture.request_notified == -1) - wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); - - ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified); - _eflutil_defaultqueue.wl.gesture.request_notified = -1; + ret = _efl_util_gesture_verify_request_notified(); return ret; } @@ -3008,11 +3181,7 @@ efl_util_gesture_deselect(efl_util_gesture_h gesture_h, Evas_Object *window, efl tizen_gesture_deselect_palm_cover(_eflutil_defaultqueue.wl.gesture.proto, surface); - while (_eflutil_defaultqueue.wl.gesture.request_notified == -1) - wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); - - ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified); - _eflutil_defaultqueue.wl.gesture.request_notified = -1; + ret = _efl_util_gesture_verify_request_notified(); return ret; } @@ -3029,11 +3198,7 @@ efl_util_gesture_activate_set(efl_util_gesture_h gesture_h, unsigned int type, E tizen_gesture_activate_set(_eflutil_defaultqueue.wl.gesture.proto, NULL, type, active); - while (_eflutil_defaultqueue.wl.gesture.request_notified == -1) - wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); - - ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified); - _eflutil_defaultqueue.wl.gesture.request_notified = -1; + ret = _efl_util_gesture_verify_request_notified(); return ret; } @@ -3060,11 +3225,7 @@ efl_util_gesture_activate_set_on_window(efl_util_gesture_h gesture_h, Evas_Objec tizen_gesture_activate_set(_eflutil_defaultqueue.wl.gesture.proto, surface, type, active); - while (_eflutil_defaultqueue.wl.gesture.request_notified == -1) - wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); - - ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified); - _eflutil_defaultqueue.wl.gesture.request_notified = -1; + ret = _efl_util_gesture_verify_request_notified(); return ret; }