PyClickerRPA 0.9.0__tar.gz → 0.11.0__tar.gz

{pyclickerrpa-0.9.0 → pyclickerrpa-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyClickerRPA
-Version: 0.9.0
+Version: 0.11.0
 Summary: Visual UI automation & testing tool: Windows + Android(ADB) automation, robust/self-healing image matching, OCR, structured conditions and loops with array iteration, node flow editor, smart recorder, task health checks and failure attribution, a visual test framework (assertions, visual regression, HTML/JUnit reports) and a web console.
 Author: Equinox
 License-Expression: MIT
@@ -89,6 +89,39 @@ autoclicker-web --suites-dir examples          # web console at http://127.0.0.1
   activate-window, HTTP request, run-Python-script, call sub-task, groups, and a
   **stop** step to end a run — with retry / repeat / until policies.
 
+### Black-box automation runtime
+
+- **Recognition-driven dispatch** (MAA-style): a step's `next` list is scanned
+  in order and the first candidate whose recognition gate hits is executed.
+  Set `next_timeout_ms` (>0, or -1 for unbounded) with `rate_limit_ms` to wait
+  and rescan instead of failing immediately — `next_timeout_ms: 0` (default)
+  keeps the classic single-pass behavior.
+- **Resource bundles**: `Task.resource_paths` lists bundle root directories;
+  template names that aren't real paths resolve as `<root>/image/<name>` with
+  later roots overriding earlier ones (overlay). `Task.load_bundle(dir)`
+  assembles a task from `interface.json` (`resource` roots + `pipeline` entry)
+  or a plain `task.json`. Hot reload rides the signature-checked template cache.
+- **Configurable capture/input channels**: controllers accept
+  `screencap_method` / `input_method`. Win32: `gdi_bitblt` (default),
+  `printwindow`, input `sendinput` (default) or `postmessage` (background,
+  needs a window handle; continuous gestures unsupported). ADB: `screencap`
+  (default) or `raw_gzip` (device-side gzip, steadier on slow links), input
+  `adb_input`. `minicap` / `minitouch` / `maatouch` / `desktop_dup` are
+  registered placeholders that fall back to the default with a
+  `strategy_fallback` warning — they require extra device components that are
+  not bundled (real-device behavior unverified).
+- **Target resolution** (MAA-style): an action's `target` param can be a fixed
+  region `[x, y, w, h]` (clicks its center) or a **node name** — it then clicks
+  the center of that node's latest recognition box, enabling "recognize A, then
+  click next to A". `target: true` / absent keeps the step's own targeting.
+- **Post-action freeze wait**: `post_wait_freezes: {time, target}` on any action
+  waits until the watched region stops changing before moving on — the standard
+  remedy for loading screens and animations. Unlike a standalone `wait_stable`
+  step it never fails the run; it waits up to `time` and proceeds.
+- **Human-like jitter**: click coordinates are sampled from a truncated Gaussian
+  (sigma = `randomOffset`/2, clamped to the bound) instead of a uniform spread,
+  which looks more like a real hand and is friendlier to anti-automation checks.
+
 ## Authoring (desktop GUI)
 
 Drag-and-drop **node flow graph** and an interoperable **step list**, with

{pyclickerrpa-0.9.0 → pyclickerrpa-0.11.0}/PyClickerRPA.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyClickerRPA
-Version: 0.9.0
+Version: 0.11.0
 Summary: Visual UI automation & testing tool: Windows + Android(ADB) automation, robust/self-healing image matching, OCR, structured conditions and loops with array iteration, node flow editor, smart recorder, task health checks and failure attribution, a visual test framework (assertions, visual regression, HTML/JUnit reports) and a web console.
 Author: Equinox
 License-Expression: MIT
@@ -89,6 +89,39 @@ autoclicker-web --suites-dir examples          # web console at http://127.0.0.1
   activate-window, HTTP request, run-Python-script, call sub-task, groups, and a
   **stop** step to end a run — with retry / repeat / until policies.
 
+### Black-box automation runtime
+
+- **Recognition-driven dispatch** (MAA-style): a step's `next` list is scanned
+  in order and the first candidate whose recognition gate hits is executed.
+  Set `next_timeout_ms` (>0, or -1 for unbounded) with `rate_limit_ms` to wait
+  and rescan instead of failing immediately — `next_timeout_ms: 0` (default)
+  keeps the classic single-pass behavior.
+- **Resource bundles**: `Task.resource_paths` lists bundle root directories;
+  template names that aren't real paths resolve as `<root>/image/<name>` with
+  later roots overriding earlier ones (overlay). `Task.load_bundle(dir)`
+  assembles a task from `interface.json` (`resource` roots + `pipeline` entry)
+  or a plain `task.json`. Hot reload rides the signature-checked template cache.
+- **Configurable capture/input channels**: controllers accept
+  `screencap_method` / `input_method`. Win32: `gdi_bitblt` (default),
+  `printwindow`, input `sendinput` (default) or `postmessage` (background,
+  needs a window handle; continuous gestures unsupported). ADB: `screencap`
+  (default) or `raw_gzip` (device-side gzip, steadier on slow links), input
+  `adb_input`. `minicap` / `minitouch` / `maatouch` / `desktop_dup` are
+  registered placeholders that fall back to the default with a
+  `strategy_fallback` warning — they require extra device components that are
+  not bundled (real-device behavior unverified).
+- **Target resolution** (MAA-style): an action's `target` param can be a fixed
+  region `[x, y, w, h]` (clicks its center) or a **node name** — it then clicks
+  the center of that node's latest recognition box, enabling "recognize A, then
+  click next to A". `target: true` / absent keeps the step's own targeting.
+- **Post-action freeze wait**: `post_wait_freezes: {time, target}` on any action
+  waits until the watched region stops changing before moving on — the standard
+  remedy for loading screens and animations. Unlike a standalone `wait_stable`
+  step it never fails the run; it waits up to `time` and proceeds.
+- **Human-like jitter**: click coordinates are sampled from a truncated Gaussian
+  (sigma = `randomOffset`/2, clamped to the bound) instead of a uniform spread,
+  which looks more like a real hand and is friendlier to anti-automation checks.
+
 ## Authoring (desktop GUI)
 
 Drag-and-drop **node flow graph** and an interoperable **step list**, with

{pyclickerrpa-0.9.0 → pyclickerrpa-0.11.0}/PyClickerRPA.egg-info/SOURCES.txt

@@ -71,6 +71,7 @@ autoclicker/web/static/index.html
 autoclicker/web/static/style.css
 tests/test_actions.py
 tests/test_adb.py
+tests/test_controller_strategies.py
 tests/test_diagnose.py
 tests/test_diagnose_gui.py
 tests/test_engine_integration.py
@@ -81,10 +82,13 @@ tests/test_listener_lifecycle.py
 tests/test_matcher.py
 tests/test_migrations.py
 tests/test_models.py
+tests/test_p1_blackbox.py
 tests/test_phase4_integration.py
 tests/test_platform_recognition.py
 tests/test_queue_entrypoints.py
+tests/test_recognition_dispatch.py
 tests/test_recorder_gui.py
+tests/test_resource_bundle.py
 tests/test_runner.py
 tests/test_sandbox.py
 tests/test_structured_flow.py

{pyclickerrpa-0.9.0 → pyclickerrpa-0.11.0}/README.md

@@ -51,6 +51,39 @@ autoclicker-web --suites-dir examples          # web console at http://127.0.0.1
   activate-window, HTTP request, run-Python-script, call sub-task, groups, and a
   **stop** step to end a run — with retry / repeat / until policies.
 
+### Black-box automation runtime
+
+- **Recognition-driven dispatch** (MAA-style): a step's `next` list is scanned
+  in order and the first candidate whose recognition gate hits is executed.
+  Set `next_timeout_ms` (>0, or -1 for unbounded) with `rate_limit_ms` to wait
+  and rescan instead of failing immediately — `next_timeout_ms: 0` (default)
+  keeps the classic single-pass behavior.
+- **Resource bundles**: `Task.resource_paths` lists bundle root directories;
+  template names that aren't real paths resolve as `<root>/image/<name>` with
+  later roots overriding earlier ones (overlay). `Task.load_bundle(dir)`
+  assembles a task from `interface.json` (`resource` roots + `pipeline` entry)
+  or a plain `task.json`. Hot reload rides the signature-checked template cache.
+- **Configurable capture/input channels**: controllers accept
+  `screencap_method` / `input_method`. Win32: `gdi_bitblt` (default),
+  `printwindow`, input `sendinput` (default) or `postmessage` (background,
+  needs a window handle; continuous gestures unsupported). ADB: `screencap`
+  (default) or `raw_gzip` (device-side gzip, steadier on slow links), input
+  `adb_input`. `minicap` / `minitouch` / `maatouch` / `desktop_dup` are
+  registered placeholders that fall back to the default with a
+  `strategy_fallback` warning — they require extra device components that are
+  not bundled (real-device behavior unverified).
+- **Target resolution** (MAA-style): an action's `target` param can be a fixed
+  region `[x, y, w, h]` (clicks its center) or a **node name** — it then clicks
+  the center of that node's latest recognition box, enabling "recognize A, then
+  click next to A". `target: true` / absent keeps the step's own targeting.
+- **Post-action freeze wait**: `post_wait_freezes: {time, target}` on any action
+  waits until the watched region stops changing before moving on — the standard
+  remedy for loading screens and animations. Unlike a standalone `wait_stable`
+  step it never fails the run; it waits up to `time` and proceeds.
+- **Human-like jitter**: click coordinates are sampled from a truncated Gaussian
+  (sigma = `randomOffset`/2, clamped to the bound) instead of a uniform spread,
+  which looks more like a real hand and is friendlier to anti-automation checks.
+
 ## Authoring (desktop GUI)
 
 Drag-and-drop **node flow graph** and an interoperable **step list**, with

{pyclickerrpa-0.9.0 → pyclickerrpa-0.11.0}/autoclicker/actions.py

@@ -100,6 +100,11 @@ def exec_click_position(ctx: ExecutionContext, step: Step) -> StepResult:
     if step.varName == "use_var":
         cx = int(ctx.vars.get("last_x", "0"))
         cy = int(ctx.vars.get("last_y", "0"))
+    # P1-4: an explicit target (fixed region or another node's recognition box)
+    # overrides the literal coordinates.
+    override = ctx.runner._resolve_target(step)
+    if override is not None:
+        cx, cy = override
     cx = ctx.runner._rand_offset(cx, step.randomOffset)
     cy = ctx.runner._rand_offset(cy, step.randomOffset)
     ctx.log(f"  点击 ({cx}, {cy})")

{pyclickerrpa-0.9.0 → pyclickerrpa-0.11.0}/autoclicker/adb.py

@@ -83,6 +83,23 @@ class AdbDevice:
             raise RuntimeError("screencap 解码失败（设备可能不支持 exec-out）")
         return img
 
+    def screencap_gzip(self) -> np.ndarray:
+        """RPA-25: 设备端 gzip 压缩后再传回的截图（慢链路设备更稳）。
+
+        需要设备 shell 提供 gzip（Android toybox 自带）。
+        """
+        import cv2
+        import gzip
+        raw = self._run(["exec-out", "sh", "-c", "screencap -p | gzip -1"])
+        try:
+            png = gzip.decompress(raw)
+        except OSError as exc:
+            raise RuntimeError(f"screencap(gzip) 解压失败: {exc}") from exc
+        img = cv2.imdecode(np.frombuffer(png, dtype=np.uint8), cv2.IMREAD_COLOR)
+        if img is None or img.size == 0:
+            raise RuntimeError("screencap(gzip) 解码失败")
+        return img
+
     # ---- input ----
     def tap(self, x: int, y: int) -> None:
         self._run(["shell", "input", "tap", str(int(x)), str(int(y))])
@@ -121,15 +138,30 @@ class AdbDevice:
 
 
 class AdbCapture:
-    """capture 后端：忽略 hwnd，一律截设备屏。"""
-    def __init__(self, device: AdbDevice):
+    """capture 后端：忽略 hwnd，一律截设备屏。
+
+    RPA-25: ``screencap_method`` 选择截图通道 —— ``"screencap"``（默认，
+    exec-out 直传 PNG）或 ``"raw_gzip"``（设备端 gzip 压缩后传回，慢链路更稳）。
+    """
+
+    METHODS = ("screencap", "raw_gzip")
+
+    def __init__(self, device: AdbDevice, screencap_method: str = "screencap"):
+        if screencap_method not in self.METHODS:
+            raise ValueError(f"未知截图方法: {screencap_method}，可选 {self.METHODS}")
         self.device = device
+        self.screencap_method = screencap_method
 
-    def capture_screen(self) -> np.ndarray:
+    def _screencap(self) -> np.ndarray:
+        if self.screencap_method == "raw_gzip":
+            return self.device.screencap_gzip()
         return self.device.screencap()
 
+    def capture_screen(self) -> np.ndarray:
+        return self._screencap()
+
     def capture_window(self, hwnd) -> np.ndarray:
-        return self.device.screencap()
+        return self._screencap()
 
 
 class AdbClicker:

{pyclickerrpa-0.9.0 → pyclickerrpa-0.11.0}/autoclicker/clicker.py

@@ -52,6 +52,9 @@ def _api():
         _user32 = loader("user32", use_last_error=True)
         _user32.SendInput.argtypes = (wintypes.UINT, ctypes.POINTER(_INPUT), ctypes.c_int)
         _user32.SendInput.restype = wintypes.UINT
+        _user32.PostMessageW.argtypes = (wintypes.HWND, wintypes.UINT,
+                                         wintypes.WPARAM, wintypes.LPARAM)
+        _user32.PostMessageW.restype = wintypes.BOOL
     return _user32
 
 
@@ -250,6 +253,85 @@ class Clicker:
             self.key_press(vk)
 
 
+# ---- RPA-25: PostMessage background input (window-message based) ----
+WM_LBUTTONDOWN, WM_LBUTTONUP = 0x0201, 0x0202
+WM_RBUTTONDOWN, WM_RBUTTONUP = 0x0204, 0x0205
+WM_MOUSEWHEEL = 0x020A
+WM_KEYDOWN, WM_KEYUP, WM_CHAR = 0x0100, 0x0101, 0x0102
+MK_LBUTTON = 0x0001
+
+
+def _lparam(x: int, y: int) -> int:
+    return (int(y) & 0xFFFF) << 16 | (int(x) & 0xFFFF)
+
+
+class PostMessageClicker:
+    """RPA-25: background input via PostMessage to a target HWND.
+
+    Unlike SendInput, this does not steal focus and works on unfocused windows,
+    but it requires a valid window handle and only supports discrete messages —
+    continuous gestures (swipe/drag/pinch) are not expressible and raise.
+    """
+
+    def _post(self, hwnd, msg, wparam, lparam) -> None:
+        if not hwnd:
+            raise NotImplementedError("postmessage 输入需要目标窗口句柄 (hwnd)")
+        api = _api()
+        if not api.PostMessageW(hwnd, msg, wparam, lparam):
+            raise OSError(f"PostMessage 失败: msg=0x{msg:04X} hwnd={hwnd}")
+
+    # ---- mouse ----
+    def click(self, hwnd, x: int, y: int) -> None:
+        lp = _lparam(x, y)
+        self._post(hwnd, WM_LBUTTONDOWN, MK_LBUTTON, lp)
+        self._post(hwnd, WM_LBUTTONUP, 0, lp)
+
+    def double_click(self, hwnd, x: int, y: int) -> None:
+        self.click(hwnd, x, y)
+        time.sleep(0.05)
+        self.click(hwnd, x, y)
+
+    def right_click(self, hwnd, x: int, y: int) -> None:
+        lp = _lparam(x, y)
+        self._post(hwnd, WM_RBUTTONDOWN, 0, lp)
+        self._post(hwnd, WM_RBUTTONUP, 0, lp)
+
+    def long_press(self, hwnd, x: int, y: int, hold_ms: int) -> None:
+        lp = _lparam(x, y)
+        self._post(hwnd, WM_LBUTTONDOWN, MK_LBUTTON, lp)
+        time.sleep(hold_ms / 1000.0)
+        self._post(hwnd, WM_LBUTTONUP, 0, lp)
+
+    def scroll(self, hwnd, x, y, amount: int) -> None:
+        lp = _lparam(x, y)
+        self._post(hwnd, WM_MOUSEWHEEL, (amount * WHEEL_DELTA & 0xFFFF) << 16, lp)
+
+    def swipe(self, hwnd, x1, y1, x2, y2, duration_ms: int = 500) -> None:
+        raise NotImplementedError("postmessage 不支持连续滑动，请改用 sendinput")
+
+    def drag(self, hwnd, x1, y1, x2, y2, duration_ms: int = 300) -> None:
+        raise NotImplementedError("postmessage 不支持拖拽，请改用 sendinput")
+
+    def pinch(self, hwnd, cx, cy, start_dist, end_dist, duration_ms: int = 400) -> None:
+        raise NotImplementedError("postmessage 不支持双指缩放，请改用 sendinput")
+
+    # ---- keyboard ----
+    def key_down(self, vk: int) -> None:
+        raise NotImplementedError("postmessage 键盘输入需要目标窗口，请用 key_press/type_text")
+
+    def key_up(self, vk: int) -> None:
+        raise NotImplementedError("postmessage 键盘输入需要目标窗口，请用 key_press/type_text")
+
+    def key_press(self, vk: int) -> None:
+        raise NotImplementedError("postmessage 按键请通过 type_text 或指定 hwnd 的窗口消息")
+
+    def type_text(self, text: str) -> None:
+        raise NotImplementedError("postmessage 文本输入需要目标窗口句柄，请改用 sendinput")
+
+    def hotkey(self, modifier: int, vk: int) -> None:
+        raise NotImplementedError("postmessage 不支持组合键，请改用 sendinput")
+
+
 # ---- vk parsing (port of Clicker::parseVkCode) --------------------------------
 _NAMED_VK = {
     "ENTER": 0x0D, "RETURN": 0x0D, "ESC": 0x1B, "ESCAPE": 0x1B, "TAB": 0x09,

{pyclickerrpa-0.9.0 → pyclickerrpa-0.11.0}/autoclicker/controllers.py

@@ -85,6 +85,74 @@ class ControllerStopped(RuntimeError):
     """A controller lease was cancelled before execution."""
 
 
+class StrategyUnavailable(RuntimeError):
+    """RPA-25: a capture/input strategy needs components that are not present.
+
+    Placeholders (minicap/minitouch/maatouch/desktop_dup) raise this so an
+    explicit opt-in never masquerades as working; controllers fall back to
+    their default strategy and record a warning.
+    """
+
+
+# RPA-25: configurable capture/input channels, registered like recognizers.
+# Names are disjoint per platform by convention (see ADB_*/WIN32_* tuples).
+ADB_SCREENCAP = ("screencap", "raw_gzip", "minicap")
+ADB_INPUT = ("adb_input", "minitouch", "maatouch")
+WIN32_SCREENCAP = ("gdi_bitblt", "printwindow", "desktop_dup")
+WIN32_INPUT = ("sendinput", "postmessage")
+
+_CAPTURE_STRATEGIES: dict[str, Callable] = {}
+_INPUT_STRATEGIES: dict[str, Callable] = {}
+
+
+def _register(registry: dict, name: str, *, replace: bool):
+    if not isinstance(name, str) or not name.strip():
+        raise ValueError("strategy name must be non-empty")
+
+    def decorator(factory):
+        if not callable(factory):
+            raise TypeError("strategy factory must be callable")
+        if name in registry and not replace:
+            raise ValueError(f"Strategy already registered: {name}")
+        registry[name] = factory
+        return factory
+    return decorator
+
+
+def register_capture_strategy(name: str, *, replace: bool = False):
+    """Register ``factory(controller) -> capture backend``."""
+    return _register(_CAPTURE_STRATEGIES, name, replace=replace)
+
+
+def register_input_strategy(name: str, *, replace: bool = False):
+    """Register ``factory(controller) -> click/keyboard backend``."""
+    return _register(_INPUT_STRATEGIES, name, replace=replace)
+
+
+def get_capture_strategy(name: str) -> Callable:
+    try:
+        return _CAPTURE_STRATEGIES[name]
+    except KeyError:
+        raise KeyError(f"Unknown capture strategy: {name!r}; "
+                       f"available: {sorted(_CAPTURE_STRATEGIES)}") from None
+
+
+def get_input_strategy(name: str) -> Callable:
+    try:
+        return _INPUT_STRATEGIES[name]
+    except KeyError:
+        raise KeyError(f"Unknown input strategy: {name!r}; "
+                       f"available: {sorted(_INPUT_STRATEGIES)}") from None
+
+
+def registered_capture_strategies() -> list[str]:
+    return sorted(_CAPTURE_STRATEGIES)
+
+
+def registered_input_strategies() -> list[str]:
+    return sorted(_INPUT_STRATEGIES)
+
+
 _lease_condition = Condition(RLock())
 _lease_locks = WeakValueDictionary()
 _lease_owners = {}
@@ -177,6 +245,30 @@ class _LegacyController:
         self._watch_thread = None
         self._watch_stop = None
         self._active_backends = []
+        # RPA-25: fallback records when a requested strategy is unavailable.
+        self.strategy_warnings: list[dict] = []
+
+    def _resolve_strategy(self, kind: str, requested: str, default: str):
+        """Build a backend through the strategy registry (RPA-25).
+
+        Unknown names are errors (never silent misses). A placeholder raising
+        StrategyUnavailable falls back to the platform default and records a
+        warning, so an explicit opt-in never masquerades as working.
+        """
+        registry = _CAPTURE_STRATEGIES if kind == "screencap" else _INPUT_STRATEGIES
+        try:
+            factory = registry[requested]
+        except KeyError:
+            raise KeyError(f"Unknown {kind} strategy: {requested!r}; "
+                           f"available: {sorted(registry)}") from None
+        try:
+            return factory(self)
+        except StrategyUnavailable as exc:
+            entry = {"kind": kind, "requested": requested,
+                     "fallback": default, "reason": str(exc)}
+            self.strategy_warnings.append(entry)
+            self.notify_change(source="strategy_fallback", **entry)
+            return registry[default](self)
 
     @property
     def connected(self):
@@ -484,24 +576,28 @@ class Win32Controller(_LegacyController):
 
     def __init__(self, *, capture=None, clicker=None,
                  origin: tuple[int, int] | Callable[[], tuple[int, int]] | None = None,
-                 target_hwnd=None, pixel_watch=None, resource="desktop"):
+                 target_hwnd=None, pixel_watch=None, resource="desktop",
+                 screencap_method: str = "gdi_bitblt", input_method: str = "sendinput"):
         self._capture = capture
         self._clicker = clicker
         self._origin = origin
         self._captured_origin = None
+        # RPA-25: injected backends win; methods apply when backends are built.
+        self._screencap_method = screencap_method
+        self._input_method = input_method
         # Window targets on one desktop share the same execution resource.
         self._init_lifecycle(("win32", resource), target_hwnd, pixel_watch)
 
     def _capture_backend(self):
         if self._capture is None:
-            from autoclicker import capture
-            self._capture = capture
+            self._capture = self._resolve_strategy(
+                "screencap", self._screencap_method, "gdi_bitblt")
         return self._capture
 
     def _click_backend(self):
         if self._clicker is None:
-            from autoclicker.clicker import Clicker
-            self._clicker = Clicker()
+            self._clicker = self._resolve_strategy(
+                "input", self._input_method, "sendinput")
         return self._clicker
 
     def _desktop_origin(self):
@@ -553,7 +649,8 @@ class ADBController(_LegacyController):
                                 key_hold=False, hotkey=False)
 
     def __init__(self, device=None, *, serial=None, adb="adb", capture=None, clicker=None,
-                 target_hwnd=None, pixel_watch=None):
+                 target_hwnd=None, pixel_watch=None,
+                 screencap_method: str = "screencap", input_method: str = "adb_input"):
         self.device = device
         self.serial = serial if serial is not None else getattr(device, "serial", None)
         if not isinstance(self.serial, (str, type(None))):
