MaaFw 4.5.5__py3-none-win_arm64.whl → 5.0.0a1__py3-none-win_arm64.whl

maa/context.py

@@ -1,13 +1,15 @@
 import ctypes
 import json
-from typing import Dict, Optional, Tuple
+from typing import Any, Dict, Optional, Tuple, Union
 
 import numpy
 
+from .event_sink import EventSink, NotificationType
 from .buffer import ImageBuffer, RectBuffer, StringBuffer, StringListBuffer
 from .define import *
 from .library import Library
 from .tasker import Tasker
+from .pipeline import JPipelineData, JPipelineParser
 from .job import JobWithResult
 
 
@@ -43,7 +45,10 @@ class Context:
         return self.tasker.get_task_detail(task_id)
 
     def run_recognition(
-        self, entry: str, image: numpy.ndarray, pipeline_override: Dict = {}
+        self,
+        entry: str,
+        image: numpy.ndarray,
+        pipeline_override: Dict = {},
     ) -> Optional[RecognitionDetail]:
         image_buffer = ImageBuffer()
         image_buffer.set(image)
@@ -84,10 +89,12 @@ class Context:
         return self.tasker.get_node_detail(node_id)
 
     def override_pipeline(self, pipeline_override: Dict) -> bool:
+        pipeline_json = json.dumps(pipeline_override, ensure_ascii=False)
+
         return bool(
             Library.framework().MaaContextOverridePipeline(
                 self._handle,
-                json.dumps(pipeline_override, ensure_ascii=False).encode(),
+                pipeline_json.encode(),
             )
         )
 
@@ -101,7 +108,7 @@ class Context:
             )
         )
 
-    def get_node_data(self, name: str) -> Optional[dict]:
+    def get_node_data(self, name: str) -> Optional[Dict]:
         string_buffer = StringBuffer()
         if not Library.framework().MaaContextGetNodeData(
             self._handle, name.encode(), string_buffer._handle
@@ -117,6 +124,14 @@ class Context:
         except json.JSONDecodeError:
             return None
 
+    def get_node_object(self, name: str) -> Optional[JPipelineData]:
+        node_data = self.get_node_data(name)
+
+        if not node_data:
+            return None
+
+        return JPipelineParser.parse_pipeline_data(node_data)
+
     @property
     def tasker(self) -> Tasker:
         return self._tasker
@@ -145,9 +160,11 @@ class Context:
 
     @staticmethod
     def _gen_post_param(entry: str, pipeline_override: Dict) -> Tuple[bytes, bytes]:
+        pipeline_json = json.dumps(pipeline_override, ensure_ascii=False)
+
         return (
             entry.encode(),
-            json.dumps(pipeline_override, ensure_ascii=False).encode(),
+            pipeline_json.encode(),
         )
 
     _api_properties_initialized: bool = False
@@ -217,3 +234,82 @@ class Context:
         Library.framework().MaaContextClone.argtypes = [
             MaaContextHandle,
         ]
+
+
+class ContextEventSink(EventSink):
+
+    @dataclass
+    class NodeNextListDetail:
+        task_id: int
+        name: str
+        next_list: list[str]
+        focus: Any
+
+    def on_node_next_list(
+        self,
+        context: "Context",
+        noti_type: NotificationType,
+        detail: NodeNextListDetail,
+    ):
+        pass
+
+    @dataclass
+    class NodeRecognitionDetail:
+        task_id: int
+        reco_id: int
+        name: str
+        focus: Any
+
+    def on_node_recognition(
+        self,
+        context: "Context",
+        noti_type: NotificationType,
+        detail: NodeRecognitionDetail,
+    ):
+        pass
+
+    @dataclass
+    class NodeActionDetail:
+        task_id: int
+        node_id: int
+        name: str
+        focus: Any
+
+    def on_node_action(
+        self, context: "Context", noti_type: NotificationType, detail: NodeActionDetail
+    ):
+        pass
+
+    def on_raw_notification(self, handle: ctypes.c_void_p, msg: str, details: dict):
+        context = Context(handle=handle)
+        noti_type = EventSink._notification_type(msg)
+
+        if msg.startswith("Node.NextList"):
+            detail = self.NodeNextListDetail(
+                task_id=details["task_id"],
+                name=details["name"],
+                next_list=details["list"],
+                focus=details["focus"],
+            )
+            self.on_node_next_list(context, noti_type, detail)
+
+        elif msg.startswith("Node.Recognition"):
+            detail = self.NodeRecognitionDetail(
+                task_id=details["task_id"],
+                reco_id=details["reco_id"],
+                name=details["name"],
+                focus=details["focus"],
+            )
+            self.on_node_recognition(context, noti_type, detail)
+
+        elif msg.startswith("Node.Action"):
+            detail = self.NodeActionDetail(
+                task_id=details["task_id"],
+                node_id=details["node_id"],
+                name=details["name"],
+                focus=details["focus"],
+            )
+            self.on_node_action(context, noti_type, detail)
+
+        else:
+            self.on_unknown_notification(context, msg, details)

maa/controller.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from typing import Any, Dict, Optional, Union
 
 from .buffer import ImageBuffer, StringBuffer
-from .notification_handler import NotificationHandler
+from .event_sink import EventSink, NotificationType
 from .define import *
 from .job import Job, JobWithResult
 from .library import Library
@@ -20,7 +20,6 @@ __all__ = [
 
 
 class Controller:
-    _notification_handler: Optional[NotificationHandler]
     _handle: MaaControllerHandle
     _own: bool
 
@@ -173,6 +172,27 @@ class Controller:
             )
         )
 
