2 #include <time.h> // gettimeofday()
3 #include <libds/backend.h>
5 #include <libds-tizen/input-devicemgr.h>
6 #include <libds/interfaces/backend.h>
7 #include <libds/interfaces/keyboard.h>
8 #include <libds/seat.h>
11 #include "input-devicemgr.h"
12 #include "src/libds/seat.h"
14 #define TIZEN_INPUT_DEVICEMGR_VERSION 4
15 #define TIZEN_PRIV_INPUT_GENERATOR "http://tizen.org/privilege/inputgenerator"
16 #define TIZEN_PRIV_INPUT_BLOCK "http://tizen.org/privilege/internal/inputdevice.block"
18 static const struct ds_keyboard_grab_interface devicemgr_keyboard_grab_iface;
22 backend_handle_destroy(struct wl_listener *listener, void *data);
24 backend_handle_input_device_add(struct wl_listener *listener, void *data);
26 seat_handle_destroy(struct wl_listener *listener, void *data);
28 //tizen_input_device_manager bind/unbind
30 device_manager_handle_bind(struct wl_client *client, void *data,
31 uint32_t version, uint32_t id);
33 device_manager_client_handle_resource_destroy(struct wl_resource *resource);
35 //tizen_input_device_manager's handlers for requests
37 device_manager_handle_block_events(struct wl_client *client,
38 struct wl_resource *resource, uint32_t serial,
39 uint32_t clas, uint32_t duration);
41 device_manager_handle_unblock_events(struct wl_client *client,
42 struct wl_resource *resource, uint32_t serial);
44 device_manager_handle_init_generator(struct wl_client *client,
45 struct wl_resource *resource, uint32_t clas);
47 device_manager_handle_init_generator_with_name(struct wl_client *client,
48 struct wl_resource *resource, uint32_t clas, const char *name);
50 device_manager_handle_deinit_generator(struct wl_client *client,
51 struct wl_resource *resource, uint32_t clas);
53 device_manager_handle_generate_key(struct wl_client *client,
54 struct wl_resource *resource,
55 const char *keyname, uint32_t pressed);
57 device_manager_handle_destroy(struct wl_client *client,
58 struct wl_resource *resource);
61 static void tz_devicemgr_destroy(struct ds_tizen_input_devicemgr *tz_devicemgr);
63 tz_devicemgr_init_generator(struct ds_tizen_input_devicemgr *tz_devicemgr,
64 struct wl_resource *resource, const char *name);
66 tz_devicemgr_deinit_generator(struct ds_tizen_input_devicemgr *tz_devicemgr,
67 struct wl_resource *resource);
69 tz_devicemgr_generate_key(struct ds_input_device *device, int keycode,
72 tz_devicemgr_pressed_keys_update(struct ds_tizen_input_devicemgr *tz_devicemgr,
73 int keycode, bool pressed);
75 tz_devicemgr_pressed_keys_cleanup(struct ds_tizen_input_devicemgr *tz_devicemgr);
77 tz_devicemgr_keymap_list_cleanup(struct ds_tizen_input_devicemgr *tz_devicemgr);
79 tz_devicemgr_keyname_to_keycode(struct wl_list *list, const char *name);
82 tz_devicemgr_check_privilege(struct ds_tizen_input_devicemgr *tz_devicemgr,
83 struct wl_client *client, const char *rule);
86 tz_devicemgr_grab_keyboard(struct ds_tizen_input_devicemgr *tz_devicemgr);
88 tz_devicemgr_ungrab_keyboard(struct ds_tizen_input_devicemgr *tz_devicemgr);
90 tz_devicemgr_ungrab_keyboard_check(struct ds_tizen_input_devicemgr *tz_devicemgr);
92 tz_devicemgr_blocked_keys_cleanup(struct ds_tizen_input_devicemgr *tz_devicemgr);
94 WL_EXPORT struct ds_tizen_input_devicemgr *
95 ds_tizen_input_devicemgr_create(struct ds_backend *backend,
98 struct ds_tizen_input_devicemgr *tz_devicemgr;
100 tz_devicemgr = calloc(1, sizeof *tz_devicemgr);
102 ds_err("Fail to allocate ds_tizen_input_devicemgr");
106 tz_devicemgr->backend = backend;
107 tz_devicemgr->backend_destroy.notify = backend_handle_destroy;
108 ds_backend_add_destroy_listener(backend, &tz_devicemgr->backend_destroy);
110 tz_devicemgr->seat = seat;
111 tz_devicemgr->seat_destroy.notify = seat_handle_destroy;
112 ds_seat_add_destroy_listener(seat, &tz_devicemgr->seat_destroy);
114 tz_devicemgr->new_input.notify = backend_handle_input_device_add;
115 ds_backend_add_new_input_listener(backend, &tz_devicemgr->new_input);
117 tz_devicemgr->global = wl_global_create(backend->display,
118 &tizen_input_device_manager_interface,
119 TIZEN_INPUT_DEVICEMGR_VERSION,
120 tz_devicemgr, device_manager_handle_bind);
121 if (!tz_devicemgr->global) {
125 tz_devicemgr->devices.kbd = calloc(1,
126 sizeof(struct ds_tizen_input_devicemgr_device));
127 if (!tz_devicemgr->devices.kbd) {
131 tz_devicemgr->grab = calloc(1, sizeof(struct ds_seat_keyboard_grab));
132 if (!tz_devicemgr->grab)
137 tz_devicemgr->grab->iface = &devicemgr_keyboard_grab_iface;
138 tz_devicemgr->grab->seat = tz_devicemgr->seat;
139 tz_devicemgr->grab->data = tz_devicemgr;
141 wl_signal_init(&tz_devicemgr->events.destroy);
142 wl_list_init(&tz_devicemgr->clients);
143 wl_list_init(&tz_devicemgr->pressed_keys);
144 wl_list_init(&tz_devicemgr->keymap_list);
145 wl_list_init(&tz_devicemgr->blocked_keys);
147 if (!tizen_security_init()) {
148 ds_inf("tizen_security_init() is failed. go on without security");
151 ds_inf("Global created: ds_tizen_input_devicemgr(%p) ", tz_devicemgr);
154 free(tz_devicemgr->devices.kbd);
156 wl_global_destroy(tz_devicemgr->global);
158 wl_list_remove(&tz_devicemgr->backend_destroy.link);
159 wl_list_remove(&tz_devicemgr->seat_destroy.link);
160 wl_list_remove(&tz_devicemgr->new_input.link);
166 ds_tizen_input_devicemgr_add_destroy_listener(
167 struct ds_tizen_input_devicemgr *tz_devicemgr,
168 struct wl_listener *listener)
170 wl_signal_add(&tz_devicemgr->events.destroy, listener);
174 ds_tizen_input_devicemgr_set_keymap_list(
175 struct ds_tizen_input_devicemgr *tz_devicemgr, struct wl_list *list)
177 struct ds_tizen_input_devicemgr_keymap_data *data, *new_data;
179 if (!tz_devicemgr || !list) {
180 ds_err("Please insert correct data\n");
184 wl_list_for_each(data, list, link) {
185 new_data = calloc(1, sizeof *data);
187 ds_err("Failed to alloc memory");
190 new_data->name = strdup(data->name);
191 new_data->keycode = data->keycode;
192 wl_list_insert(&tz_devicemgr->keymap_list, &new_data->link);
194 ds_inf("keymap set. length:%d",
195 wl_list_length(&tz_devicemgr->keymap_list));
201 tz_devicemgr_destroy(struct ds_tizen_input_devicemgr *tz_devicemgr)
203 struct ds_tizen_input_devicemgr_client *client_data, *tmp;
205 tizen_security_finish();
207 tz_devicemgr_keymap_list_cleanup(tz_devicemgr);
208 tz_devicemgr_blocked_keys_cleanup(tz_devicemgr);
209 tz_devicemgr_ungrab_keyboard(tz_devicemgr);
211 wl_signal_emit(&tz_devicemgr->events.destroy, tz_devicemgr);
212 wl_list_remove(&tz_devicemgr->backend_destroy.link);
213 wl_list_remove(&tz_devicemgr->seat_destroy.link);
214 wl_list_remove(&tz_devicemgr->new_input.link);
216 wl_global_destroy(tz_devicemgr->global);
218 wl_list_for_each_safe(client_data, tmp, &tz_devicemgr->clients, link) {
219 wl_list_remove(&client_data->link);
220 tz_devicemgr_deinit_generator(tz_devicemgr, client_data->resource);
222 wl_resource_set_user_data(client_data->resource, NULL);
226 free(tz_devicemgr->devices.kbd);
227 free(tz_devicemgr->grab);
232 backend_handle_destroy(struct wl_listener *listener, void *data)
234 struct ds_tizen_input_devicemgr *tz_devicemgr;
236 tz_devicemgr = wl_container_of(listener, tz_devicemgr, backend_destroy);
238 ds_inf("Global destroy: ds_tizen_input_devicemgr(%p)", tz_devicemgr);
240 tz_devicemgr_destroy(tz_devicemgr);
244 seat_handle_destroy(struct wl_listener *listener, void *data)
246 struct ds_tizen_input_devicemgr *tz_devicemgr;
248 tz_devicemgr = wl_container_of(listener, tz_devicemgr, backend_destroy);
250 wl_list_remove(&tz_devicemgr->seat_destroy.link);
251 wl_list_init(&tz_devicemgr->seat_destroy.link);
252 tz_devicemgr->seat = NULL;
256 backend_handle_input_device_add(struct wl_listener *listener, void *data)
258 struct ds_input_device *dev = data;
259 struct ds_tizen_input_devicemgr *tz_devicemgr;
260 enum ds_input_device_type dev_type;
262 tz_devicemgr = wl_container_of(listener, tz_devicemgr, new_input);
264 dev_type = ds_input_device_get_type(dev);
265 if (dev_type == DS_INPUT_DEVICE_KEYBOARD) {
266 if (tz_devicemgr->devices.kbd->input_device) return;
267 ds_inf("devicemgr's kbd device is set");
268 tz_devicemgr->devices.kbd->input_device = dev;
270 else if (dev_type == DS_INPUT_DEVICE_POINTER) {
271 //TODO: assign input_device 'dev' to devices.ptr
273 else if (dev_type == DS_INPUT_DEVICE_TOUCH) {
274 //TODO: assign input_device 'dev' to devices.ptr
278 static const struct tizen_input_device_manager_interface _devicemgr_impl = {
279 .block_events = device_manager_handle_block_events,
280 .unblock_events = device_manager_handle_unblock_events,
281 .init_generator = device_manager_handle_init_generator,
282 .deinit_generator = device_manager_handle_deinit_generator,
283 .generate_key = device_manager_handle_generate_key,
284 .generate_pointer = NULL,
285 .generate_touch = NULL,
286 .pointer_warp = NULL,
287 .init_generator_with_name =
288 device_manager_handle_init_generator_with_name, // v2
289 .destroy = device_manager_handle_destroy, // v3
290 .generate_axis = NULL, // v3
291 .set_touch_count = NULL, // v4
295 device_manager_client_handle_resource_destroy(struct wl_resource *resource)
297 struct ds_tizen_input_devicemgr *tz_devicemgr;
298 struct ds_tizen_input_devicemgr_client *client_data, *tmp;
300 tz_devicemgr = wl_resource_get_user_data(resource);
302 tz_devicemgr_deinit_generator(tz_devicemgr, resource);
304 if (resource == tz_devicemgr->block_resource) {
305 tz_devicemgr_ungrab_keyboard_check(tz_devicemgr);
306 if (tz_devicemgr->timer) {
307 wl_event_source_remove(tz_devicemgr->timer);
308 tz_devicemgr->timer = NULL;
312 wl_list_for_each_safe(client_data, tmp, &tz_devicemgr->clients, link) {
313 if (client_data->resource == resource) {
314 wl_list_remove(&client_data->link);
321 device_manager_handle_bind(struct wl_client *client, void *data,
322 uint32_t version, uint32_t id)
324 struct ds_tizen_input_devicemgr *tz_devicemgr = data;
325 struct ds_tizen_input_devicemgr_client *client_data;
327 client_data = calloc(1, sizeof *client_data);
329 ds_err("Failed to allocate memory !\n");
330 wl_client_post_no_memory(client);
334 client_data->resource = wl_resource_create(client,
335 &tizen_input_device_manager_interface, MIN(version,4), id);
336 if (!client_data->resource) {
337 ds_err("Failed to create resource! (ver. :%d, id:%d)", version, id);
339 wl_client_post_no_memory(client);
343 client_data->init = false;
344 wl_list_init(&client_data->link);
345 wl_list_insert(&tz_devicemgr->clients, &client_data->link);
347 wl_resource_set_implementation(client_data->resource, &_devicemgr_impl,
348 tz_devicemgr, device_manager_client_handle_resource_destroy);
352 device_manager_handle_init_generator(struct wl_client *client,
353 struct wl_resource *resource, uint32_t clas)
355 struct ds_tizen_input_devicemgr *tz_devicemgr;
356 int ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_SYSTEM_RESOURCES;
358 tz_devicemgr = wl_resource_get_user_data(resource);
360 if (!tz_devicemgr_check_privilege(tz_devicemgr, client,
361 TIZEN_PRIV_INPUT_GENERATOR)) {
362 ds_err("No permission to input generate");
363 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_PERMISSION;
367 if (clas != TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD) {
368 ds_err("only support keyboard device. (requested: 0x%x)\n", clas);
369 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_INVALID_PARAMETER;
373 ret = tz_devicemgr_init_generator(tz_devicemgr, resource,
375 if (ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE) {
376 ds_err("Failed to init input generator\n");
381 tizen_input_device_manager_send_error(resource, ret);
385 device_manager_handle_init_generator_with_name(struct wl_client *client,
386 struct wl_resource *resource, uint32_t clas, const char *name)
388 struct ds_tizen_input_devicemgr *tz_devicemgr;
389 int ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_SYSTEM_RESOURCES;
391 tz_devicemgr = wl_resource_get_user_data(resource);
394 ds_err("no name for device");
395 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_INVALID_PARAMETER;
399 if (!tz_devicemgr_check_privilege(tz_devicemgr, client,
400 TIZEN_PRIV_INPUT_GENERATOR)) {
401 ds_err("No permission to input generate");
402 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_PERMISSION;
406 if (clas != TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD) {
407 ds_err("only support keyboard device. (requested: 0x%x)\n", clas);
408 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_INVALID_PARAMETER;
412 ret = tz_devicemgr_init_generator(tz_devicemgr, resource,
414 if (ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE) {
415 ds_err("Failed to init input generator\n");
420 tizen_input_device_manager_send_error(resource, ret);
424 device_manager_handle_deinit_generator(struct wl_client *client,
425 struct wl_resource *resource, uint32_t clas)
427 struct ds_tizen_input_devicemgr *tz_devicemgr;
428 int ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_SYSTEM_RESOURCES;
430 tz_devicemgr = wl_resource_get_user_data(resource);
432 if (!tz_devicemgr_check_privilege(tz_devicemgr, client,
433 TIZEN_PRIV_INPUT_GENERATOR)) {
434 ds_err("No permission to input generate");
435 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_PERMISSION;
439 if (clas != TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD) {
440 ds_err("only support keyboard device. (requested: 0x%x)\n", clas);
441 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_INVALID_PARAMETER;
445 ret = tz_devicemgr_deinit_generator(tz_devicemgr, resource);
446 if (ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE) {
447 ds_err("Failed to deinit input generator\n");
452 tizen_input_device_manager_send_error(resource, ret);
457 xkb_keycode_t keycode;
461 find_keycode(struct xkb_keymap *keymap, xkb_keycode_t key, void *data)
463 struct keycode_map *found_keycodes = (struct keycode_map *)data;
464 xkb_keysym_t keysym = found_keycodes->keysym;
466 const xkb_keysym_t *syms_out = NULL;
468 if (found_keycodes->keycode) return;
470 nsyms = xkb_keymap_key_get_syms_by_level(keymap, key, 0, 0, &syms_out);
471 if (nsyms && syms_out) {
472 if (*syms_out == keysym) {
473 found_keycodes->keycode = key;
479 tz_devicemgr_xkb_keycode_from_keysym(struct xkb_keymap *keymap,
480 xkb_keysym_t keysym, xkb_keycode_t *keycode)
482 struct keycode_map found_keycodes = {0,};
483 found_keycodes.keysym = keysym;
484 xkb_keymap_key_for_each(keymap, find_keycode, &found_keycodes);
486 *keycode = found_keycodes.keycode;
490 tz_devicemgr_xkb_keyname_to_keycode(struct xkb_keymap *keymap,
493 xkb_keysym_t keysym = 0x0;
494 xkb_keycode_t keycode = 0;
496 if (!strncmp(name, "Keycode-", sizeof("Keycode-")-1)) {
497 keycode = atoi(name + 8);
499 keysym = xkb_keysym_from_name(name, XKB_KEYSYM_NO_FLAGS);
500 tz_devicemgr_xkb_keycode_from_keysym(keymap, keysym, &keycode);
507 device_manager_handle_generate_key(struct wl_client *client,
508 struct wl_resource *resource, const char *keyname, uint32_t pressed)
510 struct ds_tizen_input_devicemgr *tz_devicemgr;
511 int ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_SYSTEM_RESOURCES;
514 struct ds_keyboard *kbd;
516 tz_devicemgr = wl_resource_get_user_data(resource);
518 if (!tz_devicemgr->devices.kbd ||
519 !tz_devicemgr->devices.kbd->input_device) {
520 ds_err("Keyboard device is not initialized\n");
524 if (!tz_devicemgr_check_privilege(tz_devicemgr, client,
525 TIZEN_PRIV_INPUT_GENERATOR)) {
526 ds_err("No permission to input generate");
527 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_PERMISSION;
531 // keyname to keycode using xkb_info
532 kbd = ds_input_device_get_keyboard(
533 tz_devicemgr->devices.kbd->input_device);
535 keycode = tz_devicemgr_xkb_keyname_to_keycode(kbd->keymap, keyname);
539 keycode = tz_devicemgr_keyname_to_keycode(&tz_devicemgr->keymap_list,
545 res = tz_devicemgr_generate_key(tz_devicemgr->devices.kbd->input_device,
548 ds_err("Generating key is failed. key: %s, pressed: %d",
552 res = tz_devicemgr_pressed_keys_update(tz_devicemgr, keycode, pressed);
554 ds_err("Updating pressed keys is failed. key: %s, pressed: %d",
558 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE;
561 tizen_input_device_manager_send_error(resource, ret);
565 device_manager_handle_destroy(struct wl_client *client,
566 struct wl_resource *resource)
568 wl_resource_destroy(resource);
572 tz_devicemgr_check_privilege(struct ds_tizen_input_devicemgr *tz_devicemgr,
573 struct wl_client *client, const char *rule)
579 if (!client) return false;
581 wl_client_get_credentials(client, &pid, &uid, &gid);
583 return tizen_security_check_privilege(pid, uid, rule);
586 static const struct ds_input_device_interface input_device_iface =
591 static struct ds_keyboard *
594 struct ds_keyboard *kbd;
595 kbd = calloc(1, sizeof *kbd);
597 ds_err("Could not allocate memory");
600 ds_keyboard_init(kbd, NULL);
606 tz_devicemgr_init_generator(struct ds_tizen_input_devicemgr *tz_devicemgr,
607 struct wl_resource *resource, const char *name)
609 int ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_SYSTEM_RESOURCES;
610 struct ds_tizen_input_devicemgr_client *client_data;
611 struct ds_tizen_input_devicemgr_device *kbd;
613 ds_inf("Init generator. name:%s", name);
615 kbd = tz_devicemgr->devices.kbd;
616 if (strlen(kbd->name) > 0) {
617 ds_inf("devices.kbd already has name. name:%s", kbd->name);
618 return TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE;
621 if (kbd->input_device) {
622 ds_inf("devices.kbd is already set. name:%s",
623 ds_input_device_get_name(kbd->input_device));
624 return TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE;
627 //input_device create
628 kbd->input_device = calloc(1, sizeof(struct ds_input_device));
629 if(!kbd->input_device) {
630 ds_err("Failed to create input device !\n");
634 ds_input_device_init(kbd->input_device, DS_INPUT_DEVICE_KEYBOARD,
635 &input_device_iface, name, -1, -1);
636 kbd->input_device->keyboard = create_ds_keyboard();
638 wl_signal_emit(&tz_devicemgr->backend->events.new_input,
642 strncpy(kbd->name, name, UINPUT_MAX_NAME_SIZE);
644 wl_list_for_each(client_data, &tz_devicemgr->clients, link) {
645 if (client_data->resource == resource) {
646 if (client_data->init == false) {
647 client_data->init = true;
654 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE;
660 tz_devicemgr_keyname_to_keycode(struct wl_list *list, const char *name)
662 struct ds_tizen_input_devicemgr_keymap_data *data;
664 if (!wl_list_empty(list)) {
665 wl_list_for_each(data, list, link) {
666 if (!strcmp(data->name, name)) {
667 return data->keycode;
676 tz_devicemgr_generate_key(struct ds_input_device *device, int keycode,
679 struct ds_event_keyboard_key ds_event;
681 unsigned int timestamp;
682 struct ds_keyboard *kbd;
684 kbd = ds_input_device_get_keyboard(device);
686 ds_err("No ds_keyboard to notify event");
690 gettimeofday(&time, NULL);
691 timestamp = time.tv_sec * 1000 + time.tv_usec / 1000;
693 ds_event.time_msec = timestamp;
694 ds_event.keycode = keycode - 8;
696 ds_event.state = WL_KEYBOARD_KEY_STATE_PRESSED;
698 ds_event.state = WL_KEYBOARD_KEY_STATE_RELEASED;
700 ds_inf("Generate key. kbd:%p, key:%d, state:%s", kbd, ds_event.keycode,
701 (ds_event.state == WL_KEYBOARD_KEY_STATE_PRESSED) ?
702 "PRESSED" : "RELEASED");
704 ds_keyboard_notify_key(kbd, &ds_event);
710 tz_devicemgr_pressed_keys_update(struct ds_tizen_input_devicemgr *tz_devicemgr,
711 int keycode, bool pressed)
713 struct ds_tizen_input_devicemgr_key_info *key, *tmp;
716 key = calloc(1, sizeof(*key));
718 ds_err("Failed to alloc keydata memory.\n");
721 key->keycode = keycode;
722 wl_list_init(&key->link);
723 wl_list_insert(&tz_devicemgr->pressed_keys, &key->link);
726 wl_list_for_each_safe(key, tmp, &tz_devicemgr->pressed_keys, link) {
727 if (key->keycode == keycode) {
728 wl_list_remove(&key->link);
735 ds_inf("Update pressed keys. length: %d, keycode:%d, pressed:%d",
736 wl_list_length(&tz_devicemgr->pressed_keys), keycode, pressed);
742 tz_devicemgr_pressed_keys_cleanup(struct ds_tizen_input_devicemgr *tz_devicemgr)
744 struct ds_tizen_input_devicemgr_key_info *keydata, *tmp;
746 ds_inf("Clean up the pressed_keys. length: %d",
747 wl_list_length(&tz_devicemgr->pressed_keys));
749 wl_list_for_each_safe(keydata, tmp, &tz_devicemgr->pressed_keys, link) {
750 if (tz_devicemgr->devices.kbd)
751 tz_devicemgr_generate_key(tz_devicemgr->devices.kbd->input_device,
752 keydata->keycode, false);
753 wl_list_remove(&keydata->link);
759 tz_devicemgr_keymap_list_cleanup(struct ds_tizen_input_devicemgr *tz_devicemgr)
761 struct ds_tizen_input_devicemgr_keymap_data *keymap, *tmp;
763 ds_inf("Clean up the keymap_list. length: %d",
764 wl_list_length(&tz_devicemgr->keymap_list));
766 wl_list_for_each_safe(keymap, tmp, &tz_devicemgr->keymap_list, link) {
768 wl_list_remove(&keymap->link);
774 tz_devicemgr_keyboard_close(struct ds_tizen_input_devicemgr *tz_devicemgr)
776 if (!tz_devicemgr->devices.kbd->input_device) return;
777 ds_input_device_destroy(tz_devicemgr->devices.kbd->input_device);
778 tz_devicemgr->devices.kbd->input_device = NULL;
779 tz_devicemgr->devices.kbd->created = false;
783 tz_devicemgr_deinit_generator(struct ds_tizen_input_devicemgr *tz_devicemgr,
784 struct wl_resource *resource)
786 int ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE;
787 struct ds_tizen_input_devicemgr_client *client_data;
789 ds_inf("Deinit generator.");
790 wl_list_for_each(client_data, &tz_devicemgr->clients, link) {
791 if (client_data->resource == resource) {
792 if (client_data->init == true) {
793 client_data->init = false;
795 if (tz_devicemgr->ref < 0) tz_devicemgr->ref = 0;
803 if (tz_devicemgr->ref <= 0) {
804 tz_devicemgr_pressed_keys_cleanup(tz_devicemgr);
806 if (!tz_devicemgr->devices.kbd)
807 return TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE;
809 if (tz_devicemgr->devices.kbd->created)
810 tz_devicemgr_keyboard_close(tz_devicemgr);
811 memset(tz_devicemgr->devices.kbd->name, 0, UINPUT_MAX_NAME_SIZE);
818 devicemgr_keyboard_grab_iface_enter(struct ds_seat_keyboard_grab *grab,
819 struct ds_surface *surface, uint32_t keycodes[],
820 size_t num_keycodes, struct ds_keyboard_modifiers *modifiers)
822 ds_inf("devicemgr. keyboard_grab_iface_enter");
826 devicemgr_keyboard_grab_iface_clear_focus(struct ds_seat_keyboard_grab *grab)
828 ds_inf("devicemgr. keyboard_grab_iface_clear_focus");
832 tz_devicemgr_blocked_keys_cleanup(struct ds_tizen_input_devicemgr *tz_devicemgr)
834 struct ds_tizen_input_devicemgr_key_info *keydata, *tmp;
836 ds_inf("Clean up the blocked keys. length: %d",
837 wl_list_length(&tz_devicemgr->blocked_keys));
839 wl_list_for_each_safe(keydata, tmp, &tz_devicemgr->blocked_keys, link) {
840 wl_list_remove(&keydata->link);
846 devicemgr_keyboard_grab_iface_key(struct ds_seat_keyboard_grab *grab,
847 uint32_t time_msec, uint32_t key, uint32_t state)
849 struct ds_tizen_input_devicemgr *devicemgr = grab->data;
850 struct ds_tizen_input_devicemgr_key_info *keydata, *tmp;
851 bool key_blocked = false;
853 ds_inf("devicemgr. keyboard_grab_iface_key");
855 if (!devicemgr->block_resource) {
856 if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
860 wl_list_for_each_safe(keydata, tmp, &devicemgr->blocked_keys, link) {
861 if (keydata->keycode == (int)key) {
862 wl_list_remove(&keydata->link);
868 if (wl_list_empty(&devicemgr->blocked_keys)) {
869 tz_devicemgr_ungrab_keyboard(devicemgr);
877 if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
878 keydata = calloc(1, sizeof (*keydata));
881 keydata->keycode = key;
882 wl_list_init(&keydata->link);
883 wl_list_insert(&devicemgr->blocked_keys, &keydata->link);
887 if (wl_list_empty(&devicemgr->blocked_keys))
889 wl_list_for_each_safe(keydata, tmp, &devicemgr->blocked_keys, link) {
890 if (keydata->keycode == (int)key) {
891 wl_list_remove(&keydata->link);
900 ds_inf("block key event: (%d %s)\n", key, (state ? "press" : "release"));
904 devicemgr_modifiers_grab_iface_key(struct ds_seat_keyboard_grab *grab,
905 struct ds_keyboard_modifiers *modifiers)
907 ds_inf("devicemgr. modifiers_grab_iface_key");
911 devicemgr_cancel_grab_iface_key(struct ds_seat_keyboard_grab *grab)
913 ds_inf("devicemgr. cancel_grab_iface_key");
916 static const struct ds_keyboard_grab_interface devicemgr_keyboard_grab_iface = {
917 .enter = devicemgr_keyboard_grab_iface_enter,
918 .clear_focus = devicemgr_keyboard_grab_iface_clear_focus,
919 .key = devicemgr_keyboard_grab_iface_key,
920 .modifiers = devicemgr_modifiers_grab_iface_key,
921 .cancel = devicemgr_cancel_grab_iface_key,
925 tz_devicemgr_grab_keyboard(struct ds_tizen_input_devicemgr *tz_devicemgr)
927 ds_seat_keyboard_start_grab(tz_devicemgr->seat, tz_devicemgr->grab);
931 tz_devicemgr_ungrab_keyboard(struct ds_tizen_input_devicemgr *tz_devicemgr)
933 ds_seat_keyboard_end_grab(tz_devicemgr->seat);
937 tz_devicemgr_ungrab_keyboard_check(struct ds_tizen_input_devicemgr *tz_devicemgr)
939 if (wl_list_empty(&tz_devicemgr->blocked_keys))
940 tz_devicemgr_ungrab_keyboard(tz_devicemgr);
942 tz_devicemgr->block_resource = NULL;
946 devicemgr_add_timer(struct ds_tizen_input_devicemgr *tz_devicemgr,
947 wl_event_loop_timer_func_t func, int time)
949 struct wl_event_loop *event_loop;
951 event_loop = wl_display_get_event_loop(tz_devicemgr->backend->display);
953 ds_err("Failed to get event_loop from display: %p",
954 tz_devicemgr->backend->display);
958 tz_devicemgr->timer = wl_event_loop_add_timer(event_loop, func,
960 if (!tz_devicemgr->timer) {
961 ds_err("Failed to timer");
964 wl_event_source_timer_update(tz_devicemgr->timer, time);
970 devicemgr_block_timer(void *data)
972 struct ds_tizen_input_devicemgr *devicemgr = data;
974 tizen_input_device_manager_send_block_expired(devicemgr->block_resource);
976 tz_devicemgr_ungrab_keyboard_check(devicemgr);
978 wl_event_source_remove(devicemgr->timer);
979 devicemgr->timer = NULL;
985 device_manager_handle_block_events(struct wl_client *client,
986 struct wl_resource *resource, uint32_t serial, uint32_t clas,
989 struct ds_tizen_input_devicemgr *tz_devicemgr;
990 int ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_SYSTEM_RESOURCES;
993 tz_devicemgr = wl_resource_get_user_data(resource);
995 if (!tz_devicemgr_check_privilege(tz_devicemgr, client,
996 TIZEN_PRIV_INPUT_BLOCK)) {
997 ds_err("No permission to input generate");
998 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_PERMISSION;
1002 if (clas != TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD) {
1003 ds_err("only support keyboard device. (requested: 0x%x)\n", clas);
1004 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_INVALID_PARAMETER;
1008 if(tz_devicemgr->block_resource) {
1009 ds_err("currently the input system is already blocked\n");
1010 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_INVALID_PARAMETER;
1014 res = devicemgr_add_timer(tz_devicemgr, devicemgr_block_timer, duration);
1016 ds_err("Failed to add a timer\n");
1020 tz_devicemgr_grab_keyboard(tz_devicemgr);
1021 tz_devicemgr->block_resource = resource;
1022 ds_inf("Block events. clas: %d, duration:%d", clas, duration);
1023 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE;
1026 tizen_input_device_manager_send_error(resource, ret);
1030 device_manager_handle_unblock_events(struct wl_client *client,
1031 struct wl_resource *resource, uint32_t serial)
1033 struct ds_tizen_input_devicemgr *tz_devicemgr;
1034 int ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_SYSTEM_RESOURCES;
1036 tz_devicemgr = wl_resource_get_user_data(resource);
1038 if (!tz_devicemgr_check_privilege(tz_devicemgr, client,
1039 TIZEN_PRIV_INPUT_BLOCK)) {
1040 ds_err("No permission to input generate");
1041 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_PERMISSION;
1045 if (tz_devicemgr->block_resource != resource) {
1046 ds_err("currently the input system is blocked by another resource");
1047 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_INVALID_PARAMETER;
1051 tz_devicemgr_ungrab_keyboard_check(tz_devicemgr);
1052 tz_devicemgr->block_resource = NULL;
1053 ds_inf("Unblock events.");
1054 ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE;
1056 if (tz_devicemgr->timer) {
1057 wl_event_source_remove(tz_devicemgr->timer);
1058 tz_devicemgr->timer = NULL;
1062 tizen_input_device_manager_send_error(resource, ret);