evdev: Release still pressed keys/buttons when removing device

When removing a device, its not guaranteed that all button or key
presses have been released, resulting in an invalid seat wide button
count.

Note that kernel devices normally will send release events when being
unplugged, but this won't happen when removing a device from the path
backend.

Signed-off-by: Jonas Ådahl <jadahl@gmail.com>
Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net>

diff --git a/src/evdev.c b/src/evdev.c
index a605964b6334a86d2698517e8a75e0d2f4c1a97a..b9f635dbdfee785c63dd85bb332f5f4c2610c32e 100644 (file)
--- a/src/evdev.c
+++ b/src/evdev.c
@@ -59,6 +59,12 @@ is_key_down(struct evdev_device *device, int code)
        return long_bit_is_set(device->key_mask, code);
 }
 
+static int
+get_key_down_count(struct evdev_device *device, int code)
+{
+       return device->key_count[code];
+}
+
 static int
 update_key_down_count(struct evdev_device *device, int code, int pressed)
 {
@@ -1013,6 +1019,45 @@ evdev_device_get_size(struct evdev_device *device,
        return 0;
 }
 
+static void
+release_pressed_keys(struct evdev_device *device)
+{
+       struct libinput *libinput = device->base.seat->libinput;
+       struct timespec ts;
+       uint64_t time;
+       int code;
+
+       if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
+               log_bug_libinput(libinput, "clock_gettime: %s\n", strerror(errno));
+               return;
+       }
+
+       time = ts.tv_sec * 1000ULL + ts.tv_nsec / 1000000;
+
+       for (code = 0; code < KEY_CNT; code++) {
+               if (get_key_down_count(device, code) > 0) {
+                       switch (get_key_type(code)) {
+                       case EVDEV_KEY_TYPE_NONE:
+                               break;
+                       case EVDEV_KEY_TYPE_KEY:
+                               keyboard_notify_key(
+                                       &device->base,
+                                       time,
+                                       code,
+                                       LIBINPUT_KEY_STATE_RELEASED);
+                               break;
+                       case EVDEV_KEY_TYPE_BUTTON:
+                               pointer_notify_button(
+                                       &device->base,
+                                       time,
+                                       code,
+                                       LIBINPUT_BUTTON_STATE_RELEASED);
+                               break;
+                       }
+               }
+       }
+}
+
 void
 evdev_device_remove(struct evdev_device *device)
 {
@@ -1020,6 +1065,8 @@ evdev_device_remove(struct evdev_device *device)
                libinput_remove_source(device->base.seat->libinput,
                                       device->source);
 
+       release_pressed_keys(device);
+
        if (device->mtdev)
                mtdev_close_delete(device->mtdev);
        close_restricted(device->base.seat->libinput, device->fd);

diff --git a/test/keyboard.c b/test/keyboard.c
index c2040ccd5272694cd737e72900d442956a137a72..4563ce6ff78af2541435eb22d1bb7b12051e7d9c 100644 (file)
--- a/test/keyboard.c
+++ b/test/keyboard.c
@@ -25,6 +25,7 @@
 #include <check.h>
 #include <stdio.h>
 
+#include "libinput-util.h"
 #include "litest.h"
 
 START_TEST(keyboard_seat_key_count)
@@ -174,11 +175,127 @@ START_TEST(keyboard_ignore_no_pressed_release)
 }
 END_TEST
 
