autoxkit 2.4.6__cp313-cp313-win_amd64.whl

autoxkit/__init__.py

@@ -0,0 +1,3 @@
+from .constants import Hex_Key_Code, Hex_Mouse_Code, Hex_Hook_Code
+
+__all__ = ["Hex_Key_Code", "Hex_Mouse_Code", "Hex_Hook_Code"]

autoxkit/android/__init__.py

@@ -0,0 +1,208 @@
+"""Android 设备控制模块。"""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+import time
+from pathlib import Path
+from typing import Any
+
+from .client import ScrcpyClient, ScrcpyOptions
+from .adb import AdbServerLauncher
+from .models import AudioVideoEvent, StreamKind
+
+__all__ = [
+    "AndroidDevice",
+    "ScrcpyClient",
+    "ScrcpyOptions",
+    "AdbServerLauncher",
+    "AudioVideoEvent",
+    "StreamKind",
+]
+
+
+class AndroidDevice:
+    """同步 Android 设备控制器。
+
+    将异步的 ``ScrcpyClient`` 封装在后台线程中，使所有公共方法都成为
+    普通的同步调用，适合在钩子回调中使用（``key_down``、``key_up`` 等）。
+
+    用法::
+
+        from autoxkit.android import AndroidDevice
+
+        device = AndroidDevice()
+        device.connect("192.168.1.23:5555")
+
+        device.tap(500, 300)
+        device.touch(500, 300, "down")
+        device.keycode(4, "up")
+        device.disconnect()
+    """
+
+    def __init__(
+        self,
+        adb_path: str | Path = Path("scrcpy-win64-v4.0") / "adb.exe",
+        server_path: str | Path = Path("scrcpy-win64-v4.0") / "scrcpy-server",
+    ) -> None:
+        self._adb_path = Path(adb_path)
+        self._server_path = Path(server_path)
+        self._loop = asyncio.new_event_loop()
+        self._thread = threading.Thread(target=self._run_loop, daemon=True)
+        self._thread.start()
+        self._client: ScrcpyClient | None = None
+        self._session_size: tuple[int, int] | None = None
+
+    # ── 连接管理 ────────────────────────────────
+
+    def connect(
+        self,
+        serial: str | None = None,
+        *,
+        video: bool = True,
+        audio: bool = True,
+        control: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        """通过 scrcpy-server 连接到 Android 设备。
+
+        参数将传递给 :class:`ScrcpyOptions`。常用额外参数：
+
+        - ``tunnel_forward`` (bool): 使用 ``adb forward`` 而不是
+          ``adb reverse``。
+        - ``tcpip`` (bool): 启动前启用 ADB over TCP/IP。
+        - ``tcpip_dst`` (str): 已知的无线 ADB 地址。
+        """
+        self._submit(
+            self._connect_async(serial, video=video, audio=audio, control=control, **kwargs)
+        )
+
+    def disconnect(self) -> None:
+        """断开与设备的连接并停止 scrcpy-server。"""
+        self._submit(self._disconnect_async())
+
+    @property
+    def connected(self) -> bool:
+        return self._client is not None
+
+    # ── 触摸 ────────────────────────────────────────────────
+
+    def touch(self, x: int, y: int, action: str) -> None:
+        """发送触摸事件。
+
+        Args:
+            x: 屏幕 X 坐标。
+            y: 屏幕 Y 坐标。
+            action: ``"down"``、``"up"`` 或 ``"move"``。
+        """
+        action_code = {"down": 0, "up": 1, "move": 2}.get(action)
+        if action_code is None:
+            raise ValueError(f"无效的触摸动作：{action!r}（请使用 down/up/move）")
+        self._submit(self._touch_async(action_code, x, y))
+
+    def tap(self, x: int, y: int, delay: float = 0.05) -> None:
+        """在屏幕坐标上执行点击（触摸按下然后抬起）。"""
+        self.touch(x, y, "down")
+        time.sleep(delay)
+        self.touch(x, y, "up")
+
+    def swipe(self, x1: int, y1: int, x2: int, y2: int, steps: int = 10) -> None:
+        """执行从 (x1, y1) 到 (x2, y2) 的滑动手势。"""
+        self.touch(x1, y1, "down")
+        for i in range(1, steps + 1):
+            t = i / steps
+            cx = int(x1 + (x2 - x1) * t)
+            cy = int(y1 + (y2 - y1) * t)
+            self.touch(cx, cy, "move")
+        self.touch(x2, y2, "up")
+
+    # ── 按键码 ──────────────────────────────────────────────
+
+    def keycode(self, keycode: int, action: str = "down") -> None:
+        """发送 Android 按键码事件。
+
+        Args:
+            keycode: Android 按键码（例如 4 = 返回，3 = 主页）。
+            action: ``"down"`` 或 ``"up"``。
+        """
+        action_code = {"down": 0, "up": 1}.get(action)
+        if action_code is None:
+            raise ValueError(f"无效的按键动作：{action!r}（请使用 down/up）")
+        self._submit(self._keycode_async(action_code, keycode))
+
+    def key_press(self, keycode: int) -> None:
+        """按下并释放按键（模拟单次点击）。"""
+        self.keycode(keycode, "down")
+        time.sleep(0.02)
+        self.keycode(keycode, "up")
+
+    # ── 剪贴板 ────────────────────────────────────────────
+
+    def set_clipboard(self, text: str, paste: bool = False) -> None:
+        """设置设备剪贴板（可选同时粘贴）。"""
+        self._submit(self._clipboard_async(text, paste))
+
+    # ── 内部异步辅助方法 ───────────────────────────────
+
+    async def _connect_async(
+        self,
+        serial: str | None,
+        video: bool,
+        audio: bool,
+        control: bool,
+        **kwargs: Any,
+    ) -> None:
+        if self._client is not None:
+            return
+        opts = ScrcpyOptions(
+            serial=serial,
+            adb_path=self._adb_path,
+            server_path=self._server_path,
+            video=video,
+            audio=audio,
+            control=control,
+            **kwargs,
+        )
+        client = ScrcpyClient(opts)
+        await client.start()
+        self._client = client
+
+    async def _disconnect_async(self) -> None:
+        if self._client is None:
+            return
+        await self._client.stop()
+        self._client = None
+        self._session_size = None
+
+    async def _touch_async(self, action: int, x: int, y: int) -> None:
+        if self._client is None or self._client.control is None:
+            raise RuntimeError("未连接到设备")
+        width, height = self._session_size or (1, 1)
+        await self._client.control.send_touch(action, x, y, width, height)
+
+    async def _keycode_async(self, action: int, keycode: int) -> None:
+        if self._client is None or self._client.control is None:
+            raise RuntimeError("未连接到设备")
+        await self._client.control.send_keycode(action, keycode)
+
+    async def _clipboard_async(self, text: str, paste: bool) -> None:
+        if self._client is None or self._client.control is None:
+            raise RuntimeError("未连接到设备")
+        await self._client.control.set_clipboard(text, sequence=1, paste=paste)
+
+    # ── 异步循环桥接 ─────────────────────────────────────
+
+    def _submit(self, coro: Any) -> Any:
+        future = asyncio.run_coroutine_threadsafe(coro, self._loop)
+        return future.result()
+
+    def _run_loop(self) -> None:
+        asyncio.set_event_loop(self._loop)
+        self._loop.run_forever()
+
+    def __enter__(self) -> AndroidDevice:
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.disconnect()

autoxkit/android/adb.py

@@ -0,0 +1,195 @@
+"""ADB 启动器，用于 scrcpy-server v4.0."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import re
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+if os.name == "nt":
+    _CREATE_NO_WINDOW = subprocess.CREATE_NO_WINDOW
+else:
+    _CREATE_NO_WINDOW = 0
+
+
+class AdbError(RuntimeError):
+    pass
+
+
+@dataclass(slots=True)
+class AdbServerLauncher:
+    adb_path: Path
+    server_path: Path
+    serial: str | None = None
+    device_server_path: str = "/data/local/tmp/scrcpy-server.jar"
+
+    async def connect_tcpip(self, address: str) -> None:
+        stdout, stderr = await self._adb_global_output("connect", address)
+        message = f"{stdout}\n{stderr}".lower()
+        if "failed" in message or "unable" in message or "cannot" in message:
+            raise AdbError((stderr or stdout).strip())
+        self.serial = address
+
+    async def disconnect_tcpip(self, address: str) -> None:
+        await self._adb_global("disconnect", address, check=False)
+
+    async def enable_tcpip(self, port: int = 5555) -> None:
+        await self._adb("tcpip", str(port))
+
+    async def get_device_ip(self) -> str:
+        """从 `adb shell ip route` 解析 Wi-Fi IP 地址。
+
+        仅考虑接口名称以 ``wlan`` 开头的行，
+        与官方 scrcpy 行为一致，跳过非 Wi-Fi 接口，
+        例如 rmnet_data（移动数据）或 usb0（USB 共享网络）。
+        """
+        route = await self.shell_output("ip", "route")
+        for line in route.splitlines():
+            # 查找类似如下的行：
+            #   192.168.1.0/24 dev wlan0  proto kernel  scope link  src 192.168.1.x
+            fields = line.split()
+            for i, field in enumerate(fields):
+                if field == "dev" and i + 1 < len(fields) and fields[i + 1].startswith("wlan"):
+                    # 找到 wlan 行，提取源 IP
+                    for j, f in enumerate(fields):
+                        if f == "src" and j + 1 < len(fields):
+                            ip = fields[j + 1]
+                            if re.match(r"^\d{1,3}(\.\d{1,3}){3}$", ip):
+                                return ip
+        raise AdbError(
+            f"在 `adb shell ip route` 中找不到 Wi-Fi（wlan）设备的 IP: {route.strip()}"
+        )
+
+    async def discover_usb_serial(self) -> str | None:
+        """发现单个 USB 连接设备的序列号。
+
+        如果没有 USB 设备或有多个设备，则返回 None。
+        """
+        proc = await asyncio.create_subprocess_exec(
+            str(self.adb_path),
+            "devices", "-l",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            creationflags=_CREATE_NO_WINDOW,
+        )
+        stdout, _ = await proc.communicate()
+        out = stdout.decode(errors="replace")
+
+        usb_serials = []
+        for line in out.splitlines():
+            # 跳过空行和 "List of devices attached" 标题行
+            if not line.strip() or not line[0].isalnum():
+                continue
+            parts = line.split()
+            if len(parts) < 2:
+                continue
+            serial = parts[0]
+            state = parts[1]
+            if state != "device":
+                continue
+            # USB 设备的序列号不包含 ":"
+            # TCP/IP 设备的格式为 ip:port
+            if ":" not in serial:
+                usb_serials.append(serial)
+
+        if len(usb_serials) == 1:
+            return usb_serials[0]
+        return None
+
+    async def shell_output(self, *args: str) -> str:
+        stdout, _ = await self._adb_output("shell", *args)
+        return stdout
+
+    async def push_server(self) -> None:
+        await self._adb("push", str(self.server_path), self.device_server_path)
+
+    async def reverse(self, socket_name: str, port: int) -> None:
+        await self._adb("reverse", f"localabstract:{socket_name}", f"tcp:{port}")
+
+    async def remove_reverse(self, socket_name: str) -> None:
+        await self._adb("reverse", "--remove", f"localabstract:{socket_name}", check=False)
+
+    async def forward(self, socket_name: str, port: int) -> None:
+        await self._adb("forward", f"tcp:{port}", f"localabstract:{socket_name}")
+
+    async def remove_forward(self, port: int) -> None:
+        await self._adb("forward", "--remove", f"tcp:{port}", check=False)
+
+    async def start_server_process(
+        self,
+        *,
+        version: str,
+        scid: int,
+        tunnel_forward: bool,
+        video: bool,
+        audio: bool,
+        control: bool,
+        log_level: str,
+        extra_args: list[str] | None = None,
+    ) -> asyncio.subprocess.Process:
+        args = [
+            str(self.adb_path),
+            *self._serial_args(),
+            "shell",
+            f"CLASSPATH={self.device_server_path}",
+            "app_process",
+            "/",
+            "com.genymobile.scrcpy.Server",
+            version,
+            f"scid={scid:08x}",
+            f"log_level={log_level}",
+        ]
+        if tunnel_forward:
+            args.append("tunnel_forward=true")
+        if not video:
+            args.append("video=false")
+        if not audio:
+            args.append("audio=false")
+        if not control:
+            args.append("control=false")
+        if extra_args:
+            args.extend(extra_args)
+
+        return await asyncio.create_subprocess_exec(
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            creationflags=_CREATE_NO_WINDOW,
+        )
+
+    async def _adb(self, *args: str, check: bool = True) -> asyncio.subprocess.Process:
+        proc, _, _ = await self._run_adb([*self._serial_args(), *args], check=check)
+        return proc
+
+    async def _adb_global(self, *args: str, check: bool = True) -> asyncio.subprocess.Process:
+        proc, _, _ = await self._run_adb([*args], check=check)
+        return proc
+
+    async def _adb_output(self, *args: str, check: bool = True) -> tuple[str, str]:
+        _, stdout, stderr = await self._run_adb([*self._serial_args(), *args], check=check)
+        return stdout, stderr
+
+    async def _adb_global_output(self, *args: str, check: bool = True) -> tuple[str, str]:
+        _, stdout, stderr = await self._run_adb([*args], check=check)
+        return stdout, stderr
+
+    async def _run_adb(self, args: list[str], check: bool = True) -> tuple[asyncio.subprocess.Process, str, str]:
+        proc = await asyncio.create_subprocess_exec(
+            str(self.adb_path),
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            creationflags=_CREATE_NO_WINDOW,
+        )
+        stdout, stderr = await proc.communicate()
+        out = stdout.decode(errors="replace").strip()
+        err = stderr.decode(errors="replace").strip()
+        if check and proc.returncode:
+            raise AdbError(f"adb {' '.join(args)} failed: {err or out}")
+        return proc, out, err
+
+    def _serial_args(self) -> list[str]:
+        return ["-s", self.serial] if self.serial else []

autoxkit/android/binary.py

@@ -0,0 +1,115 @@
+"""scrcpy v4.0 协议的二进制辅助函数。"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+
+
+ReadExact = Callable[[int], Awaitable[bytes]]
+
+
+class ProtocolError(Exception):
+    """当网络上的字节不符合预期协议时抛出。"""
+
+
+class StreamDisabledError(ProtocolError):
+    """当 scrcpy-server 显式禁用媒体流时抛出。"""
+
+
+class StreamConfigurationError(ProtocolError):
+    """当 scrcpy-server 报告媒体流配置错误时抛出。"""
+
+
+def u16be(value: int) -> bytes:
+    return int(value).to_bytes(2, "big", signed=False)
+
+
+def i16be(value: int) -> bytes:
+    return int(value).to_bytes(2, "big", signed=True)
+
+
+def u32be(value: int) -> bytes:
+    return int(value).to_bytes(4, "big", signed=False)
+
+
+def i32be(value: int) -> bytes:
+    return int(value).to_bytes(4, "big", signed=True)
+
+
+def u64be(value: int) -> bytes:
+    return int(value).to_bytes(8, "big", signed=False)
+
+
+def read_u16be(data: bytes | bytearray | memoryview, offset: int = 0) -> int:
+    return int.from_bytes(data[offset : offset + 2], "big", signed=False)
+
+
+def read_i16be(data: bytes | bytearray | memoryview, offset: int = 0) -> int:
+    return int.from_bytes(data[offset : offset + 2], "big", signed=True)
+
+
+def read_u32be(data: bytes | bytearray | memoryview, offset: int = 0) -> int:
+    return int.from_bytes(data[offset : offset + 4], "big", signed=False)
+
+
+def read_i32be(data: bytes | bytearray | memoryview, offset: int = 0) -> int:
+    return int.from_bytes(data[offset : offset + 4], "big", signed=True)
+
+
+def read_u64be(data: bytes | bytearray | memoryview, offset: int = 0) -> int:
+    return int.from_bytes(data[offset : offset + 8], "big", signed=False)
+
+
+async def read_exact(reader: asyncio.StreamReader, size: int) -> bytes:
+    try:
+        return await reader.readexactly(size)
+    except asyncio.IncompleteReadError as exc:
+        raise EOFError(f"期望 {size} 字节，实际获取 {len(exc.partial)} 字节") from exc
+
+
+def utf8_truncate(text: str, max_bytes: int) -> bytes:
+    raw = text.encode("utf-8")
+    if len(raw) <= max_bytes:
+        return raw
+    end = max_bytes
+    while end > 0:
+        try:
+            return raw[:end].decode("utf-8").encode("utf-8")
+        except UnicodeDecodeError:
+            end -= 1
+    return b""
+
+
+def string32(text: str, max_payload_len: int) -> bytes:
+    raw = utf8_truncate(text, max_payload_len)
+    return u32be(len(raw)) + raw
+
+
+def string8(text: str, max_payload_len: int = 255) -> bytes:
+    if max_payload_len > 255:
+        raise ValueError("1字节字符串不能超过255字节")
+    raw = utf8_truncate(text, max_payload_len)
+    return bytes([len(raw)]) + raw
+
+
+def float_to_u16fp(value: float) -> int:
+    clamped = max(0.0, min(1.0, value))
+    return int(round(clamped * 0xFFFF))
+
+
+def float_to_i16fp(value: float) -> int:
+    clamped = max(-1.0, min(1.0, value))
+    if clamped == 1.0:
+        return 0x7FFF
+    return int(round(clamped * 0x8000))
+
+
+def u16fp_to_float(value: int) -> float:
+    return value / 0xFFFF
+
+
+def i16fp_to_float(value: int) -> float:
+    if value & 0x8000:
+        value -= 0x10000
+    return value / 0x8000