ksaa 2025.6.8.0__py3-none-any.whl → 2025.6.28.0__py3-none-any.whl

kotonebot/client/device.py

@@ -9,9 +9,10 @@ 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
+from .protocol import ClickableObjectProtocol, Commandable, Touchable, Screenshotable, AndroidCommandable, WindowsCommandable
 
 logger = logging.getLogger(__name__)
 
@@ -71,7 +72,6 @@ class Device:
         横屏时为 'landscape'，竖屏时为 'portrait'。
         """
 
-        self._command: Commandable
         self._touch: Touchable
         self._screenshot: Screenshotable
 
@@ -79,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:
@@ -90,12 +115,50 @@ class Device:
     def adb(self, value: AdbUtilsDevice) -> None:
         self._adb = value
 
-    def launch_app(self, package_name: str) -> None:
-        """
-        根据包名启动 app
-        """
-        self._command.launch_app(package_name)
-    
+    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:
         """
@@ -168,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
@@ -176,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])
@@ -239,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:
@@ -265,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
@@ -303,19 +378,15 @@ class Device:
         `self.orientation` 属性默认为竖屏。如果需要自动检测，
         调用 `self.detect_orientation()` 方法。
         如果已知方向，也可以直接设置 `self.orientation` 属性。
+        
+        即使设置了 `self.target_resolution`，返回的分辨率仍然是真实分辨率。
         """
-        return self._screenshot.screen_size
-
-    def current_package(self) -> str | None:
-        """
-        获取前台 APP 的包名。
-
-        :return: 前台 APP 的包名。如果获取失败，则返回 None。
-        :exception: 如果设备不支持此功能，则抛出 NotImplementedError。
-        """
-        ret = self._command.current_package()
-        logger.debug("current_package: %s", ret)
-        return ret
+        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:
         """
@@ -325,15 +396,97 @@ 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:
         super().__init__('android')
         self._adb: AdbUtilsDevice | None = adb_connection
+        self.commands: AndroidCommandable
+        
+    def current_package(self) -> str | None:
+        """
+        获取前台 APP 的包名。
+
+        :return: 前台 APP 的包名。如果获取失败，则返回 None。
+        :exception: 如果设备不支持此功能，则抛出 NotImplementedError。
+        """
+        ret = self.commands.current_package()
+        logger.debug("current_package: %s", ret)
+        return ret
+
+    def launch_app(self, package_name: str) -> None:
+        """
+        根据包名启动 app
+        """
+        self.commands.launch_app(package_name)
+    
 
 class WindowsDevice(Device):
     def __init__(self) -> None:
         super().__init__('windows')
+        self.commands: WindowsCommandable
 
         
 if __name__ == "__main__":
@@ -346,10 +499,10 @@ if __name__ == "__main__":
     d = adb.device_list()[-1]
     d.shell("dumpsys activity top | grep ACTIVITY | tail -n 1")
     dd = AndroidDevice(d)
-    adb_imp = AdbRawImpl(dd)
-    dd._command = adb_imp
+    adb_imp = AdbRawImpl(d)
     dd._touch = adb_imp
     dd._screenshot = adb_imp
+    dd.commands = adb_imp
     # dd._screenshot = MinicapScreenshotImpl(dd)
     # dd._screenshot = UiAutomator2Impl(dd)
 

kotonebot/client/host/__init__.py

@@ -1,10 +1,11 @@
-from .protocol import HostProtocol, Instance
+from .protocol import HostProtocol, Instance, AdbHostConfig, WindowsHostConfig, RemoteWindowsHostConfig
 from .custom import CustomInstance, create as create_custom
 from .mumu12_host import Mumu12Host, Mumu12Instance
 from .leidian_host import LeidianHost, LeidianInstance
 
 __all__ = [
     'HostProtocol', 'Instance',
+    'AdbHostConfig', 'WindowsHostConfig', 'RemoteWindowsHostConfig',
     'CustomInstance', 'create_custom',
     'Mumu12Host', 'Mumu12Instance',
     'LeidianHost', 'LeidianInstance'

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

kotonebot/client/host/custom.py

@@ -1,19 +1,21 @@
 import os
 import subprocess
 from psutil import process_iter
-from .protocol import HostProtocol, Instance
-from typing import Optional, ParamSpec, TypeVar, TypeGuard
+from .protocol import Instance, AdbHostConfig, HostProtocol
+from typing import ParamSpec, TypeVar
 from typing_extensions import override
 
 from kotonebot import logging
-from kotonebot.client.device import Device
+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):
+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
@@ -65,6 +67,14 @@ class CustomInstance(Instance):
     def refresh(self):
         pass
 
