fix(controller): release held input state on task stop

Queue an internal inactive action when ControllerAgent::post_stop() clears pending controller work so held background-managed keys are released even if the matching key-up never runs.

Skip Tasker\'s normal end-of-run inactive cleanup while stopping to avoid issuing the release twice.

Add a Python binding regression test that blocks inside a custom action after key-down and verifies tasker.post_stop() triggers inactive() before the task exits.

Author: Z_06

source/MaaFramework/Controller/ControllerAgent.cpp

@@ -277,9 +277,15 @@ void ControllerAgent::post_stop()
 
     need_to_stop_ = true;
 
-    if (action_runner_ && action_runner_->running()) {
+    if (!action_runner_) {
+        return;
+    }
+
+    if (action_runner_->running()) {
         action_runner_->clear();
     }
+
+    action_runner_->post({ .type = Action::Type::inactive });
 }
 
 bool ControllerAgent::running() const

source/MaaFramework/Tasker/Tasker.cpp

@@ -361,7 +361,7 @@ bool Tasker::run_task(RunnerId runner_id, TaskPtr task_ptr)
     }
     notifier_.notify(this, ret ? MaaMsg_Tasker_Task_Succeeded : MaaMsg_Tasker_Task_Failed, cb_detail);
 
-    if (controller_ && !task_runner_->pending()) {
+    if (controller_ && !need_to_stop_ && !task_runner_->pending()) {
         controller_->wait(controller_->post_inactive());
     }
 

test/python/binding_test.py

@@ -17,6 +17,7 @@
 import sys
 import numpy
 import io
+import threading
 
 # Fix encoding issues on Windows
 if sys.stdout.encoding != "utf-8":
@@ -595,6 +596,9 @@ class MyController(CustomController):
     def __init__(self):
         super().__init__()
         self.count = 0
+        self.inactive_count = 0
+        self.key_down_event = threading.Event()
+        self.inactive_event = threading.Event()
 
     def connect(self) -> bool:
         print("  on MyController.connect")
@@ -662,6 +666,7 @@ def input_text(self, text: str) -> bool:
     def key_down(self, keycode: int) -> bool:
         print(f"  on MyController.key_down: {keycode}")
         self.count += 1
+        self.key_down_event.set()
         return True
 
     def key_up(self, keycode: int) -> bool:
@@ -674,13 +679,44 @@ def scroll(self, dx: int, dy: int) -> bool:
         self.count += 1
         return True
 
+    def inactive(self) -> bool:
+        print("  on MyController.inactive")
+        self.count += 1
+        self.inactive_count += 1
+        self.inactive_event.set()
+        return True
+
     def get_custom_info(self) -> dict:
         return {
             "custom_key": "custom_value",
             "answer": 42,
         }
 
 
+class HoldKeyDownAction(CustomAction):
+
+    def __init__(self, release_event: threading.Event):
+        super().__init__()
+        self.release_event = release_event
+
+    def run(
+        self,
+        context: Context,
+        argv: CustomAction.RunArg,
+    ) -> CustomAction.RunResult:
+        del argv
+
+        controller = context.tasker.controller
+        key_down_job = controller.post_key_down(87).wait()
+        if not key_down_job.succeeded:
+            raise RuntimeError("key_down should succeed in HoldKeyDownAction")
+
+        if not self.release_event.wait(5):
+            raise RuntimeError("timeout waiting to release HoldKeyDownAction")
+
+        return CustomAction.RunResult(success=True)
+
+
 def test_custom_controller():
     print("\n=== test_custom_controller ===")
 
@@ -722,6 +758,48 @@ def test_custom_controller():
     print("  PASS: custom controller")
 
 
+def test_tasker_post_stop_releases_custom_controller():
+    print("\n=== test_tasker_post_stop_releases_custom_controller ===")
+
+    resource = Resource()
+    release_event = threading.Event()
+    resource.register_custom_action("HoldKeyDownAction", HoldKeyDownAction(release_event))
+    resource.override_pipeline(
+        {
+            "StopEntry": {
+                "action": "Custom",
+                "custom_action": "HoldKeyDownAction",
+            }
+        }
+    )
+
+    controller = MyController()
+    assert controller.post_connection().wait().succeeded, "custom controller should connect"
+
+    tasker = Tasker()
+    tasker.bind(resource, controller)
+    assert tasker.inited, "tasker should init with custom controller"
+
+    task_job = tasker.post_task("StopEntry")
+    stop_job = None
+
+    try:
+        assert controller.key_down_event.wait(5), "key_down should happen before stop"
+
+        stop_job = tasker.post_stop()
+        assert controller.inactive_event.wait(5), (
+            "post_stop should trigger controller inactive before the task exits"
+        )
+    finally:
+        release_event.set()
+        if stop_job is not None:
+            stop_job.wait()
+        task_job.wait()
+
+    assert controller.inactive_count >= 1, "inactive should be called during stop"
+    print("  PASS: tasker post_stop releases custom controller state")
+
+
 # ============================================================================
 # Toolkit 测试
 # ============================================================================
@@ -845,6 +923,7 @@ def test_background_managed_keys_api(dbg_controller: DbgController):
 
     # 测试 CustomController
     test_custom_controller()
+    test_tasker_post_stop_releases_custom_controller()
 
     # 测试 Toolkit
     test_toolkit()