@@ -561,6 +658,9 @@ class ADBController(_LegacyController):
         self.adb = adb
         self._capture = capture
         self._clicker = clicker
+        # RPA-25: injected backends win; methods apply when backends are built.
+        self._screencap_method = screencap_method
+        self._input_method = input_method
         self._init_lifecycle(("adb", self.serial or "*"), target_hwnd, pixel_watch)
 
     def _connection_backends(self):
@@ -576,14 +676,14 @@ class ADBController(_LegacyController):
 
     def _capture_backend(self):
         if self._capture is None:
-            from autoclicker.adb import AdbCapture
-            self._capture = AdbCapture(self._device())
+            self._capture = self._resolve_strategy(
+                "screencap", self._screencap_method, "screencap")
         return self._capture
 
     def _click_backend(self):
         if self._clicker is None:
-            from autoclicker.adb import AdbClicker
-            self._clicker = AdbClicker(self._device())
+            self._clicker = self._resolve_strategy(
+                "input", self._input_method, "adb_input")
         return self._clicker
 
     def capture_window(self, hwnd):
@@ -592,3 +692,89 @@ class ADBController(_LegacyController):
 
     def pinch(self, hwnd, cx, cy, start_dist, end_dist, duration_ms=400):
         raise NotImplementedError("ADB input does not support multi-touch pinch")