+    @override
+    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.")
+
+        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})'
 
@@ -76,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**')

kotonebot/client/host/leidian_host.py

@@ -1,15 +1,17 @@
 import os
 import subprocess
+from typing import Literal
 from functools import lru_cache
 from typing_extensions import override
 
 from kotonebot import logging
-from kotonebot.client import DeviceImpl, create_device
-from kotonebot.client.device import Device
+from kotonebot.client import Device
 from kotonebot.util import Countdown, Interval
-from .protocol import HostProtocol, Instance, copy_type
+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
@@ -18,7 +20,7 @@ else:
         """Stub for read_reg on non-Windows platforms."""
         return default
 
-class LeidianInstance(Instance):
+class LeidianInstance(CommonAdbCreateDeviceMixin, Instance[AdbHostConfig]):
     @copy_type(Instance.__init__)
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -61,27 +63,23 @@ class LeidianInstance(Instance):
         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, *, timeout: float = 180) -> 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.")
-        return create_device(
-            addr=f'{self.adb_ip}:{self.adb_port}',
-            impl=impl,
-            device_serial=self.adb_name,
-            connect=False,
-            timeout=timeout
-        )
 
-class LeidianHost(HostProtocol):
+        return super().create_device(impl, host_config)
+
+class LeidianHost(HostProtocol[LeidianRecipes]):
     @staticmethod
     @lru_cache(maxsize=1)
     def _read_install_path() -> str | None:
@@ -186,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())

kotonebot/client/host/mumu12_host.py

@@ -1,16 +1,19 @@
+from dataclasses import dataclass
 import os
 import json
 import subprocess
 from functools import lru_cache
-from typing import Any
+from typing import Any, Literal, overload
 from typing_extensions import override
 
 from kotonebot import logging
-from kotonebot.client import DeviceImpl, Device
+from kotonebot.client import Device
+from kotonebot.client.device import AndroidDevice
+from kotonebot.client.implements.adb import AdbImpl
+from kotonebot.client.implements.nemu_ipc import NemuIpcImpl, NemuIpcImplConfig
 from kotonebot.util import Countdown, Interval
-from .protocol import HostProtocol, Instance, copy_type
-
-logger = logging.getLogger(__name__)
+from .protocol import HostProtocol, Instance, copy_type, AdbHostConfig
+from .adb_common import AdbRecipes, CommonAdbCreateDeviceMixin, connect_adb, is_adb_recipe
 
 if os.name == 'nt':
     from ...interop.win.reg import read_reg
@@ -19,7 +22,21 @@ else:
         """Stub for read_reg on non-Windows platforms."""
         return default
 
-class Mumu12Instance(Instance):
+logger = logging.getLogger(__name__)
+MuMu12Recipes = AdbRecipes | Literal['nemu_ipc']
+
+@dataclass
+class MuMu12HostConfig(AdbHostConfig):
+    """nemu_ipc 能力的配置模型。"""
+    display_id: int | None = 0
+    """目标显示器 ID，默认为 0（主显示器）。若为 None 且设置了 target_package_name，则自动获取对应的 display_id。"""
+    target_package_name: str | None = None
+    """目标应用包名，用于自动获取 display_id。"""
+    app_index: int = 0
+    """多开应用索引，传给 get_display_id 方法。"""
+
+
+class Mumu12Instance(CommonAdbCreateDeviceMixin, Instance[MuMu12HostConfig]):
     @copy_type(Instance.__init__)
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -70,14 +87,58 @@ class Mumu12Instance(Instance):
     def running(self) -> bool:
         return self.is_android_started
 
