Merge pull request #84 from quaxalber/development

Fix long device connection times (#59)

Author: quaxalber

README.md

@@ -151,7 +151,7 @@ Follow these steps to install and configure the project:
                  └─1326 python3.11 /home/user/bluetooth_2_usb/bluetooth_2_usb.py --auto_discover
 
     Dec 02 23:16:37 pi0w systemd[1]: Started bluetooth_2_usb.service - Bluetooth to USB HID relay.
-    Dec 02 23:16:39 pi0w bluetooth_2_usb[1326]: 23-12-02 23:16:39 [INFO] Launching Bluetooth 2 USB v0.6.6
+    Dec 02 23:16:39 pi0w bluetooth_2_usb[1326]: 23-12-02 23:16:39 [INFO] Launching Bluetooth 2 USB v0.6.7
     Dec 02 23:16:39 pi0w bluetooth_2_usb[1326]: 23-12-02 23:16:39 [INFO] Discovering input devices...
     Dec 02 23:16:42 pi0w bluetooth_2_usb[1326]: 23-12-02 23:16:42 [INFO] Activated relay for device /dev/input/event2, name "AceRK Mouse", phys "a1:b2:c3:d4:e5:f6"
     Dec 02 23:16:45 pi0w bluetooth_2_usb[1326]: 23-12-02 23:16:45 [INFO] Activated relay for device /dev/input/event1, name "AceRK Keyboard", phys "a1:b2:c3:d4:e5:f6"
@@ -368,7 +368,7 @@ Here's a few things you could try:
   user@pi0w:~ $ sudo service bluetooth_2_usb stop && sudo bluetooth_2_usb -i logi,a1:b2:c3:d4:e5:f6,/dev/input/event3 -d ; sudo service bluetooth_2_usb start
   23-12-06 14:19:36 [DEBUG] CLI args: Namespace(device_ids=['logi', 'a1:b2:c3:d4:e5:f6', '/dev/input/event3'], auto_discover=False, debug=True, log_to_file=False, log_path='/var/log/bluetooth_2_usb/bluetooth_2_usb.log', version=False, list_devices=False)
   23-12-06 14:19:36 [DEBUG] Logging to stdout
-  23-12-06 14:19:36 [INFO] Launching Bluetooth 2 USB v0.6.6
+  23-12-06 14:19:36 [INFO] Launching Bluetooth 2 USB v0.6.7
   23-12-06 14:19:36 [DEBUG] Available USB devices: [Mouse gadget (/dev/hidg0), Keyboard gadget (/dev/hidg1), Consumer control gadget (/dev/hidg2)]
   23-12-06 14:19:36 [INFO] Discovering input devices...
   23-12-06 14:19:36 [DEBUG] Relaying devices with matching name "logi" or MAC "a1:b2:c3:d4:e5:f6" or path "/dev/input/event3"

bluetooth_2_usb.py

@@ -13,7 +13,7 @@
 
 
 _logger = get_logger()
-_VERSION = "0.6.6"
+_VERSION = "0.6.7"
 _VERSIONED_NAME = f"Bluetooth 2 USB v{_VERSION}"
 
 

src/bluetooth_2_usb/relay.py

@@ -6,14 +6,7 @@
 from adafruit_hid.consumer_control import ConsumerControl
 from adafruit_hid.keyboard import Keyboard
 from adafruit_hid.mouse import Mouse
-from evdev import (
-    InputDevice,
-    InputEvent,
-    KeyEvent,
-    RelEvent,
-    categorize,
-    list_devices,
-)
+from evdev import InputDevice, InputEvent, KeyEvent, RelEvent, categorize, list_devices
 import usb_hid
 from usb_hid import Device
 
@@ -27,12 +20,34 @@
 
 
 _logger = get_logger()
+_keyboard_gadget: Keyboard = None
+_mouse_gadget: Mouse = None
+_consumer_gadget: ConsumerControl = None
 
 PATH = "path"
 MAC = "MAC"
 NAME = "name"
 
 
+def list_readable_devices() -> list[InputDevice]:
+    return [InputDevice(path) for path in list_devices()]
+
+
+def init_usb_devices() -> None:
+    usb_hid.enable(
+        [
+            Device.MOUSE,
+            Device.KEYBOARD,
+            Device.CONSUMER_CONTROL,
+        ]
+    )
+    _logger.debug(f"Available USB devices: {usb_hid.devices}")
+    global _keyboard_gadget, _mouse_gadget, _consumer_gadget
+    _keyboard_gadget = Keyboard(usb_hid.devices)
+    _mouse_gadget = Mouse(usb_hid.devices)
+    _consumer_gadget = ConsumerControl(usb_hid.devices)
+
+
 class DeviceIdentifier:
     def __init__(self, device_identifier: str) -> None:
         self._value = device_identifier
@@ -86,9 +101,6 @@ def matches(self, device: InputDevice) -> bool:
 class DeviceRelay:
     def __init__(self, input_device: InputDevice):
         self._input_device = input_device
-        self._keyboard_gadget = Keyboard(usb_hid.devices)
-        self._mouse_gadget = Mouse(usb_hid.devices)
-        self._consumer_gadget = ConsumerControl(usb_hid.devices)
 
     @property
     def input_device(self) -> InputDevice:
@@ -107,45 +119,48 @@ async def async_relay_events_loop(self) -> NoReturn:
     async def _async_relay_event(self, input_event: InputEvent) -> None:
         event = categorize(input_event)
         _logger.debug(f"Received {event} from {self.input_device.name}")
-        method = None
+        func = None
         if isinstance(event, RelEvent):
-            method = self._move_mouse
+            func = _move_mouse
         elif isinstance(event, KeyEvent):
-            method = self._send_key
-        if method:
+            func = _send_key
+        if func:
             loop = asyncio.get_running_loop()
-            await loop.run_in_executor(None, method, event)
-
-    def _send_key(self, event: KeyEvent) -> None:
-        key_id, key_name = evdev_to_usb_hid(event)
-        if key_id is None:
-            return
-        device_out = self._get_output_device(event)
-        try:
-            if event.keystate == KeyEvent.key_down:
-                _logger.debug(f"Pressing {key_name} (0x{key_id:02X}) on {device_out}")
-                device_out.press(key_id)
-            elif event.keystate == KeyEvent.key_up:
-                _logger.debug(f"Releasing {key_name} (0x{key_id:02X}) on {device_out}")
-                device_out.release(key_id)
-        except Exception:
-            _logger.exception(f"Failed sending 0x{key_id:02X} to {device_out}")
-
-    def _get_output_device(self, event: KeyEvent) -> ConsumerControl | Keyboard | Mouse:
-        if is_consumer_key(event):
-            return self._consumer_gadget
-        elif is_mouse_button(event):
-            return self._mouse_gadget
-        return self._keyboard_gadget
-
-    def _move_mouse(self, event: RelEvent) -> None:
-        x, y, mwheel = get_mouse_movement(event)
-        coordinates = f"(x={x}, y={y}, mwheel={mwheel})"
-        try:
-            _logger.debug(f"Moving mouse {self._mouse_gadget} {coordinates}")
-            self._mouse_gadget.move(x, y, mwheel)
-        except Exception:
-            _logger.exception(f"Failed moving mouse {self._mouse_gadget} {coordinates}")
+            await loop.run_in_executor(None, func, event)
+
+
+def _move_mouse(event: RelEvent) -> None:
+    x, y, mwheel = get_mouse_movement(event)
+    coordinates = f"(x={x}, y={y}, mwheel={mwheel})"
+    try:
+        _logger.debug(f"Moving mouse {_mouse_gadget} {coordinates}")
+        _mouse_gadget.move(x, y, mwheel)
+    except Exception:
+        _logger.exception(f"Failed moving mouse {_mouse_gadget} {coordinates}")
+
+
+def _send_key(event: KeyEvent) -> None:
+    key_id, key_name = evdev_to_usb_hid(event)
+    if key_id is None:
+        return
+    device_out = _get_output_device(event)
+    try:
+        if event.keystate == KeyEvent.key_down:
+            _logger.debug(f"Pressing {key_name} (0x{key_id:02X}) on {device_out}")
+            device_out.press(key_id)
+        elif event.keystate == KeyEvent.key_up:
+            _logger.debug(f"Releasing {key_name} (0x{key_id:02X}) on {device_out}")
+            device_out.release(key_id)
+    except Exception:
+        _logger.exception(f"Failed sending 0x{key_id:02X} to {device_out}")
+
+
+def _get_output_device(event: KeyEvent) -> ConsumerControl | Keyboard | Mouse:
+    if is_consumer_key(event):
+        return _consumer_gadget
+    elif is_mouse_button(event):
+        return _mouse_gadget
+    return _keyboard_gadget
 
 
 class RelayController:
@@ -156,12 +171,13 @@ class RelayController:
     def __init__(
         self, device_identifiers: list[str] = None, auto_discover: bool = False
     ) -> None:
-        _enable_usb_devices()
+        init_usb_devices()
         if not device_identifiers:
             device_identifiers = []
         self._device_ids = [DeviceIdentifier(id) for id in device_identifiers]
         self._auto_discover = auto_discover
         self._cancelled = False
+        self._device_relay_paths: list[str] = []
 
     async def async_relay_devices(self) -> NoReturn:
         try:
@@ -187,13 +203,13 @@ async def _async_discover_devices_loop(self) -> AsyncGenerator[InputDevice, None
             for device in list_readable_devices():
                 if self._should_relay(device):
                     yield device
-            await asyncio.sleep(1)
+            await asyncio.sleep(0.1)
 
     def _should_relay(self, device: InputDevice) -> bool:
-        return not self._has_task(device) and self._matches_criteria(device)
+        return not self._has_relay(device) and self._matches_criteria(device)
 
-    def _has_task(self, device: InputDevice) -> bool:
-        return device.path in [task.get_name() for task in asyncio.all_tasks()]
+    def _has_relay(self, device: InputDevice) -> bool:
+        return device.path in self._device_relay_paths
 
     def _matches_criteria(self, device: InputDevice) -> bool:
         return self._auto_discover or self._matches_any_identifier(device)
@@ -207,6 +223,7 @@ def _create_task(self, device: InputDevice, task_group: TaskGroup) -> None:
     async def _async_relay_events(self, device: InputDevice) -> NoReturn:
         try:
             relay = DeviceRelay(device)
+            self._device_relay_paths.append(device.path)
             _logger.info(f"Activated {repr(relay)}")
             await relay.async_relay_events_loop()
         except CancelledError:
@@ -216,19 +233,6 @@ async def _async_relay_events(self, device: InputDevice) -> NoReturn:
             _logger.critical(f"Connection to {device.name} lost [{repr(ex)}]")
         except Exception:
             _logger.exception(f"{device.name} failed!")
-            await asyncio.sleep(2)
-
-
-def list_readable_devices() -> list[InputDevice]:
-    return [InputDevice(path) for path in list_devices()]
-
-
-def _enable_usb_devices():
-    usb_hid.enable(
-        [
-            Device.MOUSE,
-            Device.KEYBOARD,
-            Device.CONSUMER_CONTROL,
-        ]
-    )
-    _logger.debug(f"Available USB devices: {usb_hid.devices}")
+            await asyncio.sleep(1)
+        finally:
+            self._device_relay_paths.remove(device.path)