+
+
+# ---- RPA-25: built-in capture/input strategy factories ----
+
+def _require_kind(controller, cls, kind):
+    if not isinstance(controller, cls):
+        raise ValueError(f"{kind} 策略只能用于 {cls.__name__}")
+
+
+@register_capture_strategy("gdi_bitblt")
+def _win32_gdi_capture(controller):
+    _require_kind(controller, Win32Controller, "gdi_bitblt")
+    from autoclicker import capture
+    return capture
+
+
+@register_capture_strategy("printwindow")
+def _win32_printwindow_capture(controller):
+    """Prefer PrintWindow for a bound window; full-screen keeps GDI BitBlt."""
+    _require_kind(controller, Win32Controller, "printwindow")
+    from autoclicker import capture
+
+    class _PrintWindowBackend:
+        def capture_screen(self):
+            hwnd = controller.target_hwnd
+            return capture.capture_window(hwnd) if hwnd else capture.capture_screen()
+
+        def capture_window(self, hwnd):
+            return capture.capture_window(hwnd)
+
+    return _PrintWindowBackend()
+
+
+@register_capture_strategy("desktop_dup")
+def _win32_desktop_dup_capture(controller):
+    raise StrategyUnavailable("desktop_dup 需要 DXGI Desktop Duplication 实现（未内置）")
+
+
+@register_input_strategy("sendinput")
+def _win32_sendinput(controller):
+    _require_kind(controller, Win32Controller, "sendinput")
+    from autoclicker.clicker import Clicker
+    return Clicker()
+
+
+@register_input_strategy("postmessage")
+def _win32_postmessage(controller):
+    _require_kind(controller, Win32Controller, "postmessage")
+    from autoclicker.clicker import PostMessageClicker
+    return PostMessageClicker()
+
+
+@register_capture_strategy("screencap")
+def _adb_screencap(controller):
+    _require_kind(controller, ADBController, "screencap")
+    from autoclicker.adb import AdbCapture
+    return AdbCapture(controller._device())
+
+
+@register_capture_strategy("raw_gzip")
+def _adb_raw_gzip_capture(controller):
+    _require_kind(controller, ADBController, "raw_gzip")
+    from autoclicker.adb import AdbCapture
+    return AdbCapture(controller._device(), screencap_method="raw_gzip")
+
+
+@register_capture_strategy("minicap")
+def _adb_minicap_capture(controller):
+    raise StrategyUnavailable("minicap 需要向设备推送 minicap 组件（未内置）")
+
+
+@register_input_strategy("adb_input")
+def _adb_input(controller):
+    _require_kind(controller, ADBController, "adb_input")
+    from autoclicker.adb import AdbClicker
+    return AdbClicker(controller._device())
+
+
+@register_input_strategy("minitouch")
+def _adb_minitouch(controller):
+    raise StrategyUnavailable("minitouch 需要向设备推送 minitouch 组件（未内置）")
+
+
+@register_input_strategy("maatouch")
+def _adb_maatouch(controller):
+    raise StrategyUnavailable("maatouch 需要设备端 MaaTouch agent（未内置）")