-class Mumu12Host(HostProtocol):
+    @overload
+    def create_device(self, recipe: Literal['nemu_ipc'], host_config: MuMu12HostConfig) -> Device: ...
+    @overload
+    def create_device(self, recipe: AdbRecipes, host_config: AdbHostConfig) -> Device: ...
+
+    @override
+    def create_device(self, recipe: MuMu12Recipes, host_config: MuMu12HostConfig | AdbHostConfig) -> Device:
+        """为MuMu12模拟器实例创建 Device。"""
+        if self.adb_port is None:
+            raise ValueError("ADB port is not set and is required.")
+
+        if recipe == 'nemu_ipc' and isinstance(host_config, MuMu12HostConfig):
+            # NemuImpl
+            nemu_path = Mumu12Host._read_install_path()
+            if not nemu_path:
+                raise RuntimeError("无法找到 MuMu12 的安装路径。")
+            nemu_config = NemuIpcImplConfig(
+                nemu_folder=nemu_path,
+                instance_id=int(self.id),
+                display_id=host_config.display_id,
+                target_package_name=host_config.target_package_name,
+                app_index=host_config.app_index
+            )
+            nemu_impl = NemuIpcImpl(nemu_config)
+            # AdbImpl
+            adb_impl = AdbImpl(connect_adb(
+                self.adb_ip,
+                self.adb_port,
+                timeout=host_config.timeout,
+                device_serial=self.adb_name
+            ))
+            device = AndroidDevice()
+            device._screenshot = nemu_impl
+            device._touch = nemu_impl
+            device.commands = adb_impl
+
+            return device
+        elif isinstance(host_config, AdbHostConfig) and is_adb_recipe(recipe):
+            return super().create_device(recipe, host_config)
+        else:
+            raise ValueError(f'Unknown recipe: {recipe}')
+
+class Mumu12Host(HostProtocol[MuMu12Recipes]):
     @staticmethod
     @lru_cache(maxsize=1)
     def _read_install_path() -> str | None:
-        """
-        Reads the installation path (DisplayIcon) of MuMu Player 12 from the registry.
+        r"""
+        从注册表中读取 MuMu Player 12 的安装路径。
 
-        :return: The path to the display icon if found, otherwise None.
+        返回的路径为根目录。如 `F:\Apps\Netease\MuMuPlayer-12.0`。
+
+        :return: 若找到，则返回安装路径；否则返回 None。
         """
         if os.name != 'nt':
             return None
@@ -94,6 +155,9 @@ class Mumu12Host(HostProtocol):
                 icon_path = icon_path.replace('"', '')
                 path = os.path.dirname(icon_path)
                 logger.debug('MuMu Player 12 installation path: %s', path)
+                # 返回根目录（去掉 shell 子目录）
+                if os.path.basename(path).lower() == 'shell':
+                    path = os.path.dirname(path)
                 return path
         return None
 
@@ -108,7 +172,7 @@ class Mumu12Host(HostProtocol):
         install_path = Mumu12Host._read_install_path()
         if install_path is None:
             raise RuntimeError('MuMu Player 12 is not installed.')
-        manager_path = os.path.join(install_path, 'MuMuManager.exe')
+        manager_path = os.path.join(install_path, 'shell', 'MuMuManager.exe')
         logger.debug('MuMuManager execute: %s', repr(args))
         output = subprocess.run(
             [manager_path] + args,
@@ -162,6 +226,10 @@ class Mumu12Host(HostProtocol):
             if instance.id == id:
                 return instance
         return None
+
+    @staticmethod
+    def recipes() -> 'list[MuMu12Recipes]':
+        return ['adb', 'adb_raw', 'uiautomator2', 'nemu_ipc']
     
 if __name__ == '__main__':
     logging.basicConfig(level=logging.DEBUG, format='[%(asctime)s] [%(levelname)s] [%(name)s] [%(funcName)s] [%(lineno)d] %(message)s')