+    _sink_holder: Dict[int, "ControllerEventSink"] = {}
+
+    def add_sink(self, sink: "ControllerEventSink") -> Optional[int]:
+        sink_id = int(
+            Library.framework().MaaControllerAddSink(
+                self._handle, *EventSink._gen_c_param(sink)
+            )
+        )
+        if sink_id == MaaInvalidId:
+            return None
+
+        self._sink_holder[sink_id] = sink
+        return sink_id
+
+    def remove_sink(self, sink_id: int) -> None:
+        Library.framework().MaaControllerRemoveSink(self._handle, sink_id)
+        self._sink_holder.pop(sink_id)
+
+    def clear_sinks(self) -> None:
+        Library.framework().MaaControllerClearSinks(self._handle)
+
     ### private ###
 
     def _status(self, maaid: int) -> MaaStatus:
@@ -319,6 +339,22 @@ class Controller:
             MaaStringBufferHandle,
         ]
 
+        Library.framework().MaaControllerAddSink.restype = MaaSinkId
+        Library.framework().MaaControllerAddSink.argtypes = [
+            MaaControllerHandle,
+            MaaEventCallback,
+            ctypes.c_void_p,
+        ]
+
+        Library.framework().MaaControllerRemoveSink.restype = None
+        Library.framework().MaaControllerRemoveSink.argtypes = [
+            MaaControllerHandle,
+            MaaSinkId,
+        ]
+
+        Library.framework().MaaControllerClearSinks.restype = None
+        Library.framework().MaaControllerClearSinks.argtypes = [MaaControllerHandle]
+
 
 class AdbController(Controller):
     AGENT_BINARY_PATH = os.path.join(
@@ -334,13 +370,16 @@ class AdbController(Controller):
         input_methods: int = MaaAdbInputMethodEnum.Default,
         config: Dict[str, Any] = {},
         agent_path: Union[str, Path] = AGENT_BINARY_PATH,
-        notification_handler: Optional[NotificationHandler] = None,
+        notification_handler: None = None,
     ):
+        if notification_handler:
+            raise NotImplementedError(
+                "NotificationHandler is deprecated, use add_sink instead."
+            )
+
         super().__init__()
         self._set_adb_api_properties()
 