+static void
+test_key_event(struct litest_device *dev, unsigned int key, int state)
+{
+       struct libinput *li = dev->libinput;
+       struct libinput_event *event;
+       struct libinput_event_keyboard *kevent;
+
+       litest_event(dev, EV_KEY, key, state);
+       litest_event(dev, EV_SYN, SYN_REPORT, 0);
+
+       libinput_dispatch(li);
+
+       event = libinput_get_event(li);
+       ck_assert(event != NULL);
+       ck_assert_int_eq(libinput_event_get_type(event), LIBINPUT_EVENT_KEYBOARD_KEY);
+
+       kevent = libinput_event_get_keyboard_event(event);
+       ck_assert(kevent != NULL);
+       ck_assert_int_eq(libinput_event_keyboard_get_key(kevent), key);
+       ck_assert_int_eq(libinput_event_keyboard_get_key_state(kevent),
+                        state ? LIBINPUT_KEY_STATE_PRESSED :
+                                LIBINPUT_KEY_STATE_RELEASED);
+       libinput_event_destroy(event);
+}
+
+START_TEST(keyboard_key_auto_release)
+{
+       struct libinput *libinput;
+       struct litest_device *dev;
+       struct libinput_event *event;
+       enum libinput_event_type type;
+       struct libinput_event_keyboard *kevent;
+       struct {
+               int code;
+               int released;
+       } keys[] = {
+               { .code = KEY_A, },
+               { .code = KEY_S, },
+               { .code = KEY_D, },
+               { .code = KEY_G, },
+               { .code = KEY_Z, },
+               { .code = KEY_DELETE, },
+               { .code = KEY_F24, },
+       };
+       int events[2 * (ARRAY_LENGTH(keys) + 1)];
+       unsigned i;
+       int key;
+       int valid_code;
+
+       /* Enable all tested keys on the device */
+       i = 0;
+       while (i < 2 * ARRAY_LENGTH(keys)) {
+               key = keys[i / 2].code;
+               events[i++] = EV_KEY;
+               events[i++] = key;
+       }
+       events[i++] = -1;
+       events[i++] = -1;
+
+       libinput = litest_create_context();
+       dev = litest_add_device_with_overrides(libinput,
+                                              LITEST_KEYBOARD,
+                                              "Generic keyboard",
+                                              NULL, NULL, events);
+
+       litest_drain_events(libinput);
+
+       /* Send pressed events, without releasing */
+       for (i = 0; i < ARRAY_LENGTH(keys); ++i) {
+               test_key_event(dev, keys[i].code, 1);
+       }
+
+       litest_drain_events(libinput);
+
+       /* "Disconnect" device */
+       litest_delete_device(dev);
+
+       /* Mark all released keys until device is removed */
+       while (1) {
+               event = libinput_get_event(libinput);
+               ck_assert_notnull(event);
+               type = libinput_event_get_type(event);
+
+               if (type == LIBINPUT_EVENT_DEVICE_REMOVED) {
+                       libinput_event_destroy(event);
+                       break;
+               }
+
+               ck_assert_int_eq(type, LIBINPUT_EVENT_KEYBOARD_KEY);
+               kevent = libinput_event_get_keyboard_event(event);
+               ck_assert_int_eq(libinput_event_keyboard_get_key_state(kevent),
+                                LIBINPUT_KEY_STATE_RELEASED);
+               key = libinput_event_keyboard_get_key(kevent);
+
+               valid_code = 0;
+               for (i = 0; i < ARRAY_LENGTH(keys); ++i) {
+                       if (keys[i].code == key) {
+                               ck_assert_int_eq(keys[i].released, 0);
+                               keys[i].released = 1;
+                               valid_code = 1;
+                       }
+               }
+               ck_assert_int_eq(valid_code, 1);
+               libinput_event_destroy(event);
+       }
+
+       /* Check that all pressed keys has been released. */
+       for (i = 0; i < ARRAY_LENGTH(keys); ++i) {
+               ck_assert_int_eq(keys[i].released, 1);
+       }
+
+       libinput_unref(libinput);
+}
+END_TEST
+
 int
 main(int argc, char **argv)
 {
        litest_add_no_device("keyboard:seat key count", keyboard_seat_key_count);
        litest_add_no_device("keyboard:key counting", keyboard_ignore_no_pressed_release);
+       litest_add_no_device("keyboard:key counting", keyboard_key_auto_release);
 
        return litest_run(argc, argv);
 }

