修复 v0.5 审查问题: platform 改名, 协议健壮性, CJK 匹配, VBS 引号, interception API

Browse Source
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
yws
2026-10-02 01:39:06 +00:00
co-authored by Claude Opus 5.5
parent 176570e7cd
commit 809a7fb017
12 changed files with 667 additions and 360 deletions
+32
View File
@@ -0,0 +1,32 @@
# -*- coding: utf-8 -*-
"""后端共用小工具。"""
import ctypes
KEY_ALIASES = {'return': 'enter', 'escape': 'esc', 'del': 'delete', 'ins': 'insert',
'pgup': 'pageup', 'pgdn': 'pagedown', 'control': 'ctrl', 'win': 'lwin',
'arrowup': 'up', 'arrowdown': 'down', 'arrowleft': 'left', 'arrowright': 'right'}
def parse_combo(key):
"""'Alt+F4' -> ['alt', 'f4']; 单个 '+' 视为加号键。"""
k = str(key).strip().lower()
if k == '+' or '+' not in k:
parts = [k]
else:
parts = [p.strip() for p in k.split('+')]
if any(not p for p in parts):
raise ValueError('bad key combo %r' % key)
return [KEY_ALIASES.get(p, p) for p in parts]
def win_dpi_aware(user32):
"""声明 per-monitor DPI 感知, 让 SetCursorPos/GetSystemMetrics 用物理像素, 和截图一致。"""
try:
ctypes.windll.shcore.SetProcessDpiAwareness(2)
return
except Exception:
pass
try:
user32.SetProcessDPIAware()
except Exception:
pass
+127 -83
View File
@@ -3,11 +3,15 @@
输入在驱动层转为真实 HID 事件(对应用透明,非 SendInput 虚拟输入)。 输入在驱动层转为真实 HID 事件(对应用透明,非 SendInput 虚拟输入)。
需要: install-interception.exe /install 后重启系统,且本 dll 与驱动共存。 需要: install-interception.exe /install 后重启系统,且本 dll 与驱动共存。
API 以 oblitum/Interception interception.h 为准:
设备号 1..10 = 键盘, 11..20 = 鼠标; 没有 open_device 之类的函数。
interception_send(ctx, device, stroke*, nstroke) 第 4 个参数是 stroke 个数, 不是字节数。
""" """
import ctypes import ctypes
import time import time
from ctypes import wintypes from ._util import parse_combo, win_dpi_aware
# ---- Interception 常量 ---- # ---- Interception 常量 ----
MOUSE_LEFTBUTTON_DOWN = 0x001 MOUSE_LEFTBUTTON_DOWN = 0x001
@@ -25,9 +29,12 @@ KEY_DOWN = 0x00
KEY_UP = 0x01 KEY_UP = 0x01
KEY_E0 = 0x02 KEY_E0 = 0x02
MAX_KEYBOARD = 10
MAX_MOUSE = 10
KEYBOARD_DEVS = range(1, MAX_KEYBOARD + 1)
MOUSE_DEVS = range(MAX_KEYBOARD + 1, MAX_KEYBOARD + MAX_MOUSE + 1)
# ---- Set 1 扫描码 ---- # ---- Set 1 扫描码 ----
SCAN_ALPHA = {chr(c): 0x1E + i for i, c in enumerate(range(ord('A'), ord('Z') + 1))}
# 上面的映射只在 A-P 连续,Q-Z 不连续,改为显式表
SCAN = { SCAN = {
'a': 0x1E, 'b': 0x30, 'c': 0x2E, 'd': 0x20, 'e': 0x12, 'f': 0x21, 'a': 0x1E, 'b': 0x30, 'c': 0x2E, 'd': 0x20, 'e': 0x12, 'f': 0x21,
'g': 0x22, 'h': 0x23, 'i': 0x17, 'j': 0x24, 'k': 0x25, 'l': 0x26, 'g': 0x22, 'h': 0x23, 'i': 0x17, 'j': 0x24, 'k': 0x25, 'l': 0x26,
@@ -36,37 +43,59 @@ SCAN = {
'y': 0x15, 'z': 0x2C, 'y': 0x15, 'z': 0x2C,
'1': 0x02, '2': 0x03, '3': 0x04, '4': 0x05, '5': 0x06, '1': 0x02, '2': 0x03, '3': 0x04, '4': 0x05, '5': 0x06,
'6': 0x07, '7': 0x08, '8': 0x09, '9': 0x0A, '0': 0x0B, '6': 0x07, '7': 0x08, '8': 0x09, '9': 0x0A, '0': 0x0B,
'enter': 0x1C, 'return': 0x1C, 'esc': 0x01, 'space': 0x39, 'tab': 0x0F, 'enter': 0x1C, 'esc': 0x01, 'space': 0x39, 'tab': 0x0F, 'backspace': 0x0E,
'ctrl': 0x1D, 'alt': 0x38, 'lshift': 0x2A, 'rshift': 0x36, 'shift': 0x2A, 'ctrl': 0x1D, 'alt': 0x38, 'lshift': 0x2A, 'rshift': 0x36, 'shift': 0x2A,
'f1': 0x3B, 'f2': 0x3C, 'f3': 0x3D, 'f4': 0x3E, 'f5': 0x3F, 'f6': 0x40, 'f1': 0x3B, 'f2': 0x3C, 'f3': 0x3D, 'f4': 0x3E, 'f5': 0x3F, 'f6': 0x40,
'f7': 0x41, 'f8': 0x42, 'f9': 0x43, 'f10': 0x44, 'f11': 0x57, 'f12': 0x58, 'f7': 0x41, 'f8': 0x42, 'f9': 0x43, 'f10': 0x44, 'f11': 0x57, 'f12': 0x58,
',': 0x33, '.': 0x34, '/': 0x35, ';': 0x27, "'": 0x28, '[': 0x1A, ',': 0x33, '.': 0x34, '/': 0x35, ';': 0x27, "'": 0x28, '[': 0x1A,
']': 0x1B, '-': 0x0C, '=': 0x0D, '`': 0x29, '\\': 0x2B, ']': 0x1B, '-': 0x0C, '=': 0x0D, '`': 0x29, '\\': 0x2B,
} }
UPPER_SCAN = { # 大写所需符号的扫描码(按住 Shift 时) # 扩展键: 扫描码同小键盘, 需带 E0 前缀
SCAN_E0 = {
'up': 0x48, 'down': 0x50, 'left': 0x4B, 'right': 0x4D,
'home': 0x47, 'end': 0x4F, 'pageup': 0x49, 'pagedown': 0x51,
'insert': 0x52, 'delete': 0x53, 'rctrl': 0x1D, 'ralt': 0x38, 'lwin': 0x5B,
}
UPPER_SCAN = { # 需按住 Shift 的符号
'!': 0x02, '@': 0x03, '#': 0x04, '$': 0x05, '%': 0x06, '^': 0x07, '!': 0x02, '@': 0x03, '#': 0x04, '$': 0x05, '%': 0x06, '^': 0x07,
'&': 0x08, '*': 0x09, '(': 0x0A, ')': 0x0B, '_': 0x0C, '+': 0x0D, '&': 0x08, '*': 0x09, '(': 0x0A, ')': 0x0B, '_': 0x0C, '+': 0x0D,
'{': 0x1A, '}': 0x1B, ':': 0x27, '"': 0x28, '<': 0x33, '>': 0x34, '{': 0x1A, '}': 0x1B, ':': 0x27, '"': 0x28, '<': 0x33, '>': 0x34,
'?': 0x35, '~': 0x29, '|': 0x2B, '?': 0x35, '~': 0x29, '|': 0x2B,
} }
MAX_DEVICES = 64 # 键盘下游设备数量通常 <= 16,鼠标 <= 16;放宽到 64 覆盖异常
class MouseStroke(ctypes.Structure): class MouseStroke(ctypes.Structure):
# interception.h: unsigned short state, flags; short rolling; int x, y; unsigned int information
_fields_ = [("state", ctypes.c_ushort), ("flags", ctypes.c_ushort), _fields_ = [("state", ctypes.c_ushort), ("flags", ctypes.c_ushort),
("rolling", ctypes.c_short), ("x", ctypes.c_ulong), ("rolling", ctypes.c_short), ("x", ctypes.c_int),
("y", ctypes.c_ulong), ("information", ctypes.c_ulong)] ("y", ctypes.c_int), ("information", ctypes.c_uint)]
class KeyStroke(ctypes.Structure): class KeyStroke(ctypes.Structure):
_fields_ = [("code", ctypes.c_ushort), ("state", ctypes.c_ushort), _fields_ = [("code", ctypes.c_ushort), ("state", ctypes.c_ushort),
("information", ctypes.c_ulong)] ("information", ctypes.c_uint)]
def key_strokes(key):
"""键名 -> (scancode, e0) ; 未知返回 None。"""
if key in SCAN:
return SCAN[key], False
if key in SCAN_E0:
return SCAN_E0[key], True
return None
def to_absolute(v, size):
"""像素 -> Interception 绝对坐标 0..65535 (主屏)。"""
if size <= 1:
return 0
v = min(max(int(v), 0), size - 1)
return int(round(v * 65535.0 / (size - 1)))
class InterceptionBackend: class InterceptionBackend:
def __init__(self, dll_path=None): def __init__(self, dll_path=None, keyboard=None, mouse=None):
if dll_path is None: if dll_path is None:
dll_path = r'C:\Program Files\Interception\interception.dll' dll_path = r'C:\Program Files\Interception\interception.dll'
try: try:
@@ -76,69 +105,77 @@ class InterceptionBackend:
self.dll = ctypes.CDLL('interception.dll') self.dll = ctypes.CDLL('interception.dll')
self._api() self._api()
self._user32 = ctypes.WinDLL('user32', use_last_error=True) self._user32 = ctypes.WinDLL('user32', use_last_error=True)
win_dpi_aware(self._user32)
self.ctx = self.dll.interception_create_context() self.ctx = self.dll.interception_create_context()
if not self.ctx: if not self.ctx:
raise RuntimeError('interception_create_context failed (驱动未安装/未重启?)') raise RuntimeError('interception_create_context failed (驱动未安装/未重启?)')
self._kbd_devs, self._mou_devs = self._discover() # 只往一个设备发: 广播到所有键盘会让同一个键被按多次
self.kbd = keyboard or self._first_present(KEYBOARD_DEVS)
self.mou = mouse or self._first_present(MOUSE_DEVS)
self._scr_w = self._user32.GetSystemMetrics(0) self._scr_w = self._user32.GetSystemMetrics(0)
self._scr_h = self._user32.GetSystemMetrics(1) self._scr_h = self._user32.GetSystemMetrics(1)
def __del__(self):
try:
if getattr(self, 'ctx', None):
self.dll.interception_destroy_context(self.ctx)
self.ctx = None
except Exception:
pass
def _api(self): def _api(self):
d = self.dll d = self.dll
d.interception_create_context.restype = ctypes.c_void_p d.interception_create_context.restype = ctypes.c_void_p
d.interception_create_context.argtypes = [] d.interception_create_context.argtypes = []
d.interception_destroy_context.restype = None
d.interception_destroy_context.argtypes = [ctypes.c_void_p] d.interception_destroy_context.argtypes = [ctypes.c_void_p]
d.interception_open_device.restype = ctypes.c_bool d.interception_get_hardware_id.restype = ctypes.c_uint
d.interception_open_device.argtypes = [ctypes.c_void_p, ctypes.c_int]
d.interception_close_device.argtypes = [ctypes.c_void_p, ctypes.c_int]
d.interception_get_hardware_id.restype = ctypes.c_int
d.interception_get_hardware_id.argtypes = [ctypes.c_void_p, ctypes.c_int, d.interception_get_hardware_id.argtypes = [ctypes.c_void_p, ctypes.c_int,
ctypes.c_char_p, ctypes.c_int] ctypes.c_void_p, ctypes.c_uint]
d.interception_send.restype = ctypes.c_int d.interception_send.restype = ctypes.c_int
d.interception_send.argtypes = [ctypes.c_void_p, ctypes.c_int, d.interception_send.argtypes = [ctypes.c_void_p, ctypes.c_int,
ctypes.c_void_p, ctypes.c_size_t] ctypes.c_void_p, ctypes.c_uint]
def _discover(self): def hardware_id(self, dev):
kbd, mou = [], [] buf = ctypes.create_string_buffer(512)
buf = ctypes.create_string_buffer(256) n = self.dll.interception_get_hardware_id(self.ctx, dev, buf, ctypes.sizeof(buf))
for dev in range(1, MAX_DEVICES + 1): if not n or n > ctypes.sizeof(buf):
if not self.dll.interception_open_device(self.ctx, dev): return ''
continue # 驱动返回 UTF-16 (REG_MULTI_SZ), 取第一个
n = self.dll.interception_get_hardware_id(self.ctx, dev, buf, 256) return buf.raw[:n].decode('utf-16-le', 'replace').split('\x00')[0]
hid = buf.value.decode('ascii', 'replace').lower() if n > 0 else ''
if 'keyboard' in hid: def _first_present(self, devs):
kbd.append(dev) for dev in devs:
elif 'mouse' in hid: if self.hardware_id(dev):
mou.append(dev) return dev
return kbd, mou return devs[0]
def set_screen(self, w, h):
"""以截图尺寸为准(会话 0 / DPI 虚拟化下 GetSystemMetrics 不可信)。"""
self._scr_w, self._scr_h = int(w), int(h)
# ---- 底层发送 ---- # ---- 底层发送 ----
def _kbd_stroke(self, code, state): def _send(self, dev, stroke):
ks = KeyStroke() n = self.dll.interception_send(self.ctx, dev, ctypes.byref(stroke), 1)
ks.code = ctypes.c_ushort(code) if n != 1:
ks.state = ctypes.c_ushort(state) raise RuntimeError('interception_send(dev=%d) returned %d' % (dev, n))
for dev in self._kbd_devs or [1]:
try: def _kbd_stroke(self, code, state, e0=False):
self.dll.interception_send(self.ctx, dev, ctypes.byref(ks), ctypes.sizeof(ks)) ks = KeyStroke(code=code, state=state | (KEY_E0 if e0 else 0))
except Exception: self._send(self.kbd, ks)
pass
def _mouse_stroke(self, state=0, flags=0, x=0, y=0): def _mouse_stroke(self, state=0, flags=0, x=0, y=0):
ms = MouseStroke() self._send(self.mou, MouseStroke(state=state, flags=flags, x=int(x), y=int(y)))
ms.state = ctypes.c_ushort(state)
ms.flags = ctypes.c_ushort(flags) def _tap(self, code, e0=False, hold=0.04):
ms.x = ctypes.c_ulong(int(x)) self._kbd_stroke(code, KEY_DOWN, e0)
ms.y = ctypes.c_ulong(int(y)) time.sleep(hold)
for dev in self._mou_devs or [17]: self._kbd_stroke(code, KEY_UP, e0)
try:
self.dll.interception_send(self.ctx, dev, ctypes.byref(ms), ctypes.sizeof(ms))
except Exception:
pass
# ---- 公开动作 ---- # ---- 公开动作 ----
def move(self, x, y): def move(self, x, y):
nx = int(int(x) * 65535 / self._scr_w) if self._scr_w else 0 nx = to_absolute(x, self._scr_w)
ny = int(int(y) * 65535 / self._scr_h) if self._scr_h else 0 ny = to_absolute(y, self._scr_h)
self._mouse_stroke(state=0, flags=MOUSE_MOVE_ABSOLUTE, x=nx, y=ny) self._mouse_stroke(state=0, flags=MOUSE_MOVE_ABSOLUTE, x=nx, y=ny)
time.sleep(0.03) time.sleep(0.03)
return {'ok': True, 'backend': 'interception'} return {'ok': True, 'backend': 'interception'}
@@ -152,44 +189,51 @@ class InterceptionBackend:
down, up = MOUSE_RIGHTBUTTON_DOWN, MOUSE_RIGHTBUTTON_UP down, up = MOUSE_RIGHTBUTTON_DOWN, MOUSE_RIGHTBUTTON_UP
for _ in range(max(1, int(clicks))): for _ in range(max(1, int(clicks))):
self._mouse_stroke(state=down) self._mouse_stroke(state=down)
time.sleep(0.04) time.sleep(0.06)
self._mouse_stroke(state=up) self._mouse_stroke(state=up)
time.sleep(0.05) time.sleep(0.06)
return {'ok': True, 'clicked': [int(x), int(y)], 'backend': 'interception'} return {'ok': True, 'clicked': [int(x), int(y)], 'backend': 'interception'}
def _scancode(self, key):
k = str(key).lower()
return SCAN.get(k)
def keypress(self, key): def keypress(self, key):
k = str(key) try:
code = SCAN.get(k.lower()) parts = parse_combo(key)
if code is None: except ValueError as e:
return {'ok': False, 'error': str(e)}
strokes = [key_strokes(p) for p in parts]
if None in strokes:
return {'ok': False, 'error': 'unknown key %s' % key} return {'ok': False, 'error': 'unknown key %s' % key}
self._kbd_stroke(code, KEY_DOWN) for code, e0 in strokes[:-1]: # 修饰键按下
time.sleep(0.04) self._kbd_stroke(code, KEY_DOWN, e0)
self._kbd_stroke(code, KEY_UP) time.sleep(0.03)
time.sleep(0.02) self._tap(*strokes[-1])
return {'ok': True, 'key': k, 'backend': 'interception'} for code, e0 in reversed(strokes[:-1]):
time.sleep(0.03)
self._kbd_stroke(code, KEY_UP, e0)
return {'ok': True, 'key': str(key), 'backend': 'interception'}
def type_text(self, text): def type_text(self, text):
for ch in str(text): text = str(text)
plan = []
for ch in text:
low = ch.lower() low = ch.lower()
if ch.isupper() and low in SCAN: if ch == ' ':
self._kbd_stroke(SCAN['shift'], KEY_DOWN) plan.append((SCAN['space'], False))
self._kbd_stroke(SCAN[low], KEY_DOWN) elif ch == '\n':
self._kbd_stroke(SCAN[low], KEY_UP) plan.append((SCAN['enter'], False))
self._kbd_stroke(SCAN['shift'], KEY_UP) elif low in SCAN and len(low) == 1:
elif ch.lower() in SCAN: plan.append((SCAN[low], ch.isupper()))
code = SCAN[low]
self._kbd_stroke(code, KEY_DOWN)
self._kbd_stroke(code, KEY_UP)
elif ch in UPPER_SCAN: elif ch in UPPER_SCAN:
self._kbd_stroke(SCAN['shift'], KEY_DOWN) plan.append((UPPER_SCAN[ch], True))
self._kbd_stroke(UPPER_SCAN[ch], KEY_DOWN)
self._kbd_stroke(UPPER_SCAN[ch], KEY_UP)
self._kbd_stroke(SCAN['shift'], KEY_UP)
else: else:
return {'ok': False, 'error': 'untypable char %r' % ch} # 扫描码只能打 US 布局 ASCII; 中文请用 sendinput 后端(KEYEVENTF_UNICODE)
time.sleep(0.015) return {'ok': False, 'error': 'untypable char %r (interception 只支持 ASCII)' % ch}
return {'ok': True, 'typed': str(text), 'backend': 'interception'} for code, shift in plan:
if shift:
self._kbd_stroke(SCAN['shift'], KEY_DOWN)
time.sleep(0.02)
self._tap(code, hold=0.03)
if shift:
time.sleep(0.02)
self._kbd_stroke(SCAN['shift'], KEY_UP)
time.sleep(0.03)
return {'ok': True, 'typed': text, 'backend': 'interception'}
+73 -26
View File
@@ -1,20 +1,26 @@
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
"""SendInput 后端(Windows,ctypes user32)。 """SendInput 后端(Windows,ctypes user32)。
当前线上 lc_mcp.py 用的机制;作为 interception 不可用时的兜底。 当前线上 lc_mcp.py 用的机制;作为 interception 不可用时的兜底。
注意: SendInput 只能注入到调用进程所在的交互桌面; 从 SSH(session 0)里跑不会作用到游戏窗口。
""" """
import ctypes import ctypes
import time import time
from ctypes import wintypes from ctypes import wintypes
from ._util import parse_combo, win_dpi_aware
INPUT_MOUSE = 0 INPUT_MOUSE = 0
INPUT_KEYBOARD = 1 INPUT_KEYBOARD = 1
KEYEVENTF_EXTENDEDKEY = 0x0001
KEYEVENTF_KEYUP = 0x0002 KEYEVENTF_KEYUP = 0x0002
KEYEVENTF_UNICODE = 0x0004 KEYEVENTF_UNICODE = 0x0004
MOUSEEVENTF_MOVE = 0x0001
MOUSEEVENTF_LEFTDOWN = 0x0002 MOUSEEVENTF_LEFTDOWN = 0x0002
MOUSEEVENTF_LEFTUP = 0x0004 MOUSEEVENTF_LEFTUP = 0x0004
MOUSEEVENTF_RIGHTDOWN = 0x0008 MOUSEEVENTF_RIGHTDOWN = 0x0008
MOUSEEVENTF_RIGHTUP = 0x0010 MOUSEEVENTF_RIGHTUP = 0x0010
MAPVK_VK_TO_VSC = 0
class MOUSEINPUT(ctypes.Structure): class MOUSEINPUT(ctypes.Structure):
@@ -36,64 +42,105 @@ class INPUT(ctypes.Structure):
_fields_ = [("type", wintypes.DWORD), ("i", _I)] _fields_ = [("type", wintypes.DWORD), ("i", _I)]
KEYMAP = {'enter': 0x0D, 'return': 0x0D, 'esc': 0x1B, 'space': 0x20, KEYMAP = {'enter': 0x0D, 'esc': 0x1B, 'space': 0x20, 'tab': 0x09, 'backspace': 0x08,
'tab': 0x09, 'ctrl': 0x11, 'alt': 0x12, 'shift': 0x10, 'ctrl': 0x11, 'alt': 0x12, 'shift': 0x10, 'lshift': 0xA0, 'rshift': 0xA1,
'p': 0x50, 'f4': 0x73, 'f5': 0x74, 'f8': 0x77, 'f12': 0x7B, 'rctrl': 0xA3, 'ralt': 0xA5, 'lwin': 0x5B,
'1': 0x31, '2': 0x32, '3': 0x33, '4': 0x34, '5': 0x35, 'up': 0x26, 'down': 0x28, 'left': 0x25, 'right': 0x27,
'6': 0x36, '7': 0x37, '8': 0x38, '9': 0x39, '0': 0x30} 'home': 0x24, 'end': 0x23, 'pageup': 0x21, 'pagedown': 0x22,
'insert': 0x2D, 'delete': 0x2E}
KEYMAP.update({'f%d' % i: 0x6F + i for i in range(1, 13)})
EXTENDED = {0x26, 0x28, 0x25, 0x27, 0x24, 0x23, 0x21, 0x22, 0x2D, 0x2E, 0xA3, 0xA5, 0x5B}
def utf16_units(text):
"""str -> UTF-16 码元列表(BMP 外字符拆成代理对)。"""
data = str(text).encode('utf-16-le')
return [int.from_bytes(data[i:i + 2], 'little') for i in range(0, len(data), 2)]
class SendInputBackend: class SendInputBackend:
def __init__(self): def __init__(self):
self._user32 = ctypes.WinDLL('user32', use_last_error=True) self._user32 = ctypes.WinDLL('user32', use_last_error=True)
win_dpi_aware(self._user32)
self._user32.VkKeyScanW.restype = ctypes.c_short
self._user32.VkKeyScanW.argtypes = [wintypes.WCHAR]
self._user32.MapVirtualKeyW.restype = wintypes.UINT
self._user32.MapVirtualKeyW.argtypes = [wintypes.UINT, wintypes.UINT]
def _send_input(self, *inputs): def _send_input(self, *inputs):
n = len(inputs) n = len(inputs)
arr = (INPUT * n)(*inputs) arr = (INPUT * n)(*inputs)
return self._user32.SendInput(n, arr, ctypes.sizeof(INPUT)) sent = self._user32.SendInput(n, arr, ctypes.sizeof(INPUT))
if sent != n:
raise ctypes.WinError(ctypes.get_last_error())
return sent
def _mouse(self, flags):
m = INPUT(); m.type = INPUT_MOUSE; m.mi.dwFlags = flags
return m
def click(self, x, y, button='left', clicks=1): def click(self, x, y, button='left', clicks=1):
self._user32.SetCursorPos(int(x), int(y)) self._user32.SetCursorPos(int(x), int(y))
# 补一个 0 位移的 MOVE, 让只看原始输入/WM_MOUSEMOVE 的游戏刷新 hover
self._send_input(self._mouse(MOUSEEVENTF_MOVE))
time.sleep(0.03) time.sleep(0.03)
down_flag = MOUSEEVENTF_LEFTDOWN if button == 'left' else MOUSEEVENTF_RIGHTDOWN down_flag = MOUSEEVENTF_LEFTDOWN if button == 'left' else MOUSEEVENTF_RIGHTDOWN
up_flag = MOUSEEVENTF_LEFTUP if button == 'left' else MOUSEEVENTF_RIGHTUP up_flag = MOUSEEVENTF_LEFTUP if button == 'left' else MOUSEEVENTF_RIGHTUP
for _ in range(max(1, int(clicks))): for _ in range(max(1, int(clicks))):
down = INPUT(); down.type = INPUT_MOUSE; down.mi.dwFlags = down_flag self._send_input(self._mouse(down_flag))
up = INPUT(); up.type = INPUT_MOUSE; up.mi.dwFlags = up_flag time.sleep(0.05)
self._send_input(down, up) self._send_input(self._mouse(up_flag))
time.sleep(0.05) time.sleep(0.05)
return {'ok': True, 'clicked': [int(x), int(y)], 'backend': 'sendinput'} return {'ok': True, 'clicked': [int(x), int(y)], 'backend': 'sendinput'}
def move(self, x, y): def move(self, x, y):
self._user32.SetCursorPos(int(x), int(y)) self._user32.SetCursorPos(int(x), int(y))
self._send_input(self._mouse(MOUSEEVENTF_MOVE))
time.sleep(0.01) time.sleep(0.01)
return {'ok': True, 'backend': 'sendinput'} return {'ok': True, 'backend': 'sendinput'}
def _vk(self, name):
if name in KEYMAP:
return KEYMAP[name]
if len(name) == 1:
r = self._user32.VkKeyScanW(name)
if r != -1:
return r & 0xFF
return None
def _key(self, vk, up):
ki = INPUT(); ki.type = INPUT_KEYBOARD
ki.ki.wVk = vk
ki.ki.wScan = self._user32.MapVirtualKeyW(vk, MAPVK_VK_TO_VSC)
ki.ki.dwFlags = (KEYEVENTF_KEYUP if up else 0) | (KEYEVENTF_EXTENDEDKEY if vk in EXTENDED else 0)
self._send_input(ki)
def keypress(self, key): def keypress(self, key):
name = str(key).lower() try:
vk = KEYMAP.get(name) parts = parse_combo(key)
if vk is None and len(name) == 1: except ValueError as e:
vk = ord(name.upper()) if name.isalpha() else ord(name) return {'ok': False, 'error': str(e)}
if vk is None: vks = [self._vk(p) for p in parts]
if None in vks:
return {'ok': False, 'error': 'unknown key %s' % key} return {'ok': False, 'error': 'unknown key %s' % key}
self._press(vk) for vk in vks[:-1]:
self._key(vk, False)
time.sleep(0.03)
self._key(vks[-1], False)
time.sleep(0.04)
self._key(vks[-1], True)
for vk in reversed(vks[:-1]):
time.sleep(0.03)
self._key(vk, True)
return {'ok': True, 'key': str(key), 'backend': 'sendinput'} return {'ok': True, 'key': str(key), 'backend': 'sendinput'}
def _press(self, vk):
ki = INPUT(); ki.type = INPUT_KEYBOARD; ki.ki.wVk = vk
self._send_input(ki)
time.sleep(0.04)
ki2 = INPUT(); ki2.type = INPUT_KEYBOARD; ki2.ki.wVk = vk
ki2.ki.dwFlags = KEYEVENTF_KEYUP
self._send_input(ki2)
def type_text(self, text): def type_text(self, text):
for ch in str(text): for unit in utf16_units(text):
ki = INPUT(); ki.type = INPUT_KEYBOARD ki = INPUT(); ki.type = INPUT_KEYBOARD
ki.ki.wScan = ord(ch); ki.ki.dwFlags = KEYEVENTF_UNICODE ki.ki.wScan = unit; ki.ki.dwFlags = KEYEVENTF_UNICODE
ki2 = INPUT(); ki2.type = INPUT_KEYBOARD ki2 = INPUT(); ki2.type = INPUT_KEYBOARD
ki2.ki.wScan = ord(ch) ki2.ki.wScan = unit
ki2.ki.dwFlags = KEYEVENTF_UNICODE | KEYEVENTF_KEYUP ki2.ki.dwFlags = KEYEVENTF_UNICODE | KEYEVENTF_KEYUP
self._send_input(ki, ki2) self._send_input(ki, ki2)
time.sleep(0.01) time.sleep(0.01)
+104 -65
View File
@@ -1,94 +1,133 @@
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
"""Linux uinput 物理输入后端(虚拟内核 evdev 设备,需 root 或 uinput 组权限)。 """Linux uinput 物理输入后端(虚拟内核 evdev 设备,需 root 或 uinput 组权限)。
比 xdotool 更接近硬件:内核层面人为物理设备,无 X 层痕迹。 比 xdotool 更接近硬件:内核层面人为物理设备,无 X 层痕迹。
依赖: python3-uinput 或手工 ioctl。 依赖: python-uinput (pip install python-uinput)。
鼠标用绝对坐标轴(ABS_X/ABS_Y): 相对位移(REL_X/REL_Y)会被 libinput 指针加速放大, 点不准。
""" """
import os import time
import struct
from ._util import parse_combo
try: try:
import uinput import uinput
HAVE_UINPUT = True HAVE_UINPUT = True
except ImportError: except ImportError:
uinput = None
HAVE_UINPUT = False HAVE_UINPUT = False
ABS_MAX = 65535
# 键名 -> python-uinput 常量名
_NAMED = {
'enter': 'ENTER', 'esc': 'ESC', 'space': 'SPACE', 'tab': 'TAB', 'backspace': 'BACKSPACE',
'ctrl': 'LEFTCTRL', 'rctrl': 'RIGHTCTRL', 'alt': 'LEFTALT', 'ralt': 'RIGHTALT',
'shift': 'LEFTSHIFT', 'lshift': 'LEFTSHIFT', 'rshift': 'RIGHTSHIFT', 'lwin': 'LEFTMETA',
'up': 'UP', 'down': 'DOWN', 'left': 'LEFT', 'right': 'RIGHT',
'home': 'HOME', 'end': 'END', 'pageup': 'PAGEUP', 'pagedown': 'PAGEDOWN',
'insert': 'INSERT', 'delete': 'DELETE',
',': 'COMMA', '.': 'DOT', '/': 'SLASH', ';': 'SEMICOLON', "'": 'APOSTROPHE',
'[': 'LEFTBRACE', ']': 'RIGHTBRACE', '-': 'MINUS', '=': 'EQUAL', '`': 'GRAVE', '\\': 'BACKSLASH',
}
_NAMED.update({c: c.upper() for c in 'abcdefghijklmnopqrstuvwxyz0123456789'})
_NAMED.update({'f%d' % i: 'F%d' % i for i in range(1, 13)})
# US 布局下需要 Shift 的符号 -> 基础键
_SHIFTED = {'!': '1', '@': '2', '#': '3', '$': '4', '%': '5', '^': '6', '&': '7', '*': '8',
'(': '9', ')': '0', '_': '-', '+': '=', '{': '[', '}': ']', ':': ';', '"': "'",
'<': ',', '>': '.', '?': '/', '~': '`', '|': '\\'}
def _key_event(name):
const = _NAMED.get(name)
return getattr(uinput, 'KEY_' + const) if const else None
def _x_screen_size():
try:
from Xlib import display
s = display.Display().screen()
return s.width_in_pixels, s.height_in_pixels
except Exception:
return 1920, 1080
class UinputBackend: class UinputBackend:
def __init__(self): def __init__(self, screen=None):
if not HAVE_UINPUT: if not HAVE_UINPUT:
raise RuntimeError('python3-uinput not installed') raise RuntimeError('python-uinput not installed (pip install python-uinput)')
self._ctx = None self._scr_w, self._scr_h = screen or _x_screen_size()
events = [getattr(uinput, 'KEY_' + c) for c in sorted(set(_NAMED.values()))]
events += [uinput.BTN_LEFT, uinput.BTN_RIGHT,
uinput.ABS_X + (0, ABS_MAX, 0, 0), uinput.ABS_Y + (0, ABS_MAX, 0, 0)]
self._dev = uinput.Device(events, name='lc-mcp-uinput')
time.sleep(0.5) # 等 udev / 显示服务器识别新设备
def _ensure(self): def set_screen(self, w, h):
if self._ctx is None: self._scr_w, self._scr_h = int(w), int(h)
from uinput import Device, KEY_A, KEY_Z, KEY_ENTER, KEY_ESC, KEY_SPACE, KEY_TAB, KEY_F4, KEY_LEFTCTRL, KEY_LEFTSHIFT, KEY_LEFTALT, KEY_BACKSPACE, REL_X, REL_Y, BTN_LEFT, BTN_RIGHT
events = (
# 全键盘范围(够用): A-Z + 数字 + 常用
*[key for key in range(KEY_A, KEY_Z + 1)],
KEY_ENTER, KEY_ESC, KEY_SPACE, KEY_TAB, KEY_F4,
KEY_LEFTCTRL, KEY_LEFTSHIFT, KEY_LEFTALT, KEY_BACKSPACE,
REL_X, REL_Y, BTN_LEFT, BTN_RIGHT,
)
self._dev = Device(events)
return self._dev
def _key(self, code): def _abs(self, v, size):
dev = self._ensure() v = min(max(int(v), 0), max(size - 1, 0))
dev.emit(code, 1) return int(round(v * ABS_MAX / max(size - 1, 1)))
dev.emit(code, 0)
time.sleep(0.03)
def move(self, x, y): def move(self, x, y):
# uinput 只有相对位移; 需要知道当前位置。先简单相对 0 通过 xdotool 定位, 或 https 轮询 self._dev.emit(uinput.ABS_X, self._abs(x, self._scr_w), syn=False)
# 简化: 用 python-xlib 查指针位置 -> 计算 delta self._dev.emit(uinput.ABS_Y, self._abs(y, self._scr_h))
try: time.sleep(0.03)
from Xlib import display return {'ok': True, 'backend': 'uinput'}
d = display.Display()
root = d.screen().root
qp = root.query_pointer()
curx, cury = qp.root_x, qp.root_y
dx, dy = int(x) - curx, int(y) - cury
dev = self._ensure()
dev.emit(REL_X, dx)
dev.emit(REL_Y, dy)
d.sync()
except Exception:
return {'ok': False, 'error': 'uinput move needs python-xlib'}
return {'ok': True}
def click(self, x, y, button='left', times=1): def click(self, x, y, button='left', clicks=1):
self.move(x, y) self.move(x, y)
dev = self._ensure() time.sleep(0.03)
btn = BTN_LEFT if button == 'left' else BTN_RIGHT btn = uinput.BTN_LEFT if button == 'left' else uinput.BTN_RIGHT
for _ in range(times): for _ in range(max(1, int(clicks))):
dev.emit(btn, 1) self._dev.emit(btn, 1)
time.sleep(0.05) time.sleep(0.05)
dev.emit(btn, 0) self._dev.emit(btn, 0)
time.sleep(0.05) time.sleep(0.05)
return {'ok': True} return {'ok': True, 'clicked': [int(x), int(y)], 'backend': 'uinput'}
def _tap(self, ev, hold=0.03):
self._dev.emit(ev, 1)
time.sleep(hold)
self._dev.emit(ev, 0)
def keypress(self, key): def keypress(self, key):
mapping = {'enter': KEY_ENTER, 'esc': KEY_ESC, 'space': KEY_SPACE, try:
'tab': KEY_TAB, 'f4': KEY_F4, 'ctrl': KEY_LEFTCTRL, parts = parse_combo(key)
'shift': KEY_LEFTSHIFT, 'alt': KEY_LEFTALT, 'backspace': KEY_BACKSPACE} except ValueError as e:
k = key.lower() return {'ok': False, 'error': str(e)}
if k in mapping: evs = [_key_event(p) for p in parts]
self._key(mapping[k]) if None in evs:
return {'ok': True}
if len(k) == 1 and 'a' <= k <= 'z':
from uinput import KEY_A
self._key(KEY_A + (ord(k) - ord('a')))
return {'ok': True}
return {'ok': False, 'error': 'unsupported key %s' % key} return {'ok': False, 'error': 'unsupported key %s' % key}
for ev in evs[:-1]:
self._dev.emit(ev, 1)
time.sleep(0.03)
self._tap(evs[-1], 0.04)
for ev in reversed(evs[:-1]):
time.sleep(0.03)
self._dev.emit(ev, 0)
return {'ok': True, 'key': str(key), 'backend': 'uinput'}
def type_text(self, text): def type_text(self, text):
for ch in text: plan = []
if 'a' <= ch.lower() <= 'z': for ch in str(text):
self.keypress(ch.lower()) if ch == ' ':
elif ch == ' ': plan.append(('space', False))
self.keypress('space') elif ch == '\n':
plan.append(('enter', False))
elif ch.lower() in _NAMED and len(ch) == 1:
plan.append((ch.lower(), ch.isupper()))
elif ch in _SHIFTED:
plan.append((_SHIFTED[ch], True))
else: else:
return {'ok': False, 'error': 'unsupported char %r' % ch} return {'ok': False, 'error': 'unsupported char %r (uinput 只支持 US 布局 ASCII)' % ch}
time.sleep(0.05) shift = uinput.KEY_LEFTSHIFT
return {'ok': True} for name, need_shift in plan:
if need_shift:
self._dev.emit(shift, 1)
self._tap(_key_event(name))
if need_shift:
self._dev.emit(shift, 0)
time.sleep(0.03)
return {'ok': True, 'typed': str(text), 'backend': 'uinput'}
+31 -26
View File
@@ -4,11 +4,24 @@
""" """
import shutil import shutil
import subprocess import subprocess
import time
from ._util import parse_combo
# 内部键名 -> X keysym
KEYSYM = {'enter': 'Return', 'esc': 'Escape', 'space': 'space', 'tab': 'Tab',
'backspace': 'BackSpace', 'alt': 'Alt_L', 'ralt': 'Alt_R', 'ctrl': 'Control_L',
'rctrl': 'Control_R', 'shift': 'Shift_L', 'lshift': 'Shift_L', 'rshift': 'Shift_R',
'lwin': 'Super_L', 'up': 'Up', 'down': 'Down', 'left': 'Left', 'right': 'Right',
'home': 'Home', 'end': 'End', 'pageup': 'Prior', 'pagedown': 'Next',
'insert': 'Insert', 'delete': 'Delete'}
KEYSYM.update({'f%d' % i: 'F%d' % i for i in range(1, 13)})
def _run(args): def _run(args):
return subprocess.run(args, capture_output=True, text=True, timeout=30) r = subprocess.run(args, capture_output=True, text=True, timeout=30)
if r.returncode != 0:
raise RuntimeError('%s failed: %s' % (' '.join(args[:2]), (r.stderr or '').strip()[-200:]))
return r
class XdotoolBackend: class XdotoolBackend:
@@ -17,34 +30,26 @@ class XdotoolBackend:
if not shutil.which('xdotool'): if not shutil.which('xdotool'):
raise RuntimeError('xdotool not found (apt install xdotool)') raise RuntimeError('xdotool not found (apt install xdotool)')
def _screen(self):
try:
r = _run(['xdotool', 'getdisplaygeometry'])
w, h = r.stdout.strip().split()
return int(w), int(h)
except Exception:
return 1920, 1080
def move(self, x, y): def move(self, x, y):
_run(['xdotool', 'mousemove', str(int(x)), str(int(y))]) _run(['xdotool', 'mousemove', '--sync', str(int(x)), str(int(y))])
return {'ok': True} return {'ok': True, 'backend': 'xdotool'}
def click(self, x, y, button='left', times=1): def click(self, x, y, button='left', clicks=1):
btn = {'left': '1', 'right': '3', 'middle': '2'}.get(button, '1') btn = {'left': '1', 'right': '3', 'middle': '2'}.get(button, '1')
_run(['xdotool', 'mousemove', str(int(x)), str(int(y))]) _run(['xdotool', 'mousemove', '--sync', str(int(x)), str(int(y)),
_run(['xdotool', 'click', '--repeat', str(times), '--delay', '60', btn]) 'click', '--repeat', str(max(1, int(clicks))), '--delay', '60', btn])
return {'ok': True} return {'ok': True, 'clicked': [int(x), int(y)], 'backend': 'xdotool'}
def keypress(self, key): def keypress(self, key):
key = key.lower() try:
# xdotool 键名映射 parts = parse_combo(key)
mapping = {'enter': 'Return', 'esc': 'Escape', 'space': 'space', except ValueError as e:
'tab': 'Tab', 'alt': 'Alt_L', 'f4': 'F4', 'ctrl': 'Control_L', return {'ok': False, 'error': str(e)}
'shift': 'Shift_L', 'backspace': 'BackSpace'} combo = '+'.join(KEYSYM.get(p, p) for p in parts)
k = mapping.get(key, key) _run(['xdotool', 'key', '--', combo])
_run(['xdotool', 'key', k]) return {'ok': True, 'key': str(key), 'backend': 'xdotool'}
return {'ok': True}
def type_text(self, text): def type_text(self, text):
_run(['xdotool', 'type', '--delay', '60', text]) # '--' 防止以 '-' 开头的文本被当成选项
return {'ok': True} _run(['xdotool', 'type', '--delay', '60', '--', str(text)])
return {'ok': True, 'typed': str(text), 'backend': 'xdotool'}