ksaa 2025.6.23.0__tar.gz → 2025.7.3.0__tar.gz

{ksaa-2025.6.23.0/ksaa.egg-info → ksaa-2025.7.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ksaa
-Version: 2025.6.23.0
+Version: 2025.7.3.0
 Summary: Kotones Auto Assistant(kaa) is a script for game 'Gakuen Idol M@ster' that automates the dailies and produces.
 Requires-Python: ~=3.10
 Description-Content-Type: text/markdown
@@ -106,6 +106,9 @@ kaa 的开发主要用到了以下开源项目：
 ](https://github.com/AllenHeartcore/GkmasObjectManager)：用于提取游戏图像资源，以 GPLv3 协议开源。
 * [gakumasu-diff](https://github.com/vertesan/gakumasu-diff)：游戏数据。
 
+kaa 的开发还参考了以下开源项目：
+* [EmulatorExtras](https://github.com/MaaXYZ/EmulatorExtras)：MuMu 与雷电模拟器的截图与控制接口定义。
+* [blue_archive_auto_script](https://github.com/pur1fying/blue_archive_auto_script)：MuMu 与雷电模拟器的截图与控制接口的 Python 实现，以及各模拟器的控制实现。
 
 ## 免责声明
 **请在使用本项目前仔细阅读以下内容。使用本脚本将带来包括但不限于账号被封禁的风险。**

{ksaa-2025.6.23.0 → ksaa-2025.7.3.0}/README.md

@@ -76,6 +76,9 @@ kaa 的开发主要用到了以下开源项目：
 ](https://github.com/AllenHeartcore/GkmasObjectManager)：用于提取游戏图像资源，以 GPLv3 协议开源。
 * [gakumasu-diff](https://github.com/vertesan/gakumasu-diff)：游戏数据。
 
+kaa 的开发还参考了以下开源项目：
+* [EmulatorExtras](https://github.com/MaaXYZ/EmulatorExtras)：MuMu 与雷电模拟器的截图与控制接口定义。
+* [blue_archive_auto_script](https://github.com/pur1fying/blue_archive_auto_script)：MuMu 与雷电模拟器的截图与控制接口的 Python 实现，以及各模拟器的控制实现。
 
 ## 免责声明
 **请在使用本项目前仔细阅读以下内容。使用本脚本将带来包括但不限于账号被封禁的风险。**

{ksaa-2025.6.23.0 → ksaa-2025.7.3.0}/WHATS_NEW.md

@@ -1,5 +1,47 @@
 # 更新日志
 ## kaa
+### v2025.7.3.0
+启动器：
+* [新增] 新启动器现在支持安装指定版本与指定补丁（#456019b）
+* [新增] 自动更新可禁用（#3f88c3a）
+* [新增] 启动器 C++ EXE 跳板程序（#b377b84）
+* [新增] 新启动器（#c4b93f4）
+
+其他：
+* [其他] Git 记录提取工具支持 bootstrap scope（#66ea531）
+
+### v2025.6.28.0
+脚本：
+* [修复] 修正 debug_entry 脚本路径处理逻辑（#b53a055）
+* [修复] 修复清理日志功能失效的问题（#ad5c7b7）
+* [修复] 修复 debug_entry 执行的脚本没有正确输出日志的问题（#3ceae4c）
+
+界面：
+* [新增] 优化日志导出功能（#9574d20）
+* [新增] 为 UI 增加部分配置有效性验证（#08a7e71）
+* [新增] 加入调试模式警告提示（#a01c37d）
+* [新增] 画面 Tab 刷新机制由自动改为手动（#2469fc0）
+* [新增] MuMu12 保活模式可选开启（#71170e5）
+
+框架：
+* [修复] 修复 Device 中缩放与截图 Hook 的处理顺序不正确问题
+* [修复] 修复 NemuIpc 在多显示器下的坐标系问题（#87da282）
+* [修复] 修复当目标分辨率与实际分辨率旋转不同时截图会强制拉伸的问题（#e62e65d）
+* [修复] 缩放处理支持自动识别旋转（#677932a）
+* [修复] 修复 NemuIpc 截图无法响应屏幕旋转导致的分辨率变化（#105a894）
+* [新增] NemuIpcImpl 获取显示器 ID 支持自动重试（#0c94acf）
+* [新增] 支持 MuMu12 后台保活模式（#e232826）
+* [新增] 引入 Nemu 截图与控制方式（#f0b9181）
+* [新增] 移除 WindowsImpl 中的分辨率缩放（#415a8df）
+* [新增] 支持等比例分辨率缩放（#bb7f603）
+* [重构] 组装 Device 改用 recipe 方案（#f01e022）
+* [重构] 将传递的 MuMu 路径从 shell 目录改为 MuMu 根目录（#784b8ed）
+
+其他：
+* [其他] HsvRangeTool 支持从剪贴板粘贴图片（#1397587）
+* [其他] VSCode 新增不初始化 context 的启动配置（#0718678）
+* [其他] 调整部分日志输出格式（#bcd8cf2）
+
 ### v2025.6.23.0
 脚本：
 * [新增] 优化了培育开始的逻辑，修复若干 bug（#86313ec）

{ksaa-2025.6.23.0 → ksaa-2025.7.3.0}/kotonebot/backend/context/context.py

@@ -46,12 +46,10 @@ from kotonebot.backend.color import (
 from kotonebot.backend.ocr import (
     Ocr, OcrResult, OcrResultList, jp, en, StringMatchFunction
 )
-from kotonebot.client.registration import AdbBasedImpl, create_device
 from kotonebot.config.manager import load_config, save_config
 from kotonebot.config.base_config import UserConfig
 from kotonebot.backend.core import Image, HintBox
 from kotonebot.errors import KotonebotWarning
-from kotonebot.client import DeviceImpl
 from kotonebot.backend.preprocessor import PreprocessorProtocol
 from kotonebot.primitives import Rect
 

{ksaa-2025.6.23.0 → ksaa-2025.7.3.0}/kotonebot/client/__init__.py

@@ -1,11 +1,10 @@
 from .device import Device
-from .registration import create_device, DeviceImpl
+from .registration import DeviceImpl
 
 # 确保所有实现都被注册
 from . import implements  # noqa: F401
 
 __all__ = [
     'Device',
-    'create_device',
     'DeviceImpl',
 ]

{ksaa-2025.6.23.0 → ksaa-2025.7.3.0}/kotonebot/client/device.py

@@ -9,6 +9,7 @@ from cv2.typing import MatLike
 from adbutils._device import AdbDevice as AdbUtilsDevice
 
 from ..backend.debug import result
+from ..errors import UnscalableResolutionError
 from kotonebot.backend.core import HintBox
 from kotonebot.primitives import Rect, Point, is_point
 from .protocol import ClickableObjectProtocol, Commandable, Touchable, Screenshotable, AndroidCommandable, WindowsCommandable
@@ -78,6 +79,31 @@ class Device:
         """
         设备平台名称。
         """
+        self.target_resolution: tuple[int, int] | None = None
+        """
+        目标分辨率。
+        
+        若设置，则在截图、点击、滑动等时会缩放到目标分辨率。
+        仅支持等比例缩放，若无法等比例缩放，则会抛出异常 `UnscalableResolutionError`。
+        """
+        self.match_rotation: bool = True
+        """
+        分辨率缩放是否自动匹配旋转。
+
+        当目标与真实分辨率的宽高比不一致时，是否允许通过旋转（交换宽高）后再进行匹配。
+        为 True 则忽略方向差异，只要宽高比一致就视为可缩放；False 则必须匹配旋转。
+
+        例如，当目标分辨率为 1920x1080，而真实分辨率为 1080x1920 时，
+        ``match_rotation`` 为 True 则认为可以缩放，为 False 则会抛出异常。
+        """
+        self.aspect_ratio_tolerance: float = 0.1
+        """
+        宽高比容差阈值。
+
+        判断两分辨率宽高比差异是否接受的阈值。
+        该值越小，对比例一致性的要求越严格。
+        默认为 0.1（即 10% 容差）。
+        """
     
     @property
     def adb(self) -> AdbUtilsDevice:
@@ -89,6 +115,50 @@ class Device:
     def adb(self, value: AdbUtilsDevice) -> None:
         self._adb = value
 
+    def _scale_pos_real_to_target(self, real_x: int, real_y: int) -> tuple[int, int]:
+        """将真实屏幕坐标缩放到目标逻辑坐标"""
+        if self.target_resolution is None:
+            return real_x, real_y
+
+        real_w, real_h = self.screen_size
+        target_w, target_h = self.target_resolution
+
+        # 校验分辨率是否可缩放并获取调整后的目标分辨率
+        adjusted_target_w, adjusted_target_h = self.__assert_scalable((real_w, real_h), (target_w, target_h))
+
+        scale_w = adjusted_target_w / real_w
+        scale_h = adjusted_target_h / real_h
+
+        return int(real_x * scale_w), int(real_y * scale_h)
+
+    def _scale_pos_target_to_real(self, target_x: int, target_y: int) -> tuple[int, int]:
+        """将目标逻辑坐标缩放到真实屏幕坐标"""
+        if self.target_resolution is None:
+            return target_x, target_y # 输入坐标已是真实坐标
+
+        real_w, real_h = self.screen_size
+        target_w, target_h = self.target_resolution
+
+        # 校验分辨率是否可缩放并获取调整后的目标分辨率
+        adjusted_target_w, adjusted_target_h = self.__assert_scalable((real_w, real_h), (target_w, target_h))
+
+        scale_to_real_w = real_w / adjusted_target_w
+        scale_to_real_h = real_h / adjusted_target_h
+
+        return int(target_x * scale_to_real_w), int(target_y * scale_to_real_h)
+
+    def __scale_image (self, img: MatLike) -> MatLike:
+        if self.target_resolution is None:
+            return img
+
+        target_w, target_h = self.target_resolution
+        h, w = img.shape[:2]
+
+        # 校验分辨率是否可缩放并获取调整后的目标分辨率
+        adjusted_target = self.__assert_scalable((w, h), (target_w, target_h))
+
+        return cv2.resize(img, adjusted_target)
+
     @overload
     def click(self) -> None:
         """
@@ -161,7 +231,12 @@ class Device:
             logger.debug(f"Executing click hook before: ({x}, {y})")
             x, y = hook(x, y)
             logger.debug(f"Click hook before result: ({x}, {y})")
-        logger.debug(f"Click: {x}, {y}")
+        if self.target_resolution is not None:
+            # 输入坐标为逻辑坐标，需要转换为真实坐标
+            real_x, real_y = self._scale_pos_target_to_real(x, y)
+        else:
+            real_x, real_y = x, y
+        logger.debug(f"Click: {x}, {y}%s", f"(Physical: {real_x}, {real_y})" if self.target_resolution is not None else "")
         from ..backend.context import ContextStackVars
         if ContextStackVars.current() is not None:
             image = ContextStackVars.ensure_current()._screenshot
@@ -169,9 +244,11 @@ class Device:
             image = np.array([])
         if image is not None and image.size > 0:
             cv2.circle(image, (x, y), 10, (0, 0, 255), -1)
-            message = f"point: ({x}, {y})"
+            message = f"Point: ({x}, {y})"
+            if self.target_resolution is not None:
+                message += f" physical: ({real_x}, {real_y})"
             result("device.click", image, message)
-        self._touch.click(x, y)
+        self._touch.click(real_x, real_y)
 
     def __click_point_tuple(self, point: Point) -> None:
         self.click(point[0], point[1])
@@ -232,6 +309,10 @@ class Device:
         """
         滑动屏幕
         """
+        if self.target_resolution is not None:
+            # 输入坐标为逻辑坐标，需要转换为真实坐标
+            x1, y1 = self._scale_pos_target_to_real(x1, y1)
+            x2, y2 = self._scale_pos_target_to_real(x2, y2)
         self._touch.swipe(x1, y1, x2, y2, duration)
 
     def swipe_scaled(self, x1: float, y1: float, x2: float, y2: float, duration: float|None = None) -> None:
@@ -258,6 +339,7 @@ class Device:
                 logger.debug("screenshot hook before returned image")
                 return img
         img = self.screenshot_raw()
+        img = self.__scale_image(img)
         if self.screenshot_hook_after is not None:
             img = self.screenshot_hook_after(img)
         return img
@@ -296,8 +378,15 @@ class Device:
         `self.orientation` 属性默认为竖屏。如果需要自动检测，
         调用 `self.detect_orientation()` 方法。
         如果已知方向，也可以直接设置 `self.orientation` 属性。
+        
+        即使设置了 `self.target_resolution`，返回的分辨率仍然是真实分辨率。
         """
-        return self._screenshot.screen_size
+        size = self._screenshot.screen_size
+        if self.orientation == 'landscape':
+            size = sorted(size, reverse=True)
+        else:
+            size = sorted(size, reverse=False)
+        return size[0], size[1]
 
     def detect_orientation(self) -> Literal['portrait', 'landscape'] | None:
         """
@@ -307,6 +396,68 @@ class Device:
         """
         return self._screenshot.detect_orientation()
 
+    def __aspect_ratio_compatible(self, src_size: tuple[int, int], tgt_size: tuple[int, int]) -> bool:
+        """
+        判断两个尺寸在宽高比意义上是否兼容
+
+        若 ``self.match_rotation`` 为 True，忽略方向（长边/短边）进行比较。
+        判断标准由 ``self.aspect_ratio_tolerance`` 决定（默认 0.1）。
+        """
+        src_w, src_h = src_size
+        tgt_w, tgt_h = tgt_size
+
+        # 尺寸必须为正
+        if src_w <= 0 or src_h <= 0:
+            raise ValueError(f"Source size dimensions must be positive for scaling: {src_size}")
+        if tgt_w <= 0 or tgt_h <= 0:
+            raise ValueError(f"Target size dimensions must be positive for scaling: {tgt_size}")
+
+        tolerant = self.aspect_ratio_tolerance
+
+        # 直接比较宽高比
+        if abs((tgt_w / src_w) - (tgt_h / src_h)) <= tolerant:
+            return True
+
+        # 尝试忽略方向差异
+        if self.match_rotation:
+            ratio_src = max(src_w, src_h) / min(src_w, src_h)
+            ratio_tgt = max(tgt_w, tgt_h) / min(tgt_w, tgt_h)
+            return abs(ratio_src - ratio_tgt) <= tolerant
+
+        return False
+
+    def __assert_scalable(self, source: tuple[int, int], target: tuple[int, int]) -> tuple[int, int]:
+        """
+        校验分辨率是否可缩放，并返回调整后的目标分辨率。
+
+        当 match_rotation 为 True 且源分辨率与目标分辨率的旋转方向不一致时，
+        自动交换目标分辨率的宽高，使其与源分辨率的方向保持一致。
+
+        :param src_size: 源分辨率 (width, height)
+        :param tgt_size: 目标分辨率 (width, height)
+        :return: 调整后的目标分辨率 (width, height)
+        :raises UnscalableResolutionError: 若宽高比不兼容
+        """
+        # 智能调整目标分辨率方向
+        adjusted_tgt_size = target
+        if self.match_rotation:
+            src_w, src_h = source
+            tgt_w, tgt_h = target
+
+            # 判断源分辨率和目标分辨率的方向
+            src_is_landscape = src_w > src_h
+            tgt_is_landscape = tgt_w > tgt_h
+
+            # 如果方向不一致，交换目标分辨率的宽高
+            if src_is_landscape != tgt_is_landscape:
+                adjusted_tgt_size = (tgt_h, tgt_w)
+
+        # 校验调整后的分辨率是否兼容
+        if not self.__aspect_ratio_compatible(source, adjusted_tgt_size):
+            raise UnscalableResolutionError(target, source)
+
+        return adjusted_tgt_size
+
 
 class AndroidDevice(Device):
     def __init__(self, adb_connection: AdbUtilsDevice | None = None) -> None:

ksaa-2025.7.3.0/kotonebot/client/host/adb_common.py

@@ -0,0 +1,94 @@
+from abc import ABC
+from typing import Any, Literal, TypeGuard, TypeVar, get_args
+from typing_extensions import assert_never
+
+from adbutils import adb
+from adbutils._device import AdbDevice
+from kotonebot import logging
+from kotonebot.client.device import AndroidDevice
+from .protocol import Instance, AdbHostConfig, Device
+
+logger = logging.getLogger(__name__)
+AdbRecipes = Literal['adb', 'adb_raw', 'uiautomator2']
+
+def is_adb_recipe(recipe: Any) -> TypeGuard[AdbRecipes]:
+    return recipe in get_args(AdbRecipes)
+
+def connect_adb(
+    ip: str,
+    port: int,
+    connect: bool = True,
+    disconnect: bool = True,
+    timeout: float = 180,
+    device_serial: str | None = None
+) -> AdbDevice:
+    """
+    创建 ADB 连接。
+    """
+    if disconnect:
+        logger.debug('adb disconnect %s:%d', ip, port)
+        adb.disconnect(f'{ip}:{port}')
+    if connect:
+        logger.debug('adb connect %s:%d', ip, port)
+        result = adb.connect(f'{ip}:{port}')
+        if 'cannot connect to' in result:
+            raise ValueError(result)
+    serial = device_serial or f'{ip}:{port}'
+    logger.debug('adb wait for %s', serial)
+    adb.wait_for(serial, timeout=timeout)
+    devices = adb.device_list()
+    logger.debug('adb device_list: %s', devices)
+    d = [d for d in devices if d.serial == serial]
+    if len(d) == 0:
+        raise ValueError(f"Device {serial} not found")
+    d = d[0]
+    return d
+
+class CommonAdbCreateDeviceMixin(ABC):
+    """
+    通用 ADB 创建设备的 Mixin。
+    该 Mixin 定义了创建 ADB 设备的通用接口。
+    """
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        # 下面的属性只是为了让类型检查通过，无实际实现
+        self.adb_ip: str
+        self.adb_port: int
+        self.adb_name: str
+    
+    def create_device(self, recipe: AdbRecipes, config: AdbHostConfig) -> Device:
+        """
+        创建 ADB 设备。
+        """
+        connection = connect_adb(
+            self.adb_ip,
+            self.adb_port,
+            connect=True,
+            disconnect=True,
+            timeout=config.timeout,
+            device_serial=self.adb_name
+        )
+        d = AndroidDevice(connection)
+        match recipe:
+            case 'adb':
+                from kotonebot.client.implements.adb import AdbImpl
+                impl = AdbImpl(connection)
+                d._screenshot = impl
+                d._touch = impl
+                d.commands = impl
+            case 'adb_raw':
+                from kotonebot.client.implements.adb_raw import AdbRawImpl
+                impl = AdbRawImpl(connection)
+                d._screenshot = impl
+                d._touch = impl
+                d.commands = impl
+            case 'uiautomator2':
+                from kotonebot.client.implements.uiautomator2 import UiAutomator2Impl
+                from kotonebot.client.implements.adb import AdbImpl
+                impl = UiAutomator2Impl(connection)
+                d._screenshot = impl
+                d._touch = impl
+                d.commands = AdbImpl(connection)
+            case _:
+                assert_never(f'Unsupported ADB recipe: {recipe}')
+        return d

{ksaa-2025.6.23.0 → ksaa-2025.7.3.0}/kotonebot/client/host/custom.py

@@ -1,22 +1,21 @@
 import os
 import subprocess
 from psutil import process_iter
-from .protocol import Instance, AdbHostConfig
-from typing import ParamSpec, TypeVar, cast
+from .protocol import Instance, AdbHostConfig, HostProtocol
+from typing import ParamSpec, TypeVar
 from typing_extensions import override
 
 from kotonebot import logging
-from kotonebot.client import DeviceImpl
-from kotonebot.client.device import Device
-from kotonebot.client.registration import AdbBasedImpl, create_device
-from kotonebot.client.implements.adb import AdbImplConfig
+from kotonebot.client import Device
+from .adb_common import AdbRecipes, CommonAdbCreateDeviceMixin
 
 logger = logging.getLogger(__name__)
+CustomRecipes = AdbRecipes
 
 P = ParamSpec('P')
 T = TypeVar('T')
 
-class CustomInstance(Instance[AdbHostConfig]):
+class CustomInstance(CommonAdbCreateDeviceMixin, Instance[AdbHostConfig]):
     def __init__(self, exe_path: str | None, emulator_args: str = "", *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.exe_path: str | None = exe_path
@@ -69,24 +68,12 @@ class CustomInstance(Instance[AdbHostConfig]):
         pass
 
     @override
-    def create_device(self, impl: DeviceImpl, host_config: AdbHostConfig) -> Device:
+    def create_device(self, impl: CustomRecipes, host_config: AdbHostConfig) -> Device:
         """为自定义实例创建 Device。"""
         if self.adb_port is None:
             raise ValueError("ADB port is not set and is required.")
 
-        # 为 ADB 相关的实现创建配置
-        if impl in ['adb', 'adb_raw', 'uiautomator2']:
-            config = AdbImplConfig(
-                addr=f'{self.adb_ip}:{self.adb_port}',
-                connect=True,
-                disconnect=True,
-                device_serial=self.adb_name,
-                timeout=host_config.timeout
-            )
-            impl = cast(AdbBasedImpl, impl) # make pylance happy
-            return create_device(impl, config)
-        else:
-            raise ValueError(f'Unsupported device implementation for Custom: {impl}')
+        return super().create_device(impl, host_config)
 
     def __repr__(self) -> str:
         return f'CustomInstance(#{self.id}# at "{self.exe_path}" with {self.adb_ip}:{self.adb_port})'
@@ -99,6 +86,25 @@ def _type_check(ins: Instance) -> CustomInstance:
 def create(exe_path: str | None, adb_ip: str, adb_port: int, adb_name: str | None, emulator_args: str = "") -> CustomInstance:
     return CustomInstance(exe_path, emulator_args=emulator_args, id='custom', name='Custom', adb_ip=adb_ip, adb_port=adb_port, adb_name=adb_name)
 
+class CustomHost(HostProtocol[CustomRecipes]):
+    @staticmethod
+    def installed() -> bool:
+        # Custom instances don't have a specific installation requirement
+        return True
+
+    @staticmethod
+    def list() -> list[Instance]:
+        # Custom instances are created manually, not discovered
+        return []
+
+    @staticmethod
+    def query(*, id: str) -> Instance | None:
+        # Custom instances are created manually, not discovered
+        return None
+
+    @staticmethod
+    def recipes() -> 'list[CustomRecipes]':
+        return ['adb', 'adb_raw', 'uiautomator2']
 
 if __name__ == '__main__':
     ins = create(r'C:\Program Files\BlueStacks_nxt\HD-Player.exe', '127.0.0.1', 5555, '**emulator-name**')

{ksaa-2025.6.23.0 → ksaa-2025.7.3.0}/kotonebot/client/host/leidian_host.py

@@ -1,18 +1,17 @@
 import os
 import subprocess
-from typing import cast
+from typing import Literal
 from functools import lru_cache
 from typing_extensions import override
 
 from kotonebot import logging
-from kotonebot.client import DeviceImpl
-from kotonebot.client.device import Device
-from kotonebot.client.registration import AdbBasedImpl, create_device
-from kotonebot.client.implements.adb import AdbImplConfig
+from kotonebot.client import Device
 from kotonebot.util import Countdown, Interval
 from .protocol import HostProtocol, Instance, copy_type, AdbHostConfig
+from .adb_common import AdbRecipes, CommonAdbCreateDeviceMixin
 
 logger = logging.getLogger(__name__)
+LeidianRecipes = AdbRecipes
 
 if os.name == 'nt':
     from ...interop.win.reg import read_reg
@@ -21,7 +20,7 @@ else:
         """Stub for read_reg on non-Windows platforms."""
         return default
 
-class LeidianInstance(Instance[AdbHostConfig]):
+class LeidianInstance(CommonAdbCreateDeviceMixin, Instance[AdbHostConfig]):
     @copy_type(Instance.__init__)
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -64,35 +63,23 @@ class LeidianInstance(Instance[AdbHostConfig]):
         it = Interval(5)
         while not cd.expired() and not self.running():
             it.wait()
+            self.refresh()
         if not self.running():
             raise TimeoutError(f'Leidian instance "{self.name}" is not available.')
 
     @override
     def running(self) -> bool:
-        result = LeidianHost._invoke_manager(['isrunning', '--index', str(self.index)])
-        return result.strip() == 'running'
+        return self.is_running
 
     @override
-    def create_device(self, impl: DeviceImpl, host_config: AdbHostConfig) -> Device:
+    def create_device(self, impl: LeidianRecipes, host_config: AdbHostConfig) -> Device:
         """为雷电模拟器实例创建 Device。"""
         if self.adb_port is None:
             raise ValueError("ADB port is not set and is required.")
 
-        # 为 ADB 相关的实现创建配置
-        if impl in ['adb', 'adb_raw', 'uiautomator2']:
-            config = AdbImplConfig(
-                addr=f'{self.adb_ip}:{self.adb_port}',
-                connect=False,  # 雷电模拟器不需要 adb connect
-                disconnect=False,
-                device_serial=self.adb_name,
-                timeout=host_config.timeout
-            )
-            impl = cast(AdbBasedImpl, impl) # make pylance happy
-            return create_device(impl, config)
-        else:
-            raise ValueError(f'Unsupported device implementation for Leidian: {impl}')
+        return super().create_device(impl, host_config)
 
-class LeidianHost(HostProtocol):
+class LeidianHost(HostProtocol[LeidianRecipes]):
     @staticmethod
     @lru_cache(maxsize=1)
     def _read_install_path() -> str | None:
@@ -197,6 +184,10 @@ class LeidianHost(HostProtocol):
                 return instance
         return None
 
+    @staticmethod
+    def recipes() -> 'list[LeidianRecipes]':
+        return ['adb', 'adb_raw', 'uiautomator2']
+
 if __name__ == '__main__':
     logging.basicConfig(level=logging.DEBUG, format='[%(asctime)s] [%(levelname)s] [%(name)s] [%(funcName)s] [%(lineno)d] %(message)s')
     print(LeidianHost._read_install_path())