kotonebot 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

kotonebot/client/device.py

@@ -1,20 +1,22 @@
-import logging
-from typing_extensions import deprecated
-from typing import Callable, Literal, overload
+from typing import Callable, Literal, overload, TYPE_CHECKING
 
 import cv2
 import numpy as np
-from adbutils import adb
 from cv2.typing import MatLike
-from adbutils._device import AdbDevice as AdbUtilsDevice
 
+if TYPE_CHECKING:
+    from adbutils._device import AdbDevice as AdbUtilsDevice
+
+from kotonebot import logging
 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
+from .scaler import AbstractScaler
+from kotonebot.config.config import conf
+from kotonebot.primitives.geometry import Size
 
 logger = logging.getLogger(__name__)
+LogLevel = Literal['info', 'debug', 'verbose', 'silent']
 
 class HookContextManager:
     def __init__(self, device: 'Device', func: Callable[[MatLike], MatLike]):
@@ -30,7 +32,7 @@ class HookContextManager:
         self.device.screenshot_hook_after = self.old_func
 
 class Device:
-    def __init__(self, platform: str = 'unknown') -> None:
+    def __init__(self, platform: str = 'unknown', scaler: AbstractScaler | None = None) -> None:
         self.screenshot_hook_after: Callable[[MatLike], MatLike] | None = None
         """截图后调用的函数"""
         self.screenshot_hook_before: Callable[[], MatLike | None] | None = None
@@ -54,88 +56,52 @@ 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% 容差）。
-        """
+        self.log_level: LogLevel = 'debug'
+        """默认日志级别。"""
     
-    @property
-    def adb(self) -> AdbUtilsDevice:
-        if self._adb is None:
-            raise ValueError("AdbClient is not connected")
-        return self._adb
-
-    @adb.setter
-    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
+        self._scaler = scaler or conf().device.default_scaler_factory()
+        self._scaler_initialized = False
 
-        # 校验分辨率是否可缩放并获取调整后的目标分辨率
-        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)
+    @property
+    def scaler(self) -> AbstractScaler:
+        # TODO: 应该要有一种更好的方式，把从延迟初始化的 _screenshot 中获取到屏幕大小，以初始化 scaler 的逻辑放到更合适的位置。
+        if not self._scaler.physical_resolution:
+            self._scaler.logic_resolution = conf().device.default_logic_resolution
+            self._scaler.physical_resolution = Size(*self._screenshot.screen_size)
+            self._scaler_initialized = True
+        return self._scaler
+
+    def setup(self, 
+        *, 
+        screenshot: Screenshotable,
+        touch: Touchable,
+        commands: Commandable | None = None,
+        scaler: AbstractScaler | None = None,
+    ):
+        self._screenshot = screenshot
+        self._touch = touch
+        self.commands = commands
+
+    def __log(self, message: str, level: LogLevel | None = None, *args):
+        """以指定的日志级别输出日志。
+
+        :param message: 要输出的日志信息。
+        :param level: 要使用的日志级别。可以是 'info', 'debug', 'verbose', 'silent' 中的一个，或者是 None。
+                       如果为 None，则使用实例的 `log_level` 属性。
+        """
+        effective_level = level if level is not None else self.log_level
+
+        if effective_level == 'info':
+            logger.info(message, *args)
+        elif effective_level == 'debug':
+            logger.debug(message, *args)
+        elif effective_level == 'verbose':
+            logger.verbose(message, *args)
+        elif effective_level == 'silent':
+            pass # Do nothing
 
     @overload
-    def click(self) -> None:
+    def click(self, *, log: "LogLevel | None" = None) -> None:
         """
         点击上次 `image` 对象或 `ocr` 对象的寻找结果（仅包括返回单个结果的函数）。
         （不包括 `image.raw()` 和 `ocr.raw()` 的结果。）
@@ -145,73 +111,76 @@ class Device:
         ...
 
     @overload
-    def click(self, x: int, y: int) -> None:
+    def click(self, x: int, y: int, *, log: "LogLevel | None" = None) -> None:
         """
         点击屏幕上的某个点
         """
         ...
 
     @overload
-    def click(self, point: Point) -> None:
+    def click(self, point: Point, *, log: "LogLevel | None" = None) -> None:
         """
         点击屏幕上的某个点
         """
         ...
     
     @overload
