GithubFollow/One-KVM
1
0
Fork 0
mirror of https://github.com/mofeng-git/One-KVM.git synced 2025-12-12 01:00:29 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

pikvm/pikvm#57: Mouse jiggler

Browse Source
This commit is contained in:
Maxim Devaev 2023-10-23 08:10:19 +03:00
parent 73f96fa0c7
commit 4038754c37
9 changed files with 156 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
kvmd/apps/kvmd/api/hid.py
View File

@ -91,6 +91,7 @@ class HidApi:
for (key, validator) in [
("keyboard_output", valid_hid_keyboard_output),
("mouse_output", valid_hid_mouse_output),
("jiggler", valid_bool),
]
if request.query.get(key) is not None
}

44
kvmd/plugins/hid/__init__.py
View File

@ -20,6 +20,9 @@
# ========================================================================== #
import asyncio
import time
from typing import Iterable
from typing import AsyncGenerator
@ -29,6 +32,11 @@ from .. import get_plugin_class
# =====
class BaseHid(BasePlugin):
def __init__(self) -> None:
self.__jiggler_enabled = False
self.__jiggler_absolute = True
self.__activity_ts = 0
def sysprep(self) -> None:
raise NotImplementedError
@ -64,9 +72,14 @@ class BaseHid(BasePlugin):
def send_mouse_wheel_event(self, delta_x: int, delta_y: int) -> None:
raise NotImplementedError
def set_params(self, keyboard_output: (str | None)=None, mouse_output: (str | None)=None) -> None:
_ = keyboard_output
_ = mouse_output
def set_params(
self,
keyboard_output: (str | None)=None,
mouse_output: (str | None)=None,
jiggler: (bool | None)=None,
) -> None:
raise NotImplementedError
def set_connected(self, connected: bool) -> None:
_ = connected
@ -74,6 +87,31 @@ class BaseHid(BasePlugin):
def clear_events(self) -> None:
raise NotImplementedError
# =====
async def systask(self) -> None:
factor = 1
while True:
if self.__jiggler_enabled and (self.__activity_ts + 60 < int(time.monotonic())):
if self.__jiggler_absolute:
self.send_mouse_move_event(100 * factor, 100 * factor)
else:
self.send_mouse_relative_event(10 * factor, 10 * factor)
factor *= -1
await asyncio.sleep(1)
def _bump_activity(self) -> None:
self.__activity_ts = int(time.monotonic())
def _set_jiggler_absolute(self, absolute: bool) -> None:
self.__jiggler_absolute = absolute
def _set_jiggler_enabled(self, enabled: bool) -> None:
self.__jiggler_enabled = enabled
def _get_jiggler_state(self) -> dict:
return {"enabled": self.__jiggler_enabled}
# =====
def get_hid_class(name: str) -> type[BaseHid]:

20
kvmd/plugins/hid/_mcu/__init__.py
View File

