ok-script 0.0.183__tar.gz → 0.0.185__tar.gz

{ok-script-0.0.183/ok_script.egg-info → ok-script-0.0.185}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ok-script
-Version: 0.0.183
+Version: 0.0.185
 Summary: Automation with Computer Vision for Python
 Home-page: https://github.com/ok-oldking/ok-script
 Author: ok-oldking

{ok-script-0.0.183 → ok-script-0.0.185}/ok/capture/BaseCaptureMethod.py

@@ -39,7 +39,7 @@ class BaseCaptureMethod:
                     frame = frame[:, :, :3]
             return frame
         except Exception as e:
-            raise CaptureException() from e
+            raise CaptureException(str(e)) from e
 
     def __str__(self):
         return f'{self.__class__.__name__}_{self.width}x{self.height}'

{ok-script-0.0.183 → ok-script-0.0.185}/ok/capture/adb/DeviceManager.py

@@ -93,21 +93,23 @@ class DeviceManager:
     def adb_connect(self, addr, try_connect=True):
         from adbutils import AdbError
         try:
-            for device in self.adb.device_list():
+            for device in self.adb.list():
                 if self.exit_event.is_set():
                     logger.error(f"adb_connect exit_event is set")
                     return None
                 if device.serial == addr:
-                    if device.info['state'] == 'offline':
+                    if device.state == 'offline':
                         logger.debug(f'adb_connect offline disconnect first {addr}')
                         self.adb.disconnect(addr)
                     else:
                         logger.debug(f'adb_connect already connected {addr}')
-                        return device
+                        return self.adb.device(addr)
             if try_connect:
-                self.adb.connect(addr, timeout=5)
-                logger.debug(f'adb_connect {addr}')
+                ret = self.adb.connect(addr, timeout=5)
+                logger.debug(f'adb_connect try_connect {addr} {ret}')
                 return self.adb_connect(addr, try_connect=False)
+            else:
+                logger.debug(f'adb_connect {addr} not in device list {self.adb.list()}')
         except AdbError as e:
             logger.error(f"adb connect error {addr}", e)
             self.try_kill_adb(e)
@@ -185,19 +187,19 @@ class DeviceManager:
                 logger.debug(f"refresh current only skip others {preferred['imei']} != {emulator.name}")
                 continue
             adb_device = self.adb_connect(emulator.serial)
+            logger.info(f'adb_connect emulator result {emulator.type} {adb_device}')
             width, height = self.get_resolution(adb_device) if adb_device is not None else 0, 0
             name, hwnd, full_path, x, y, width, height = find_hwnd(None,
                                                                    emulator.path, width, height, emulator.player_id)
             connected = adb_device is not None and name is not None
-            emulator_device = {"address": emulator.serial, "device": "adb",
-                               "full_path": emulator.path, "connected": connected,
-                               "imei": emulator.name, "player_id": emulator.player_id,
+            emulator_device = {"address": emulator.serial, "device": "adb", "full_path": emulator.path,
+                               "connected": connected, "imei": emulator.name, "player_id": emulator.player_id,
                                "nick": name or emulator.name, "emulator": emulator}
             if adb_device is not None:
                 emulator_device["resolution"] = f"{width}x{height}"
                 emulator_device["adb_imei"] = self.adb_get_imei(adb_device)
             self.device_dict[emulator.name] = emulator_device
-        logger.debug(f'refresh emulators {self.device_dict}')
+        logger.info(f'refresh emulators {self.device_dict}')
 
     def get_resolution(self, device=None):
         if device is None:
@@ -334,6 +336,13 @@ class DeviceManager:
                 self.ensure_hwnd(None, preferred.get('full_path'), width, height, preferred['player_id'])
                 self.use_windows_capture({'can_bit_blt': True}, require_bg=True, use_bit_blt_only=False,
                                          bit_blt_render_full=False)
+            elif self.config.get('capture') == 'ipc':
+                from ok.capture.adb.NemuIpcCaptureMethod import NemuIpcCaptureMethod
+                if not isinstance(self.capture_method, NemuIpcCaptureMethod):
+                    if self.capture_method is not None:
+                        self.capture_method.close()
+                    self.capture_method = NemuIpcCaptureMethod(self, self.exit_event)
+                self.capture_method.update_emulator(self.get_preferred_device()['emulator'])
             else:
                 if not isinstance(self.capture_method, ADBCaptureMethod):
                     logger.debug(f'use adb capture')

ok-script-0.0.185/ok/capture/adb/NemuIpcCaptureMethod.py

@@ -0,0 +1,121 @@
+# original https://github.com/Toufool/AutoSplit/blob/master/src/capture_method/WindowsGraphicsCaptureMethod.py
+import json
+import os
+
+import numpy as np
+from typing_extensions import override
+
+from ok.alas.emulator_windows import EmulatorInstance
+from ok.capture.BaseCaptureMethod import BaseCaptureMethod
+from ok.capture.adb.nemu_ipc import NemuIpcImpl
+from ok.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class NemuIpcCaptureMethod(BaseCaptureMethod):
+    name = "Nemu Ipc Capture"
+    description = "mumu player 12 only"
+
+    def __init__(self, device_manager, exit_event, width=0, height=0):
+        super().__init__()
+        self.device_manager = device_manager
+        self.exit_event = exit_event
+        self._connected = (width != 0 and height != 0)
+        self.nemu_impl: NemuIpcImpl | None = None
+        self.emulator: EmulatorInstance | None = None
+
+    def update_emulator(self, emulator: EmulatorInstance):
+        self.emulator = emulator
+        logger.info(f'update_path_and_id {emulator}')
+        if self.nemu_impl:
+            self.nemu_impl.disconnect()
+            self.nemu_impl = None
+
+    def init_nemu(self):
+        self.check_mumu_app_keep_alive_400()
+        if not self.nemu_impl:
+            self.nemu_impl = NemuIpcImpl(
+                nemu_folder=self.base_folder(),
+                instance_id=self.emulator.player_id,
+                display_id=0
+            ).__enter__()
+
+    def base_folder(self):
+        return os.path.dirname(os.path.dirname(self.emulator.path))
+
+    def check_mumu_app_keep_alive_400(self):
+        """
+        Check app_keep_alive from emulator config if version >= 4.0
+
+        Args:
+            file: E:/ProgramFiles/MuMuPlayer-12.0/vms/MuMuPlayer-12.0-1/config/customer_config.json
+
+        Returns:
+            bool: If success to read file
+        """
+        file = os.path.abspath(os.path.join(
+            self.base_folder(),
+            f'vms/MuMuPlayer-12.0-{self.emulator.player_id}/configs/customer_config.json'))
+
+        # with E:\ProgramFiles\MuMuPlayer-12.0\shell\MuMuPlayer.exe
+        # config is E:\ProgramFiles\MuMuPlayer-12.0\vms\MuMuPlayer-12.0-1\config\customer_config.json
+        try:
+            with open(file, mode='r', encoding='utf-8') as f:
+                s = f.read()
+                data = json.loads(s)
+        except FileNotFoundError:
+            logger.warning(f'Failed to check check_mumu_app_keep_alive, file {file} not exists')
+            return False
+        value = deep_get(data, keys='customer.app_keptlive', default=None)
+        logger.info(f'customer.app_keptlive {value}')
+        if str(value).lower() == 'true':
+            # https://mumu.163.com/help/20230802/35047_1102450.html
+            logger.error('Please turn off enable background keep alive in MuMuPlayer settings')
+            raise Exception('Please turn off enable background keep alive in MuMuPlayer settings')
+        return True
+
+    @override
+    def close(self):
+        super().close()
+        if self.nemu_impl:
+            self.nemu_impl.disconnect()
+            self.nemu_impl = None
+
+    @override
+    def do_get_frame(self) -> np.ndarray | None:
+        self.init_nemu()
+        return self.screencap()
+
+    def screencap(self):
+        if self.exit_event.is_set():
+            return None
+        if self.nemu_impl:
+            frame = self.nemu_impl.screenshot(timeout=0.5)
+            return frame
+
+    def connected(self):
+        return True
+
+
+def deep_get(d, keys, default=None):
+    """
+    Get values in dictionary safely.
+    https://stackoverflow.com/questions/25833613/safe-method-to-get-value-of-nested-dictionary
+
+    Args:
+        d (dict):
+        keys (str, list): Such as `Scheduler.NextRun.value`
+        default: Default return if key not found.
+
+    Returns:
+
+    """
+    if isinstance(keys, str):
+        keys = keys.split('.')
+    assert type(keys) is list
+    if d is None:
+        return default
+    if not keys:
+        return d
+    return deep_get(d.get(keys[0]), keys[1:], default)