-    def click(self, rect: Rect) -> None:
+    def click(self, rect: Rect, *, log: "LogLevel | None" = None) -> None:
         """
         从屏幕上的某个矩形区域随机选择一个点并点击
         """
         ...
 
     @overload
-    def click(self, clickable: ClickableObjectProtocol) -> None:
+    def click(self, clickable: ClickableObjectProtocol, *, log: "LogLevel | None" = None) -> None:
         """
         点击屏幕上的某个可点击对象
         """
         ...
 
     def click(self, *args, **kwargs) -> None:
+        log: LogLevel | None = kwargs.pop('log', None)
         arg1 = args[0] if len(args) > 0 else None
         arg2 = args[1] if len(args) > 1 else None
         if arg1 is None:
-            self.__click_last()
+            self.__click_last(log=log)
         elif isinstance(arg1, Rect):
-            self.__click_rect(arg1)
+            self.__click_rect(arg1, log=log)
         elif is_point(arg1):
-            self.__click_point_tuple(arg1)
+            self.__click_point_tuple(arg1, log=log)
         elif isinstance(arg1, int) and isinstance(arg2, int):
-            self.__click_point(arg1, arg2)
+            self.__click_point(arg1, arg2, log=log)
         elif isinstance(arg1, ClickableObjectProtocol):
-            self.__click_clickable(arg1)
+            self.__click_clickable(arg1, log=log)
         else:
             raise ValueError(f"Invalid arguments: {arg1}, {arg2}")
 
-    def __click_last(self) -> None:
+    def __click_last(self, *, log: "LogLevel | None" = None) -> None:
         if self.last_find is None:
             raise ValueError("No last find result. Make sure you are not calling the 'raw' functions.")
-        self.click(self.last_find)
+        self.click(self.last_find, log=log)
 
-    def __click_rect(self, rect: Rect) -> None:
+    def __click_rect(self, rect: Rect, *, log: "LogLevel | None" = None) -> None:
         # 从矩形中心的 60% 内部随机选择一点
         x = rect.x1 + rect.w // 2 + np.random.randint(-int(rect.w * 0.3), int(rect.w * 0.3))
         y = rect.y1 + rect.h // 2 + np.random.randint(-int(rect.h * 0.3), int(rect.h * 0.3))
         x = int(x)
         y = int(y)
-        self.click(x, y)
+        self.click(x, y, log=log)
 
-    def __click_point(self, x: int, y: int) -> None:
+    def __click_point(self, x: int, y: int, *, log: "LogLevel | None" = None) -> None:
         for hook in self.click_hooks_before:
             logger.debug(f"Executing click hook before: ({x}, {y})")
             x, y = hook(x, y)
             logger.debug(f"Click hook before result: ({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 "")
+        
+        real_pos = self.scaler.logic_to_physical((x, y))
+        real_x, real_y = int(real_pos[0]), int(real_pos[1])
+        
+        log_message = f"Click: {x}, {y}%s"
+        log_details = f"(Physical: {real_x}, {real_y})"
+        self.__log(log_message, log, log_details)
+
         from ..backend.context import ContextStackVars
         if ContextStackVars.current() is not None:
             image = ContextStackVars.ensure_current()._screenshot
@@ -220,18 +189,17 @@ class Device:
         if image is not None and image.size > 0:
             cv2.circle(image, (x, y), 10, (0, 0, 255), -1)
             message = f"Point: ({x}, {y})"
-            if self.target_resolution is not None:
-                message += f" physical: ({real_x}, {real_y})"
+            message += f" physical: ({real_x}, {real_y})"
             result("device.click", image, message)
         self._touch.click(real_x, real_y)
 
-    def __click_point_tuple(self, point: Point) -> None:
-        self.click(point[0], point[1])
+    def __click_point_tuple(self, point: Point, *, log: "LogLevel | None" = None) -> None:
+        self.click(point[0], point[1], log=log)
 
-    def __click_clickable(self, clickable: ClickableObjectProtocol) -> None:
-        self.click(clickable.rect)
+    def __click_clickable(self, clickable: ClickableObjectProtocol, *, log: "LogLevel | None" = None) -> None:
+        self.click(clickable.rect, log=log)
 
-    def click_center(self) -> None:
+    def click_center(self, *, log: "LogLevel | None" = None) -> None:
         """
         点击屏幕中心。
         
@@ -239,26 +207,26 @@ class Device:
         调用前确保 `orientation` 属性与设备方向一致，
         否则点击位置会不正确。
         """
-        size = self.target_resolution or self.screen_size
+        size = self.scaler.physical_to_logic(self.screen_size)
         x, y = size[0] // 2, size[1] // 2
-        self.click(x, y)
+        self.click(x, y, log=log)
     
     @overload
-    def double_click(self, x: int, y: int, interval: float = 0.4) -> None:
+    def double_click(self, x: int, y: int, interval: float = 0.4, *, log: "LogLevel | None" = None) -> None:
         """
         双击屏幕上的某个点
         """
         ...
 
     @overload
-    def double_click(self, rect: Rect, interval: float = 0.4) -> None:
+    def double_click(self, rect: Rect, interval: float = 0.4, *, log: "LogLevel | None" = None) -> None:
         """
         双击屏幕上的某个矩形区域
         """
         ...
     
     @overload
-    def double_click(self, clickable: ClickableObjectProtocol, interval: float = 0.4) -> None:
+    def double_click(self, clickable: ClickableObjectProtocol, interval: float = 0.4, *, log: "LogLevel | None" = None) -> None:
         """
         双击屏幕上的某个可点击对象
         """
@@ -267,31 +235,36 @@ class Device:
     def double_click(self, *args, **kwargs) -> None:
         from kotonebot import sleep
         arg0 = args[0]
+        log = kwargs.get('log', None)
         if isinstance(arg0, Rect) or isinstance(arg0, ClickableObjectProtocol):
             rect = arg0
             interval = kwargs.get('interval', 0.4)
-            self.click(rect)
+            self.click(rect, log=log)
             sleep(interval)
-            self.click(rect)
+            self.click(rect, log=log)
         else:
             x = args[0]
             y = args[1]
             interval = kwargs.get('interval', 0.4)
-            self.click(x, y)
+            self.click(x, y, log=log)
             sleep(interval)
-            self.click(x, y)
+            self.click(x, y, log=log)
 
-    def swipe(self, x1: int, y1: int, x2: int, y2: int, duration: float|None = None) -> None:
+    def swipe(self, x1: int, y1: int, x2: int, y2: int, duration: float|None = None, *, log: "LogLevel | None" = None) -> None:
         """
         滑动屏幕
         """
-        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)
+        real_pos1 = self.scaler.logic_to_physical((x1, y1))
+        real_x1, real_y1 = int(real_pos1[0]), int(real_pos1[1])
+        real_pos2 = self.scaler.logic_to_physical((x2, y2))
+        real_x2, real_y2 = int(real_pos2[0]), int(real_pos2[1])
+        log_message = f"Swipe: from ({x1}, {y1}) to ({x2}, {y2}) (Physical: from ({real_x1}, {real_y1}) to ({real_x2}, {real_y2}))"
+
+        self.__log(log_message, log)
+
+        self._touch.swipe(real_x1, real_y1, real_x2, real_y2, duration)
 
-    def swipe_scaled(self, x1: float, y1: float, x2: float, y2: float, duration: float|None = None) -> None:
+    def swipe_scaled(self, x1: float, y1: float, x2: float, y2: float, duration: float|None = None, *, log: "LogLevel | None" = None) -> None:
         """
         滑动屏幕，参数为屏幕坐标的百分比。
 
@@ -304,8 +277,8 @@ class Device:
         :param y2: 结束点 y 坐标百分比。范围 [0, 1]
         :param duration: 滑动持续时间，单位秒。None 表示使用默认值。
         """
