fix reader-service and use md5 hashing

inputremapper/configs/input_config.py

@@ -48,7 +48,7 @@ class InputConfig(BaseModel):
 
     type: int
     code: int
-    origin: Optional[int] = None
+    origin: Optional[str] = None
     analog_threshold: Optional[int] = None
 
     @property

inputremapper/gui/reader_client.py

@@ -151,7 +151,7 @@ def _read(self):
                 # update the generator
                 try:
                     if self._recording_generator is not None:
-                        self._recording_generator.send(InputEvent(*message_body))
+                        self._recording_generator.send(InputEvent(**message_body))
                     else:
                         # the ReaderService should only send events while the gui
                         # is recording, so this is unexpected.
@@ -198,15 +198,20 @@ def stop_recorder(self) -> None:
 
     @staticmethod
     def _input_event_to_config(event: InputEvent):
-        return {"type": event.type, "code": event.code, "analog_threshold": event.value}
+        return {
+            "type": event.type,
+            "code": event.code,
+            "analog_threshold": event.value,
+            "origin": event.origin,
+        }
 
     def _recorder(self) -> RecordingGenerator:
         """Generator which receives InputEvents.
 
         It accumulates them into EventCombinations and sends those on the
         message_broker. It will stop once all keys or inputs are released.
         """
-        active: Set[Tuple[int, int]] = set()
+        active: Set = set()
         accumulator: List[InputEvent] = []
         while True:
             event: InputEvent = yield
@@ -215,7 +220,7 @@ def _recorder(self) -> RecordingGenerator:
 
             if event.value == 0:
                 try:
-                    active.remove((event.type, event.code))
+                    active.remove(event.input_match_hash)
                 except KeyError:
                     # we haven't seen this before probably a key got released which
                     # was pressed before we started recording. ignore it.
@@ -226,12 +231,12 @@ def _recorder(self) -> RecordingGenerator:
                     return
                 continue
 
-            active.add(event.type_and_code)
-            accu_type_code = [e.type_and_code for e in accumulator]
-            if event.type_and_code in accu_type_code and event not in accumulator:
+            active.add(event.input_match_hash)
+            accu_input_hashes = [e.input_match_hash for e in accumulator]
+            if event.input_match_hash in accu_input_hashes and event not in accumulator:
                 # the value has changed but the event is already in the accumulator
                 # update the event