-        self._notification_handler = notification_handler
-
         self._handle = Library.framework().MaaAdbControllerCreate(
             str(adb_path).encode(),
             address.encode(),
@@ -348,7 +387,6 @@ class AdbController(Controller):
             MaaAdbInputMethod(input_methods),
             json.dumps(config, ensure_ascii=False).encode(),
             str(agent_path).encode(),
-            *NotificationHandler._gen_c_param(self._notification_handler)
         )
 
         if not self._handle:
@@ -364,8 +402,6 @@ class AdbController(Controller):
             MaaAdbInputMethod,
             ctypes.c_char_p,
             ctypes.c_char_p,
-            MaaNotificationCallback,
-            ctypes.c_void_p,
         ]
 
 
@@ -376,17 +412,20 @@ class Win32Controller(Controller):
         hWnd: Union[ctypes.c_void_p, int, None],
         screencap_method: int = MaaWin32ScreencapMethodEnum.DXGI_DesktopDup,
         input_method: int = MaaWin32InputMethodEnum.Seize,
-        notification_handler: Optional[NotificationHandler] = None,
+        notification_handler: None = None,
     ):
+        if notification_handler:
+            raise NotImplementedError(
+                "NotificationHandler is deprecated, use add_sink instead."
+            )
+
         super().__init__()
         self._set_win32_api_properties()
 
-        self._notification_handler = notification_handler
         self._handle = Library.framework().MaaWin32ControllerCreate(
             hWnd,
             MaaWin32ScreencapMethod(screencap_method),
             MaaWin32InputMethod(input_method),
-            *NotificationHandler._gen_c_param(self._notification_handler)
         )
 
         if not self._handle:
@@ -398,8 +437,6 @@ class Win32Controller(Controller):
             ctypes.c_void_p,
             MaaWin32ScreencapMethod,
             MaaWin32InputMethod,
-            MaaNotificationCallback,
-            ctypes.c_void_p,
         ]
 
 
@@ -411,18 +448,21 @@ class DbgController(Controller):
         write_path: Union[str, Path],
         dbg_type: int,
         config: Dict[str, Any] = {},
-        notification_handler: Optional[NotificationHandler] = None,
+        notification_handler: None = None,
     ):
+        if notification_handler:
+            raise NotImplementedError(
+                "NotificationHandler is deprecated, use add_sink instead."
+            )
+
         super().__init__()
         self._set_dbg_api_properties()
 
-        self._notification_handler = notification_handler
         self._handle = Library.framework().MaaDbgControllerCreate(
             str(read_path).encode(),
             str(write_path).encode(),
             MaaDbgControllerType(dbg_type),
             json.dumps(config, ensure_ascii=False).encode(),
-            *NotificationHandler._gen_c_param(self._notification_handler)
         )
 
         if not self._handle:
@@ -435,8 +475,6 @@ class DbgController(Controller):
             ctypes.c_char_p,
             MaaDbgControllerType,
             ctypes.c_char_p,
-            MaaNotificationCallback,
-            ctypes.c_void_p,
         ]
 
 
@@ -446,13 +484,16 @@ class CustomController(Controller):
 
     def __init__(
         self,
-        notification_handler: Optional[NotificationHandler] = None,
+        notification_handler: None = None,
     ):
+        if notification_handler:
+            raise NotImplementedError(
+                "NotificationHandler is deprecated, use add_sink instead."
+            )
+
         super().__init__()
         self._set_custom_api_properties()
 