-        w, h = self.target_resolution or self.screen_size
-        self.swipe(int(w * x1), int(h * y1), int(w * x2), int(h * y2), duration)
+        w, h = self.scaler.physical_to_logic(self.screen_size)
+        self.swipe(int(w * x1), int(h * y1), int(w * x2), int(h * y2), duration, log=log)
     
     def screenshot(self) -> MatLike:
         """
@@ -318,7 +291,7 @@ class Device:
                 logger.debug("screenshot hook before returned image")
                 return img
         img = self.screenshot_raw()
-        img = self.__scale_image(img)
+        img = self.scaler.transform_screenshot(img)
         if self.screenshot_hook_after is not None:
             img = self.screenshot_hook_after(img)
         return img
@@ -365,73 +338,11 @@ 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:
+    def __init__(self, adb_connection: 'AdbUtilsDevice | None' = None) -> None:
         super().__init__('android')
-        self._adb: AdbUtilsDevice | None = adb_connection
+        self._adb: 'AdbUtilsDevice | None' = adb_connection
         self.commands: AndroidCommandable
         
     def current_package(self) -> str | None:
@@ -455,50 +366,4 @@ class AndroidDevice(Device):
 class WindowsDevice(Device):
     def __init__(self) -> None:
         super().__init__('windows')
-        self.commands: WindowsCommandable
-
-        
-if __name__ == "__main__":
-    from kotonebot.client.implements.adb import AdbImpl
-    from kotonebot.client.implements.adb_raw import AdbRawImpl
-    from .implements.uiautomator2 import UiAutomator2Impl
-    print("server version:", adb.server_version())
-    adb.connect("127.0.0.1:5555")
-    print("devices:", adb.device_list())
-    d = adb.device_list()[-1]
-    d.shell("dumpsys activity top | grep ACTIVITY | tail -n 1")
-    dd = AndroidDevice(d)
-    adb_imp = AdbRawImpl(d)
-    dd._touch = adb_imp
-    dd._screenshot = adb_imp
-    dd.commands = adb_imp
-    # dd._screenshot = MinicapScreenshotImpl(dd)
-    # dd._screenshot = UiAutomator2Impl(dd)
-
-    # 实时展示画面
-    import cv2
-    import numpy as np
-    import time
-    last_time = time.time()
-    while True:
-        start_time = time.time()
-        img = dd.screenshot()
-        # 50% 缩放
-        img = cv2.resize(img, (img.shape[1] // 2, img.shape[0] // 2))
-        
-        # 计算帧间隔
-        interval = start_time - last_time
-        fps = 1 / interval if interval > 0 else 0
-        last_time = start_time
-        
-        # 获取当前时间和帧率信息
-        current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
-        fps_text = f"FPS: {fps:.1f} {interval*1000:.1f}ms"
-        
-        # 在图像上绘制信息
-        font = cv2.FONT_HERSHEY_SIMPLEX
-        cv2.putText(img, current_time, (10, 30), font, 0.5, (0, 0, 255), 1, cv2.LINE_AA)
-        cv2.putText(img, fps_text, (10, 60), font, 0.5, (0, 0, 255), 1, cv2.LINE_AA)
-        
-        cv2.imshow("screen", img)
-        cv2.waitKey(1)
+        self.commands: WindowsCommandable

kotonebot/client/host/__init__.py

@@ -1,7 +1,38 @@
+from typing import TYPE_CHECKING
+
 from .protocol import HostProtocol, Instance, AdbHostConfig, WindowsHostConfig, RemoteWindowsHostConfig
-from .custom import CustomInstance, create as create_custom
-from .mumu12_host import Mumu12Host, Mumu12Instance, Mumu12V5Host, Mumu12V5Instance
-from .leidian_host import LeidianHost, LeidianInstance
+if TYPE_CHECKING:
+    from .custom import CustomInstance, create as create_custom
+    from .mumu12_host import Mumu12Host, Mumu12Instance, Mumu12V5Host, Mumu12V5Instance
+    from .leidian_host import LeidianHost, LeidianInstance
+
+def _require_custom():
+    global CustomInstance, create_custom
+    from .custom import CustomInstance, create as create_custom
+    
+def _require_mumu12():
+    global Mumu12Host, Mumu12Instance, Mumu12V5Host, Mumu12V5Instance
+    from .mumu12_host import Mumu12Host, Mumu12Instance, Mumu12V5Host, Mumu12V5Instance
+    
+def _require_leidian():
+    global LeidianHost, LeidianInstance
+    from .leidian_host import LeidianHost, LeidianInstance
+
+_IMPORT_NAMES = [
+    (_require_custom, ['CustomInstance', 'create_custom']),
+    (_require_mumu12, ['Mumu12Host', 'Mumu12Instance', 'Mumu12V5Host', 'Mumu12V5Instance']),
+    (_require_leidian, ['LeidianHost', 'LeidianInstance']),
+]
+
+def __getattr__(name: str):
+    for item in _IMPORT_NAMES:
+        if name in item[1]:
+            item[0]()
+            break
+    try:
+        return globals()[name]
+    except KeyError:
+        raise AttributeError(name=name)
 
 __all__ = [
     'HostProtocol', 'Instance',

kotonebot/client/host/adb_common.py

@@ -2,14 +2,18 @@ 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
+try:
+    from adbutils import adb
+    from adbutils._device import AdbDevice
+except ImportError as _e:
+    from kotonebot.errors import MissingDependencyError
+    raise MissingDependencyError(_e, 'android')
 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']
+AdbRecipes = Literal['adb', 'uiautomator2']
 
 def is_adb_recipe(recipe: Any) -> TypeGuard[AdbRecipes]:
     return recipe in get_args(AdbRecipes)
@@ -85,12 +89,6 @@ class CommonAdbCreateDeviceMixin(ABC):
                 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

kotonebot/client/host/custom.py

@@ -1,6 +1,10 @@
 import os
 import subprocess
-from psutil import process_iter
+try:
+    from psutil import process_iter
+except ImportError as _e:
+    from kotonebot.errors import MissingDependencyError
+    raise MissingDependencyError(_e, 'windows')
 from .protocol import Instance, AdbHostConfig, HostProtocol
 from typing import ParamSpec, TypeVar
 from typing_extensions import override
@@ -104,7 +108,7 @@ class CustomHost(HostProtocol[CustomRecipes]):
 
     @staticmethod
     def recipes() -> 'list[CustomRecipes]':
-        return ['adb', 'adb_raw', 'uiautomator2']
+        return ['adb', '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

@@ -9,16 +9,11 @@ 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
+from ...interop.win.reg import read_reg
 
 logger = logging.getLogger(__name__)
 LeidianRecipes = AdbRecipes
 
-if os.name == 'nt':
-    from ...interop.win.reg import read_reg
-else:
-    def read_reg(key, subkey, name, *, default=None, **kwargs):
-        """Stub for read_reg on non-Windows platforms."""
-        return default
 
 class LeidianInstance(CommonAdbCreateDeviceMixin, Instance[AdbHostConfig]):
     @copy_type(Instance.__init__)
@@ -186,7 +181,7 @@ class LeidianHost(HostProtocol[LeidianRecipes]):
 
     @staticmethod
     def recipes() -> 'list[LeidianRecipes]':
-        return ['adb', 'adb_raw', 'uiautomator2']
+        return ['adb', 'uiautomator2']
 
 if __name__ == '__main__':
     logging.basicConfig(level=logging.DEBUG, format='[%(asctime)s] [%(levelname)s] [%(name)s] [%(funcName)s] [%(lineno)d] %(message)s')

kotonebot/client/host/mumu12_host.py

@@ -14,13 +14,8 @@ from kotonebot.client.implements.nemu_ipc import NemuIpcImpl, NemuIpcImplConfig
 from kotonebot.util import Countdown, Interval
 from .protocol import HostProtocol, Instance, copy_type, AdbHostConfig
 from .adb_common import AdbRecipes, CommonAdbCreateDeviceMixin, connect_adb, is_adb_recipe
+from ...interop.win.reg import read_reg
 
-if os.name == 'nt':
-    from ...interop.win.reg import read_reg
-else:
-    def read_reg(key, subkey, name, *, default=None, **kwargs):
-        """Stub for read_reg on non-Windows platforms."""
-        return default
 
 # Forward declarations for type hints
 if TYPE_CHECKING:
@@ -145,7 +140,7 @@ class Mumu12Host(HostProtocol[MuMu12Recipes]):
 
     @staticmethod
     def recipes() -> 'list[MuMu12Recipes]':
-        return ['adb', 'adb_raw', 'uiautomator2', 'nemu_ipc']
+        return ['adb', 'uiautomator2', 'nemu_ipc']
 
 class Mumu12Instance(CommonAdbCreateDeviceMixin, Instance[MuMu12HostConfig]):
     HostClass: 'type[Mumu12Host]' = Mumu12Host