@ -117,6 +117,7 @@ class BaseMcuHid(BaseHid, multiprocessing.Process): # pylint: disable=too-many-
**gpio_kwargs: Any,
) -> None:
BaseHid.__init__(self)
multiprocessing.Process.__init__(self, daemon=True)
self.__read_retries = read_retries
@ -177,6 +178,7 @@ class BaseMcuHid(BaseHid, multiprocessing.Process): # pylint: disable=too-many-
active_mouse = get_active_mouse(outputs1)
if online and active_mouse in ["usb_rel", "ps2"]:
absolute = False
self._set_jiggler_absolute(absolute)
keyboard_outputs: dict = {"available": [], "active": ""}
mouse_outputs: dict = {"available": [], "active": ""}
@ -224,6 +226,7 @@ class BaseMcuHid(BaseHid, multiprocessing.Process): # pylint: disable=too-many-
"absolute": absolute,
"outputs": mouse_outputs,
},
"jiggler": self._get_jiggler_state(),
}
async def poll_state(self) -> AsyncGenerator[dict, None]:
@ -251,20 +254,31 @@ class BaseMcuHid(BaseHid, multiprocessing.Process): # pylint: disable=too-many-
def send_key_events(self, keys: Iterable[tuple[str, bool]]) -> None:
for (key, state) in keys:
self.__queue_event(KeyEvent(key, state))
self._bump_activity()
def send_mouse_button_event(self, button: str, state: bool) -> None:
self.__queue_event(MouseButtonEvent(button, state))
self._bump_activity()
def send_mouse_move_event(self, to_x: int, to_y: int) -> None:
self.__queue_event(MouseMoveEvent(to_x, to_y))
self._bump_activity()
def send_mouse_relative_event(self, delta_x: int, delta_y: int) -> None:
self.__queue_event(MouseRelativeEvent(delta_x, delta_y))
self._bump_activity()
def send_mouse_wheel_event(self, delta_x: int, delta_y: int) -> None:
self.__queue_event(MouseWheelEvent(delta_x, delta_y))
self._bump_activity()
def set_params(
self,
keyboard_output: (str | None)=None,
mouse_output: (str | None)=None,
jiggler: (bool | None)=None,
) -> None:
def set_params(self, keyboard_output: (str | None)=None, mouse_output: (str | None)=None) -> None:
events: list[BaseEvent] = []
if keyboard_output is not None:
events.append(SetKeyboardOutputEvent(keyboard_output))
@ -272,12 +286,16 @@ class BaseMcuHid(BaseHid, multiprocessing.Process): # pylint: disable=too-many-
events.append(SetMouseOutputEvent(mouse_output))
for (index, event) in enumerate(events, 1):
self.__queue_event(event, clear=(index == len(events)))
if jiggler is not None:
self._set_jiggler_enabled(jiggler)
self.__notifier.notify()
def set_connected(self, connected: bool) -> None:
self.__queue_event(SetConnectedEvent(connected), clear=True)
def clear_events(self) -> None:
self.__queue_event(ClearEvent(), clear=True)
self._bump_activity()
def __queue_event(self, event: BaseEvent, clear: bool=False) -> None:
if not self.__stop_event.is_set():

24
kvmd/plugins/hid/bt/__init__.py
View File

@ -59,7 +59,7 @@ class Plugin(BaseHid): # pylint: disable=too-many-instance-attributes
# https://gist.github.com/whitelynx/9f9bd4cb266b3924c64dfdff14bce2e8
# https://archlinuxarm.org/forum/viewtopic.php?f=67&t=14244
def __init__( # pylint: disable=too-many-arguments,too-many-locals,super-init-not-called
def __init__( # pylint: disable=too-many-arguments,too-many-locals
self,
manufacturer: str,
product: str,
@ -78,6 +78,9 @@ class Plugin(BaseHid): # pylint: disable=too-many-instance-attributes
select_timeout: float,
) -> None:
super().__init__()
self._set_jiggler_absolute(False)
self.__proc: (multiprocessing.Process | None) = None
self.__stop_event = multiprocessing.Event()
@ -146,6 +149,7 @@ class Plugin(BaseHid): # pylint: disable=too-many-instance-attributes
"absolute": False,
"outputs": outputs,
},
"jiggler": self._get_jiggler_state(),
}
async def poll_state(self) -> AsyncGenerator[dict, None]:
@ -175,18 +179,36 @@ class Plugin(BaseHid): # pylint: disable=too-many-instance-attributes
def send_key_events(self, keys: Iterable[tuple[str, bool]]) -> None:
for (key, state) in keys:
self.__server.queue_event(make_keyboard_event(key, state))
self._bump_activity()
def send_mouse_button_event(self, button: str, state: bool) -> None:
self.__server.queue_event(MouseButtonEvent(button, state))
self._bump_activity()
def send_mouse_relative_event(self, delta_x: int, delta_y: int) -> None:
self.__server.queue_event(MouseRelativeEvent(delta_x, delta_y))
self._bump_activity()
def send_mouse_wheel_event(self, delta_x: int, delta_y: int) -> None:
self.__server.queue_event(MouseWheelEvent(delta_x, delta_y))
self._bump_activity()
def clear_events(self) -> None:
self.__server.clear_events()
self._bump_activity()
def set_params(
self,
keyboard_output: (str | None)=None,
mouse_output: (str | None)=None,
jiggler: (bool | None)=None,
) -> None:
_ = keyboard_output
_ = mouse_output
if jiggler is not None:
self._set_jiggler_enabled(jiggler)
self.__notifier.notify()
# =====

23
kvmd/plugins/hid/ch9329/__init__.py
View File

@ -58,6 +58,7 @@ class Plugin(BaseHid, multiprocessing.Process): # pylint: disable=too-many-inst
read_timeout: float,
) -> None:
BaseHid.__init__(self)
multiprocessing.Process.__init__(self, daemon=True)
self.__device_path = device_path
@ -112,6 +113,7 @@ class Plugin(BaseHid, multiprocessing.Process): # pylint: disable=too-many-inst
"active": ("usb" if absolute else "usb_rel"),
},
},
"jiggler": self._get_jiggler_state(),
}
async def poll_state(self) -> AsyncGenerator[dict, None]:
@ -139,23 +141,40 @@ class Plugin(BaseHid, multiprocessing.Process): # pylint: disable=too-many-inst
def send_key_events(self, keys: Iterable[tuple[str, bool]]) -> None:
for (key, state) in keys:
self.__queue_cmd(self.__keyboard.process_key(key, state))
self._bump_activity()
def send_mouse_button_event(self, button: str, state: bool) -> None:
self.__queue_cmd(self.__mouse.process_button(button, state))
self._bump_activity()
def send_mouse_move_event(self, to_x: int, to_y: int) -> None:
self.__queue_cmd(self.__mouse.process_move(to_x, to_y))
self._bump_activity()
def send_mouse_wheel_event(self, delta_x: int, delta_y: int) -> None:
self.__queue_cmd(self.__mouse.process_wheel(delta_x, delta_y))
self._bump_activity()
def send_mouse_relative_event(self, delta_x: int, delta_y: int) -> None:
self.__queue_cmd(self.__mouse.process_relative(delta_x, delta_y))
self._bump_activity()
def set_params(self, keyboard_output: (str | None)=None, mouse_output: (str | None)=None) -> None:
def set_params(
self,
keyboard_output: (str | None)=None,
mouse_output: (str | None)=None,
jiggler: (bool | None)=None,
) -> None:
_ = keyboard_output
if mouse_output is not None:
get_logger(0).info("HID : mouse output = %s", mouse_output)
self.__mouse.set_absolute(mouse_output == "usb")
absolute = (mouse_output == "usb")
self.__mouse.set_absolute(absolute)
self._set_jiggler_absolute(absolute)
self.__notifier.notify()
if jiggler is not None:
self._set_jiggler_enabled(jiggler)
self.__notifier.notify()
def set_connected(self, connected: bool) -> None:

25
kvmd/plugins/hid/otg/__init__.py
View File

@ -44,7 +44,7 @@ from .mouse import MouseProcess
# =====
class Plugin(BaseHid): # pylint: disable=too-many-instance-attributes
def __init__( # pylint: disable=super-init-not-called
def __init__(
self,
keyboard: dict[str, Any],
mouse: dict[str, Any],
@ -53,6 +53,8 @@ class Plugin(BaseHid): # pylint: disable=too-many-instance-attributes
udc: str, # XXX: Not from options, see /kvmd/apps/kvmd/__init__.py for details
) -> None:
super().__init__()
self.__udc = udc
self.__notifier = aiomulti.AioProcessNotifier()
@ -80,6 +82,8 @@ class Plugin(BaseHid): # pylint: disable=too-many-instance-attributes
# но так было проще реализовать переключение режимов
self.__mouses["usb_win98"] = self.__mouses["usb"]
self._set_jiggler_absolute(self.__mouse_current.is_absolute())
@classmethod
def get_plugin_options(cls) -> dict:
return {
@ -141,6 +145,7 @@ class Plugin(BaseHid): # pylint: disable=too-many-instance-attributes
},
**mouse_state,
},
"jiggler": self._get_jiggler_state(),
}
async def poll_state(self) -> AsyncGenerator[dict, None]:
@ -172,25 +177,40 @@ class Plugin(BaseHid): # pylint: disable=too-many-instance-attributes
def send_key_events(self, keys: Iterable[tuple[str, bool]]) -> None:
self.__keyboard_proc.send_key_events(keys)
self._bump_activity()
def send_mouse_button_event(self, button: str, state: bool) -> None:
self.__mouse_current.send_button_event(button, state)
self._bump_activity()
def send_mouse_move_event(self, to_x: int, to_y: int) -> None:
self.__mouse_current.send_move_event(to_x, to_y)
self._bump_activity()
def send_mouse_relative_event(self, delta_x: int, delta_y: int) -> None:
self.__mouse_current.send_relative_event(delta_x, delta_y)
self._bump_activity()
def send_mouse_wheel_event(self, delta_x: int, delta_y: int) -> None:
self.__mouse_current.send_wheel_event(delta_x, delta_y)
self._bump_activity()
def set_params(
self,
keyboard_output: (str | None)=None,
mouse_output: (str | None)=None,
jiggler: (bool | None)=None,
) -> None:
def set_params(self, keyboard_output: (str | None)=None, mouse_output: (str | None)=None) -> None:
_ = keyboard_output
if mouse_output in self.__mouses and mouse_output != self.__get_current_mouse_mode():
self.__mouse_current.send_clear_event()
self.__mouse_current = self.__mouses[mouse_output]
self.__mouse_current.set_win98_fix(mouse_output == "usb_win98")
self._set_jiggler_absolute(self.__mouse_current.is_absolute())
self.__notifier.notify()
if jiggler is not None:
self._set_jiggler_enabled(jiggler)
self.__notifier.notify()
def clear_events(self) -> None:
@ -198,6 +218,7 @@ class Plugin(BaseHid): # pylint: disable=too-many-instance-attributes
self.__mouse_proc.send_clear_event()
if self.__mouse_alt_proc:
self.__mouse_alt_proc.send_clear_event()
self._bump_activity()
# =====

9
web/kvm/index.html
View File

@ -338,6 +338,15 @@
</div>
</td>
</tr>
<tr>
<td>Mouse jiggler:</td>
<td align="right">
<div class="switch-box">
<input disabled type="checkbox" id="hid-jiggler-switch">
<label for="hid-jiggler-switch"><span class="switch-inner"></span><span class="switch"></span></label>
</div>
</td>
</tr>
<tr>
<td>Mute HID input events:</td>
<td align="right">

2
web/kvm/navbar-system.pug
View File

@ -99,6 +99,8 @@ li(id="system-dropdown" class="right")
table(class="kv")
tr(id="hid-connect" class="feature-disabled")
+menu_switch_notable("hid-connect-switch", "Connect HID to Server", true, true)
tr
+menu_switch_notable("hid-jiggler-switch", "Mouse jiggler", false, false)
tr
+menu_switch_notable("hid-mute-switch", "Mute HID input events", true, false)
tr(id="v3-usb-breaker" class="feature-disabled")

17
web/share/js/kvm/hid.js
View File

@ -111,6 +111,8 @@ export function Hid(__getGeometry, __recorder) {
}
tools.storage.bindSimpleSwitch($("hid-sysrq-ask-switch"), "hid.sysrq.ask", true);
tools.el.setOnClick($("hid-jiggler-switch"), __clickJigglerSwitch);
};
/************************************************************************/
@ -119,6 +121,7 @@ export function Hid(__getGeometry, __recorder) {
tools.el.setEnabled($("hid-pak-text"), ws);
tools.el.setEnabled($("hid-pak-button"), ws);
tools.el.setEnabled($("hid-reset-button"), ws);
tools.el.setEnabled($("hid-jiggler-switch"), ws);
if (!ws) {
self.setState(null);
}
@ -129,6 +132,9 @@ export function Hid(__getGeometry, __recorder) {
self.setState = function(state) {
let has_relative_squash = false;
if (state) {
$("hid-jiggler-switch").checked = !!state.jiggler.enabled;
}
if (state && state.online) {
let keyboard_outputs = state.keyboard.outputs.available;
let mouse_outputs = state.mouse.outputs.available;
@ -290,6 +296,17 @@ export function Hid(__getGeometry, __recorder) {
});
};
var __clickJigglerSwitch = function() {
let enabled = $("hid-jiggler-switch").checked;
let http = tools.makeRequest("POST", `/api/hid/set_params?jiggler=${enabled}`, function() {
if (http.readyState === 4) {
if (http.status !== 200) {
wm.error(`Can't ${enabled ? "enabled" : "disable"} mouse juggler:<br>`, http.responseText);
}
}
});
};
var __clickConnectSwitch = function() {
let connected = $("hid-connect-switch").checked;
let http = tools.makeRequest("POST", `/api/hid/set_connected?connected=${connected}`, function() {