-        self._notification_handler = notification_handler
-
         self._callbacks = MaaCustomControllerCallbacks(
             CustomController._c_connect_agent,
             CustomController._c_request_uuid_agent,
@@ -473,7 +514,6 @@ class CustomController(Controller):
         self._handle = Library.framework().MaaCustomControllerCreate(
             self.c_handle,
             self.c_arg,
-            *NotificationHandler._gen_c_param(self._notification_handler)
         )
 
         if not self._handle:
@@ -805,6 +845,39 @@ class CustomController(Controller):
         Library.framework().MaaCustomControllerCreate.argtypes = [
             ctypes.POINTER(MaaCustomControllerCallbacks),
             ctypes.c_void_p,
-            MaaNotificationCallback,
-            ctypes.c_void_p,
         ]
+
+
+class ControllerEventSink(EventSink):
+
+    @dataclass
+    class ControllerActionDetail:
+        ctrl_id: int
+        uuid: str
+        action: str
+        param: dict
+
+    def on_controller_action(
+        self,
+        controller: Controller,
+        noti_type: NotificationType,
+        detail: ControllerActionDetail,
+    ):
+        pass
+
+    def on_raw_notification(self, handle: ctypes.c_void_p, msg: str, details: dict):
+
+        controller = Controller(handle=handle)
+        noti_type = EventSink._notification_type(msg)
+
+        if msg.startswith("Controller.Action"):
+            detail = self.ControllerActionDetail(
+                ctrl_id=details["ctrl_id"],
+                uuid=details["uuid"],
+                action=details["action"],
+                param=details["param"],
+            )
+            self.on_controller_action(controller, noti_type, detail)
+
+        else:
+            self.on_unknown_notification(controller, msg, details)

maa/define.py

@@ -17,6 +17,7 @@ MaaResId = MaaId
 MaaTaskId = MaaId
 MaaRecoId = MaaId
 MaaNodeId = MaaId
+MaaSinkId = MaaId
 MaaInvalidId = MaaId(0)
 
 MaaStringBufferHandle = ctypes.c_void_p
@@ -240,8 +241,8 @@ class MaaDbgControllerTypeEnum(IntEnum):
 
 FUNCTYPE = ctypes.WINFUNCTYPE if (platform.system() == "Windows") else ctypes.CFUNCTYPE
 
-MaaNotificationCallback = FUNCTYPE(
-    None, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_void_p
+MaaEventCallback = FUNCTYPE(
+    None, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_void_p
 )
 
 MaaCustomRecognitionCallback = FUNCTYPE(

maa/event_sink.py

@@ -0,0 +1,74 @@
+import ctypes
+import json
+from abc import ABC
+from typing import Optional, Tuple, Any
+from enum import IntEnum
+from dataclasses import dataclass
+
+from .define import MaaEventCallback
+
+
+# class NotificationEvent(IntEnum):
+#     ResourceLoading = 1
+#     ControllerAction = 2
+#     TaskerTask = 3
+#     TaskNextList = 4
+#     TaskRecognition = 5
+#     TaskAction = 6
+
+
+class NotificationType(IntEnum):
+    Unknown = 0
+    Starting = 1
+    Succeeded = 2
+    Failed = 3
+
+
+class EventSink(ABC):
+    def on_unknown_notification(self, instance, msg: str, details: dict):
+        pass
+
+    def on_raw_notification(self, handle: ctypes.c_void_p, msg: str, details: dict):
+        pass
+
+    @property
+    def c_callback(self) -> MaaEventCallback:
+        return self._c_sink_agent
+
+    @property
+    def c_callback_arg(self) -> ctypes.c_void_p:
+        return ctypes.c_void_p.from_buffer(ctypes.py_object(self))
+
+    @staticmethod
+    def _gen_c_param(
+        sink: "EventSink",
+    ) -> Tuple[MaaEventCallback, ctypes.c_void_p]:
+        return sink.c_callback, sink.c_callback_arg
+
+    @staticmethod
+    def _notification_type(message: str) -> NotificationType:
+        if message.endswith(".Starting"):
+            return NotificationType.Starting
+        elif message.endswith(".Succeeded"):
+            return NotificationType.Succeeded
+        elif message.endswith(".Failed"):
+            return NotificationType.Failed
+        else:
+            return NotificationType.Unknown
+
+    @staticmethod
+    @MaaEventCallback
+    def _c_sink_agent(
+        handle: ctypes.c_void_p,
+        msg: ctypes.c_char_p,
+        details_json: ctypes.c_char_p,
+        callback_arg: ctypes.c_void_p,
+    ):
+        if not callback_arg:
+            return
+
+        self: EventSink = ctypes.cast(callback_arg, ctypes.py_object).value
+
+        self.on_raw_notification(
+            handle, msg.decode(), json.loads(details_json.decode())
+        )