refactoring

kvmd/apps/kvmd/api/hid.py

@@ -25,13 +25,12 @@ import stat
 import functools
 import struct
 
+from typing import Iterable
 from typing import Callable
 
 from aiohttp.web import Request
 from aiohttp.web import Response
 
-from ....mouse import MouseRange
-
 from ....keyboard.keysym import build_symmap
 from ....keyboard.printer import text_to_web_keys
 
@@ -59,12 +58,7 @@ class HidApi:
     def __init__(
         self,
         hid: BaseHid,
-
         keymap_path: str,
-        ignore_keys: list[str],
-
-        mouse_x_range: tuple[int, int],
-        mouse_y_range: tuple[int, int],
     ) -> None:
 
         self.__hid = hid
@@ -73,11 +67,6 @@ class HidApi:
         self.__default_keymap_name = os.path.basename(keymap_path)
         self.__ensure_symmap(self.__default_keymap_name)
 
-        self.__ignore_keys = ignore_keys
-
-        self.__mouse_x_range = mouse_x_range
-        self.__mouse_y_range = mouse_y_range
-
     # =====
 
     @exposed_http("GET", "/hid")
@@ -134,7 +123,7 @@ class HidApi:
         if limit > 0:
             text = text[:limit]
         symmap = self.__ensure_symmap(req.query.get("keymap", self.__default_keymap_name))
-        self.__hid.send_key_events(text_to_web_keys(text, symmap))
+        self.__hid.send_key_events(text_to_web_keys(text, symmap), no_ignore_keys=True)
         return make_json_response()
 
     def __ensure_symmap(self, keymap_name: str) -> dict[int, dict[int, str]]:
@@ -162,8 +151,7 @@ class HidApi:
             state = valid_bool(data[0])
         except Exception:
             return
-        if key not in self.__ignore_keys:
-            self.__hid.send_key_events([(key, state)])
+        self.__hid.send_key_event(key, state)
 
     @exposed_ws(2)
     async def __ws_bin_mouse_button_handler(self, _: WsSession, data: bytes) -> None:
@@ -182,17 +170,17 @@ class HidApi:
             to_y = valid_hid_mouse_move(to_y)
         except Exception:
             return
-        self.__send_mouse_move_event(to_x, to_y)
+        self.__hid.send_mouse_move_event(to_x, to_y)
 
     @exposed_ws(4)
     async def __ws_bin_mouse_relative_handler(self, _: WsSession, data: bytes) -> None:
-        self.__process_ws_bin_delta_request(data, self.__hid.send_mouse_relative_event)
+        self.__process_ws_bin_delta_request(data, self.__hid.send_mouse_relative_events)
 
     @exposed_ws(5)
     async def __ws_bin_mouse_wheel_handler(self, _: WsSession, data: bytes) -> None:
-        self.__process_ws_bin_delta_request(data, self.__hid.send_mouse_wheel_event)
+        self.__process_ws_bin_delta_request(data, self.__hid.send_mouse_wheel_events)
 
-    def __process_ws_bin_delta_request(self, data: bytes, handler: Callable[[int, int], None]) -> None:
+    def __process_ws_bin_delta_request(self, data: bytes, handler: Callable[[Iterable[tuple[int, int]], bool], None]) -> None:
         try:
             squash = valid_bool(data[0])
             data = data[1:]
@@ -202,7 +190,7 @@ class HidApi:
                 deltas.append((valid_hid_mouse_delta(delta_x), valid_hid_mouse_delta(delta_y)))
         except Exception:
             return
-        self.__send_mouse_delta_event(deltas, squash, handler)
+        handler(deltas, squash)
 
     # =====
 
@@ -213,8 +201,7 @@ class HidApi:
             state = valid_bool(event["state"])
         except Exception:
             return
-        if key not in self.__ignore_keys:
-            self.__hid.send_key_events([(key, state)])
+        self.__hid.send_key_event(key, state)
 
     @exposed_ws("mouse_button")
     async def __ws_mouse_button_handler(self, _: WsSession, event: dict) -> None:
@@ -232,17 +219,17 @@ class HidApi:
             to_y = valid_hid_mouse_move(event["to"]["y"])
         except Exception:
             return
-        self.__send_mouse_move_event(to_x, to_y)
+        self.__hid.send_mouse_move_event(to_x, to_y)
 
     @exposed_ws("mouse_relative")
     async def __ws_mouse_relative_handler(self, _: WsSession, event: dict) -> None:
-        self.__process_ws_delta_event(event, self.__hid.send_mouse_relative_event)
+        self.__process_ws_delta_event(event, self.__hid.send_mouse_relative_events)
 
     @exposed_ws("mouse_wheel")
     async def __ws_mouse_wheel_handler(self, _: WsSession, event: dict) -> None:
-        self.__process_ws_delta_event(event, self.__hid.send_mouse_wheel_event)
+        self.__process_ws_delta_event(event, self.__hid.send_mouse_wheel_events)
 
-    def __process_ws_delta_event(self, event: dict, handler: Callable[[int, int], None]) -> None:
+    def __process_ws_delta_event(self, event: dict, handler: Callable[[Iterable[tuple[int, int]], bool], None]) -> None:
         try:
             raw_delta = event["delta"]
             deltas = [
@@ -252,19 +239,18 @@ class HidApi:
             squash = valid_bool(event.get("squash", False))
         except Exception:
             return
-        self.__send_mouse_delta_event(deltas, squash, handler)
+        handler(deltas, squash)
 
     # =====
 
     @exposed_http("POST", "/hid/events/send_key")
     async def __events_send_key_handler(self, req: Request) -> Response:
         key = valid_hid_key(req.query.get("key"))
-        if key not in self.__ignore_keys:
-            if "state" in req.query:
-                state = valid_bool(req.query["state"])
-                self.__hid.send_key_events([(key, state)])
-            else:
-                self.__hid.send_key_events([(key, True), (key, False)])
+        if "state" in req.query:
+            state = valid_bool(req.query["state"])
+            self.__hid.send_key_event(key, state)
+        else:
+            self.__hid.send_key_events([(key, True), (key, False)])
         return make_json_response()
 
     @exposed_http("POST", "/hid/events/send_mouse_button")
@@ -282,7 +268,7 @@ class HidApi:
     async def __events_send_mouse_move_handler(self, req: Request) -> Response:
         to_x = valid_hid_mouse_move(req.query.get("to_x"))
         to_y = valid_hid_mouse_move(req.query.get("to_y"))
-        self.__send_mouse_move_event(to_x, to_y)
+        self.__hid.send_mouse_move_event(to_x, to_y)
         return make_json_response()
 
     @exposed_http("POST", "/hid/events/send_mouse_relative")
@@ -298,33 +284,3 @@ class HidApi:
         delta_y = valid_hid_mouse_delta(req.query.get("delta_y"))
         handler(delta_x, delta_y)
         return make_json_response()
-
-    # =====
-
-    def __send_mouse_move_event(self, to_x: int, to_y: int) -> None:
-        if self.__mouse_x_range != MouseRange.RANGE:
-            to_x = MouseRange.remap(to_x, *self.__mouse_x_range)
-        if self.__mouse_y_range != MouseRange.RANGE:
-            to_y = MouseRange.remap(to_y, *self.__mouse_y_range)
-        self.__hid.send_mouse_move_event(to_x, to_y)
-
-    def __send_mouse_delta_event(
-        self,
-        deltas: list[tuple[int, int]],
-        squash: bool,
-        handler: Callable[[int, int], None],
-    ) -> None:
-
-        if squash:
-            prev = (0, 0)
-            for cur in deltas:
-                if abs(prev[0] + cur[0]) > 127 or abs(prev[1] + cur[1]) > 127:
-                    handler(*prev)
-                    prev = cur
-                else:
-                    prev = (prev[0] + cur[0], prev[1] + cur[1])
-            if prev[0] or prev[1]:
-                handler(*prev)
-        else:
-            for xy in deltas:
-                handler(*xy)