{pyclickerrpa-0.9.0 → pyclickerrpa-0.11.0}/autoclicker/migrations.py

@@ -1,7 +1,8 @@
 """Versioned, non-mutating migrations for legacy and canonical task JSON.
 
 0: implicit legacy fields; 1: script opt-in; 2: symbolic edges;
-3: explicit variable_mode/subtask_scope (legacy/shared for existing tasks).
+3: explicit variable_mode/subtask_scope (legacy/shared for existing tasks);
+4: resource_paths bundle roots (empty for existing tasks).
 """
 from __future__ import annotations
 
@@ -9,7 +10,7 @@ import copy
 import re
 from typing import Callable
 
-LATEST_SCHEMA_VERSION = 3
+LATEST_SCHEMA_VERSION = 4
 _MIGRATIONS: dict[int, Callable[[dict], dict]] = {}
 
 
@@ -166,6 +167,14 @@ def migrate_2_to_3(data: dict) -> dict:
     return data
 
 
+@migration(3)
+def migrate_3_to_4(data: dict) -> dict:
+    # RPA-24: bundle roots are opt-in; existing tasks resolve paths as before.
+    data.setdefault("resource_paths", [])
+    data["schema_version"] = 4
+    return data
+
+
 def migrate_to_latest(data: dict) -> dict:
     """Deep-copy and migrate, rejecting malformed or unsupported versions."""
     if not isinstance(data, dict):