diff --git a/test/pointer.c b/test/pointer.c
index aa75274b1330f3ccef5376ac156d2d956d041419..c0af460c6ffc016e9ffbc88d32feb3bde3be5d09 100644 (file)
--- a/test/pointer.c
+++ b/test/pointer.c
@@ -152,6 +152,95 @@ START_TEST(pointer_button)
 }
 END_TEST
 
+START_TEST(pointer_button_auto_release)
+{
+       struct libinput *libinput;
+       struct litest_device *dev;
+       struct libinput_event *event;
+       enum libinput_event_type type;
+       struct libinput_event_pointer *pevent;
+       struct {
+               int code;
+               int released;
+       } buttons[] = {
+               { .code = BTN_LEFT, },
+               { .code = BTN_MIDDLE, },
+               { .code = BTN_EXTRA, },
+               { .code = BTN_SIDE, },
+               { .code = BTN_BACK, },
+               { .code = BTN_FORWARD, },
+               { .code = BTN_4, },
+       };
+       int events[2 * (ARRAY_LENGTH(buttons) + 1)];
+       unsigned i;
+       int button;
+       int valid_code;
+
+       /* Enable all tested buttons on the device */
+       for (i = 0; i < 2 * ARRAY_LENGTH(buttons);) {
+               button = buttons[i / 2].code;
+               events[i++] = EV_KEY;
+               events[i++] = button;
+       }
+       events[i++] = -1;
+       events[i++] = -1;
+
+       libinput = litest_create_context();
+       dev = litest_add_device_with_overrides(libinput,
+                                              LITEST_MOUSE,
+                                              "Generic mouse",
+                                              NULL, NULL, events);
+
+       litest_drain_events(libinput);
+
+       /* Send pressed events, without releasing */
+       for (i = 0; i < ARRAY_LENGTH(buttons); ++i) {
+               test_button_event(dev, buttons[i].code, 1);
+       }
+
+       litest_drain_events(libinput);
+
+       /* "Disconnect" device */
+       litest_delete_device(dev);
+
+       /* Mark all released buttons until device is removed */
+       while (1) {
+               event = libinput_get_event(libinput);
+               ck_assert_notnull(event);
+               type = libinput_event_get_type(event);
+
+               if (type == LIBINPUT_EVENT_DEVICE_REMOVED) {
+                       libinput_event_destroy(event);
+                       break;
+               }
+
+               ck_assert_int_eq(type, LIBINPUT_EVENT_POINTER_BUTTON);
+               pevent = libinput_event_get_pointer_event(event);
+               ck_assert_int_eq(libinput_event_pointer_get_button_state(pevent),
+                                LIBINPUT_BUTTON_STATE_RELEASED);
+               button = libinput_event_pointer_get_button(pevent);
+
+               valid_code = 0;
+               for (i = 0; i < ARRAY_LENGTH(buttons); ++i) {
+                       if (buttons[i].code == button) {
+                               ck_assert_int_eq(buttons[i].released, 0);
+                               buttons[i].released = 1;
+                               valid_code = 1;
+                       }
+               }
+               ck_assert_int_eq(valid_code, 1);
+               libinput_event_destroy(event);
+       }
+
+       /* Check that all pressed buttons has been released. */
+       for (i = 0; i < ARRAY_LENGTH(buttons); ++i) {
+               ck_assert_int_eq(buttons[i].released, 1);
+       }
+
+       libinput_unref(libinput);
+}
+END_TEST
+
 static void
 test_wheel_event(struct litest_device *dev, int which, int amount)
 {
@@ -300,6 +389,7 @@ int main (int argc, char **argv) {
 
        litest_add("pointer:motion", pointer_motion_relative, LITEST_POINTER, LITEST_ANY);
        litest_add("pointer:button", pointer_button, LITEST_BUTTON, LITEST_CLICKPAD);
+       litest_add_no_device("pointer:button_auto_release", pointer_button_auto_release);
        litest_add("pointer:scroll", pointer_scroll_wheel, LITEST_WHEEL, LITEST_ANY);
        litest_add_no_device("pointer:seat button count", pointer_seat_button_count);