-                i = accu_type_code.index(event.type_and_code)
+                i = accu_input_hashes.index(event.input_match_hash)
                 accumulator[i] = event
                 self.message_broker.publish(
                     CombinationRecorded(

inputremapper/gui/reader_service.py

@@ -50,6 +50,7 @@
 
 import evdev
 from evdev.ecodes import EV_KEY, EV_ABS, EV_REL, REL_HWHEEL, REL_WHEEL
+from inputremapper.utils import get_device_hash
 
 from inputremapper.configs.input_config import InputCombination, InputConfig
 from inputremapper.configs.mapping import UIMapping
@@ -267,98 +268,81 @@ def _create_event_pipeline(self, sources: List[evdev.InputDevice]) -> ContextDum
         context = ContextDummy()
         # create a context for each source
         for device in sources:
+            device_hash = get_device_hash(device)
             capabilities = device.capabilities(absinfo=False)
 
             for ev_code in capabilities.get(EV_KEY) or ():
-                context.notify_callbacks[(EV_KEY, ev_code)].append(
+                input_config = InputConfig(
+                    type=EV_KEY, code=ev_code, origin=device_hash
+                )
+                context.notify_callbacks[input_config.input_match_hash].append(
                     ForwardToUIHandler(self._results_pipe).notify
                 )
 
             for ev_code in capabilities.get(EV_ABS) or ():
                 # positive direction
+                input_config = InputConfig(
+                    type=EV_ABS, code=ev_code, analog_threshold=30, origin=device_hash
+                )
                 mapping = UIMapping(
-                    input_combination=InputCombination(
-                        InputConfig(type=EV_ABS, code=ev_code, analog_threshold=30)
-                    ),
+                    input_combination=InputCombination(input_config),
                     target_uinput="keyboard",
                 )
                 handler: MappingHandler = AbsToBtnHandler(
-                    InputCombination(
-                        InputConfig(type=EV_ABS, code=ev_code, analog_threshold=30)
-                    ),
-                    mapping,
+                    InputCombination(input_config), mapping
                 )
                 handler.set_sub_handler(ForwardToUIHandler(self._results_pipe))
-                context.notify_callbacks[(EV_ABS, ev_code)].append(handler.notify)
+                context.notify_callbacks[input_config.input_match_hash].append(
+                    handler.notify
+                )
 
                 # negative direction
+                input_config = input_config.modify(analog_threshold=-30)
                 mapping = UIMapping(
-                    input_combination=InputCombination(
-                        InputConfig(type=EV_ABS, code=ev_code, analog_threshold=-30)
-                    ),
+                    input_combination=InputCombination(input_config),
                     target_uinput="keyboard",
                 )
-                handler = AbsToBtnHandler(
-                    InputCombination(
-                        InputConfig(type=EV_ABS, code=ev_code, analog_threshold=-30)
-                    ),
-                    mapping,
-                )
+                handler = AbsToBtnHandler(InputCombination(input_config), mapping)
                 handler.set_sub_handler(ForwardToUIHandler(self._results_pipe))
-                context.notify_callbacks[(EV_ABS, ev_code)].append(handler.notify)
+                context.notify_callbacks[input_config.input_match_hash].append(
+                    handler.notify
+                )
 
             for ev_code in capabilities.get(EV_REL) or ():
                 # positive direction
+                input_config = InputConfig(
+                    type=EV_REL,
+                    code=ev_code,
+                    analog_threshold=self.rel_xy_speed[ev_code],
+                    origin=device_hash,
+                )
                 mapping = UIMapping(
-                    input_combination=InputCombination(
-                        InputConfig(
-                            type=EV_REL,
-                            code=ev_code,
-                            analog_threshold=self.rel_xy_speed[ev_code],
-                        )
-                    ),
+                    input_combination=InputCombination(input_config),
                     target_uinput="keyboard",
                     release_timeout=0.3,
                     force_release_timeout=True,
                 )
-                handler = RelToBtnHandler(
-                    InputCombination(
-                        InputConfig(
-                            type=EV_REL,
-                            code=ev_code,
-                            analog_threshold=self.rel_xy_speed[ev_code],
-                        )
-                    ),
-                    mapping,
-                )
+                handler = RelToBtnHandler(InputCombination(input_config), mapping)
                 handler.set_sub_handler(ForwardToUIHandler(self._results_pipe))
-                context.notify_callbacks[(EV_REL, ev_code)].append(handler.notify)
+                context.notify_callbacks[input_config.input_match_hash].append(
+                    handler.notify
+                )
 
                 # negative direction
+                input_config = input_config.modify(
+                    analog_threshold=-self.rel_xy_speed[ev_code]
+                )
                 mapping = UIMapping(
-                    input_combination=InputCombination(
-                        InputConfig(
-                            type=EV_REL,
-                            code=ev_code,
-                            analog_threshold=-self.rel_xy_speed[ev_code],
-                        )
-                    ),
+                    input_combination=InputCombination(input_config),
                     target_uinput="keyboard",
                     release_timeout=0.3,
                     force_release_timeout=True,
                 )
-                handler = RelToBtnHandler(
-                    InputCombination(
-                        InputConfig(
-                            type=EV_REL,
-                            code=ev_code,
-                            analog_threshold=-self.rel_xy_speed[ev_code],
-                        )
-                    ),
-                    mapping,
-                )
+                handler = RelToBtnHandler(InputCombination(input_config), mapping)
                 handler.set_sub_handler(ForwardToUIHandler(self._results_pipe))
-                context.notify_callbacks[(EV_REL, ev_code)].append(handler.notify)
+                context.notify_callbacks[input_config.input_match_hash].append(
+                    handler.notify
+                )
 
         return context
 
@@ -402,13 +386,14 @@ def notify(
             self.pipe.send(
                 {
                     "type": MSG_EVENT,
-                    "message": (
-                        event.sec,
-                        event.usec,
-                        event.type,
-                        event.code,
-                        event.value,
-                    ),
+                    "message": {
+                        "sec": event.sec,
+                        "usec": event.usec,
+                        "type": event.type,
+                        "code": event.code,
+                        "value": event.value,
+                        "origin": event.origin,
+                    },
                 }
             )
         return True

inputremapper/injection/injector.py

@@ -193,7 +193,8 @@ def stop_injecting(self) -> None:
     def _find_input_device(
         devices: List[evdev.InputDevice], input_config: InputConfig
     ) -> Optional[evdev.InputDevice]:
-        devices_by_hash = {get_device_hash: device for device in devices}
+        devices_by_hash = {get_device_hash(device): device for device in devices}
+        logger.debug(f"possible devices: {devices_by_hash}")
 
         def has_type_and_code(device, type, code) -> bool:
             return code in device.capabilities(absinfo=False).get(type, [])

inputremapper/input_event.py

@@ -53,7 +53,7 @@ class InputEvent:
     code: int
     value: int
     actions: Tuple[EventActions, ...] = ()
-    origin: Optional[int] = None
+    origin: Optional[str] = None
 
     def __eq__(self, other: InputEvent | evdev.InputEvent | Tuple[int, int, int]):
         # useful in tests

inputremapper/utils.py

@@ -21,7 +21,8 @@
 """Utility functions."""
 
 import sys
-from typing import Optional, Hashable
+from hashlib import md5
+from typing import Optional
 
 import evdev
 
@@ -30,8 +31,13 @@ def is_service() -> bool:
     return sys.argv[0].endswith("input-remapper-service")
 
 
-def get_device_hash(device: evdev.InputDevice) -> int:
-    return hash(str(device.capabilities(absinfo=False)) + device.name)
+def get_device_hash(device: evdev.InputDevice) -> str:
+    """get a unique hash for the given device"""
+    # the builtin hash() function can not be used because it is randomly
+    # seeded at python startup.
+    # a non-cryptographic hash would be faster but there is none in the standard lib
+    s = str(device.capabilities(absinfo=False)) + device.name
+    return md5(s.encode()).hexdigest()
 
 
 def get_evdev_constant_name(type_: int, code: int, *_) -> Optional[str]: