| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551 |
- import asyncio
- import ctypes
- import os
- import sys
- from functools import partial, wraps
- from pathlib import Path
- import cv2
- import numpy as np
- from module.base.decorator import cached_property, del_cached_property, has_cached_property
- from module.base.utils import ensure_time
- from module.device.method.minitouch import insert_swipe, random_rectangle_point
- from module.device.method.utils import RETRY_TRIES, retry_sleep
- from module.exception import RequestHumanTakeover
- from module.logger import logger
- class NemuIpcIncompatible(Exception):
- pass
- class NemuIpcError(Exception):
- pass
- class CaptureStd:
- """
- Capture stdout and stderr from both python and C library
- https://stackoverflow.com/questions/5081657/how-do-i-prevent-a-c-shared-library-to-print-on-stdout-in-python/17954769
- ```
- with CaptureStd() as capture:
- # String wasn't printed
- print('whatever')
- # But captured in ``capture.stdout``
- print(f'Got stdout: "{capture.stdout}"')
- print(f'Got stderr: "{capture.stderr}"')
- ```
- """
- def __init__(self):
- self.stdout = b''
- self.stderr = b''
- def _redirect_stdout(self, to):
- sys.stdout.close()
- os.dup2(to, self.fdout)
- sys.stdout = os.fdopen(self.fdout, 'w')
- def _redirect_stderr(self, to):
- sys.stderr.close()
- os.dup2(to, self.fderr)
- sys.stderr = os.fdopen(self.fderr, 'w')
- def __enter__(self):
- self.fdout = sys.stdout.fileno()
- self.fderr = sys.stderr.fileno()
- self.reader_out, self.writer_out = os.pipe()
- self.reader_err, self.writer_err = os.pipe()
- self.old_stdout = os.dup(self.fdout)
- self.old_stderr = os.dup(self.fderr)
- file_out = os.fdopen(self.writer_out, 'w')
- file_err = os.fdopen(self.writer_err, 'w')
- self._redirect_stdout(to=file_out.fileno())
- self._redirect_stderr(to=file_err.fileno())
- return self
- def __exit__(self, exc_type, exc_val, exc_tb):
- self._redirect_stdout(to=self.old_stdout)
- self._redirect_stderr(to=self.old_stderr)
- os.close(self.old_stdout)
- os.close(self.old_stderr)
- self.stdout = self.recvall(self.reader_out)
- self.stderr = self.recvall(self.reader_err)
- os.close(self.reader_out)
- os.close(self.reader_err)
- @staticmethod
- def recvall(reader, length=1024) -> bytes:
- fragments = []
- while 1:
- chunk = os.read(reader, length)
- if chunk:
- fragments.append(chunk)
- else:
- break
- output = b''.join(fragments)
- return output
- class CaptureNemuIpc(CaptureStd):
- instance = None
- def is_capturing(self):
- """
- Only capture at the topmost wrapper to avoid nested capturing
- If a capture is ongoing, this instance does nothing
- """
- cls = self.__class__
- return isinstance(cls.instance, cls) and cls.instance != self
- def __enter__(self):
- if self.is_capturing():
- return self
- super().__enter__()
- CaptureNemuIpc.instance = self
- return self
- def __exit__(self, exc_type, exc_val, exc_tb):
- if self.is_capturing():
- return
- CaptureNemuIpc.instance = None
- super().__exit__(exc_type, exc_val, exc_tb)
- self.check_stdout()
- self.check_stderr()
- def check_stdout(self):
- if not self.stdout:
- return
- logger.info(f'NemuIpc stdout: {self.stdout}')
- def check_stderr(self):
- if not self.stderr:
- return
- logger.error(f'NemuIpc stderr: {self.stderr}')
- # Calling an old MuMu12 player
- # Tested on 3.4.0
- # b'nemu_capture_display rpc error: 1783\r\n'
- # Tested on 3.7.3
- # b'nemu_capture_display rpc error: 1745\r\n'
- if b'error: 1783' in self.stderr or b'error: 1745' in self.stderr:
- raise NemuIpcIncompatible(
- f'NemuIpc requires MuMu12 version >= 3.8.13, please check your version')
- # contact_id incorrect
- # b'nemu_capture_display cannot find rpc connection\r\n'
- if b'cannot find rpc connection' in self.stderr:
- raise NemuIpcError(self.stderr)
- # Emulator died
- # b'nemu_capture_display rpc error: 1722\r\n'
- # MuMuVMMSVC.exe died
- # b'nemu_capture_display rpc error: 1726\r\n'
- # No idea how to handle yet
- if b'error: 1722' in self.stderr or b'error: 1726' in self.stderr:
- raise NemuIpcError('Emulator instance is probably dead')
- def retry(func):
- @wraps(func)
- def retry_wrapper(self, *args, **kwargs):
- """
- Args:
- self (NemuIpcImpl):
- """
- init = None
- for _ in range(RETRY_TRIES):
- try:
- if callable(init):
- retry_sleep(_)
- init()
- return func(self, *args, **kwargs)
- # Can't handle
- except RequestHumanTakeover:
- break
- # Can't handle
- except NemuIpcIncompatible as e:
- logger.error(e)
- break
- # Function call timeout
- except asyncio.TimeoutError:
- logger.warning(f'Func {func.__name__}() call timeout, retrying: {_}')
- def init():
- self.reconnect()
- # NemuIpcError
- except NemuIpcError as e:
- logger.error(e)
- def init():
- self.reconnect()
- # Unknown, probably a trucked image
- except Exception as e:
- logger.exception(e)
- def init():
- pass
- logger.critical(f'Retry {func.__name__}() failed')
- raise RequestHumanTakeover
- return retry_wrapper
- class NemuIpcImpl:
- def __init__(self, nemu_folder: str, instance_id: int, display_id: int = 0):
- """
- Args:
- nemu_folder: Installation path of MuMu12, e.g. E:/ProgramFiles/MuMuPlayer-12.0
- instance_id: Emulator instance ID, starting from 0
- display_id: Always 0 if keep app alive was disabled
- """
- self.nemu_folder: str = nemu_folder
- self.instance_id: int = instance_id
- self.display_id: int = display_id
- list_dll = [
- # MuMuPlayer12
- os.path.abspath(os.path.join(nemu_folder, './shell/sdk/external_renderer_ipc.dll')),
- # MuMuPlayer12 5.0
- os.path.abspath(os.path.join(nemu_folder, './nx_device/12.0/shell/sdk/external_renderer_ipc.dll')),
- ]
- self.lib = None
- for ipc_dll in list_dll:
- if not os.path.exists(ipc_dll):
- continue
- try:
- self.lib = ctypes.CDLL(ipc_dll)
- break
- except OSError as e:
- logger.error(e)
- logger.error(f'ipc_dll={ipc_dll} exists, but cannot be loaded')
- continue
- if self.lib is None:
- # not found
- raise NemuIpcIncompatible(
- f'NemuIpc requires MuMu12 version >= 3.8.13, please check your version. '
- f'None of the following path exists: {list_dll}')
- # success
- logger.info(
- f'NemuIpcImpl init, '
- f'nemu_folder={nemu_folder}, '
- f'ipc_dll={ipc_dll}, '
- f'instance_id={instance_id}, '
- f'display_id={display_id}'
- )
- self.connect_id: int = 0
- self.width = 0
- self.height = 0
- def connect(self):
- if self.connect_id > 0:
- return
- connect_id = self.ev_run_sync(
- self.lib.nemu_connect,
- self.nemu_folder, self.instance_id
- )
- if connect_id == 0:
- raise NemuIpcError(
- 'Connection failed, please check if nemu_folder is correct and emulator is running'
- )
- self.connect_id = connect_id
- # logger.info(f'NemuIpc connected: {self.connect_id}')
- def disconnect(self):
- if self.connect_id == 0:
- return
- self.ev_run_sync(
- self.lib.nemu_disconnect,
- self.connect_id
- )
- # logger.info(f'NemuIpc disconnected: {self.connect_id}')
- self.connect_id = 0
- def reconnect(self):
- self.disconnect()
- self.connect()
- def __enter__(self):
- self.connect()
- return self
- def __exit__(self, exc_type, exc_val, exc_tb):
- self.disconnect()
- @cached_property
- def _ev(self):
- return asyncio.new_event_loop()
- async def ev_run_async(self, func, *args, **kwargs):
- """
- Args:
- func: Sync function to call
- *args:
- **kwargs:
- Raises:
- asyncio.TimeoutError: If function call timeout
- """
- func_wrapped = partial(func, *args, **kwargs)
- # Increased timeout for slow PCs
- # Default screenshot interval is 0.2s, so a 0.15s timeout would have a fast retry without extra time costs
- result = await asyncio.wait_for(self._ev.run_in_executor(None, func_wrapped), timeout=0.15)
- return result
- def ev_run_sync(self, func, *args, **kwargs):
- """
- Args:
- func: Sync function to call
- *args:
- **kwargs:
- Raises:
- asyncio.TimeoutError: If function call timeout
- NemuIpcIncompatible:
- NemuIpcError
- """
- result = self._ev.run_until_complete(self.ev_run_async(func, *args, **kwargs))
- err = False
- if func.__name__ == 'nemu_connect':
- if result == 0:
- err = True
- else:
- if result > 0:
- err = True
- # Get to actual error message printed in std
- if err:
- logger.warning(f'Failed to call {func.__name__}, result={result}')
- with CaptureNemuIpc():
- result = self._ev.run_until_complete(self.ev_run_async(func, *args, **kwargs))
- return result
- def get_resolution(self):
- """
- Get emulator resolution, `self.width` and `self.height` will be set
- """
- if self.connect_id == 0:
- self.connect()
- width_ptr = ctypes.pointer(ctypes.c_int(0))
- height_ptr = ctypes.pointer(ctypes.c_int(0))
- nullptr = ctypes.POINTER(ctypes.c_int)()
- ret = self.ev_run_sync(
- self.lib.nemu_capture_display,
- self.connect_id, self.display_id, 0, width_ptr, height_ptr, nullptr
- )
- if ret > 0:
- raise NemuIpcError('nemu_capture_display failed during get_resolution()')
- self.width = width_ptr.contents.value
- self.height = height_ptr.contents.value
- @retry
- def screenshot(self):
- """
- Returns:
- np.ndarray: Image array in RGBA color space
- Note that image is upside down
- """
- if self.connect_id == 0:
- self.connect()
- self.get_resolution()
- width_ptr = ctypes.pointer(ctypes.c_int(self.width))
- height_ptr = ctypes.pointer(ctypes.c_int(self.height))
- length = self.width * self.height * 4
- pixels_pointer = ctypes.pointer((ctypes.c_ubyte * length)())
- ret = self.ev_run_sync(
- self.lib.nemu_capture_display,
- self.connect_id, self.display_id, length, width_ptr, height_ptr, pixels_pointer
- )
- if ret > 0:
- raise NemuIpcError('nemu_capture_display failed during screenshot()')
- # image = np.ctypeslib.as_array(pixels_pointer, shape=(self.height, self.width, 4))
- image = np.ctypeslib.as_array(pixels_pointer.contents).reshape((self.height, self.width, 4))
- return image
- def convert_xy(self, x, y):
- """
- Convert classic ADB coordinates to Nemu's
- `self.height` must be updated before calling this method
- Returns:
- int, int
- """
- x, y = int(x), int(y)
- x, y = self.height - y, x
- return x, y
- @retry
- def down(self, x, y):
- """
- Contact down, continuous contact down will be considered as swipe
- """
- if self.connect_id == 0:
- self.connect()
- if self.height == 0:
- self.get_resolution()
- x, y = self.convert_xy(x, y)
- ret = self.ev_run_sync(
- self.lib.nemu_input_event_touch_down,
- self.connect_id, self.display_id, x, y
- )
- if ret > 0:
- raise NemuIpcError('nemu_input_event_touch_down failed')
- @retry
- def up(self):
- """
- Contact up
- """
- if self.connect_id == 0:
- self.connect()
- ret = self.ev_run_sync(
- self.lib.nemu_input_event_touch_up,
- self.connect_id, self.display_id
- )
- if ret > 0:
- raise NemuIpcError('nemu_input_event_touch_up failed')
- def serial_to_id(serial: str):
- """
- Predict instance ID from serial
- E.g.
- "127.0.0.1:16384" -> 0
- "127.0.0.1:16416" -> 1
- Returns:
- int: instance_id, or None if failed to predict
- """
- try:
- port = int(serial.split(':')[1])
- except (IndexError, ValueError):
- return None
- index, offset = divmod(port - 16384, 32)
- if 0 <= index < 32 and offset in [0, 1, 2]:
- return index
- else:
- return None
- class NemuIpc():
- @cached_property
- def nemu_ipc(self) -> NemuIpcImpl:
- """
- Initialize a nemu ipc implementation
- """
- # Try existing settings first
- if self.config.script.device.emulatorinfo_path:
- folder = str(Path(self.config.script.device.emulatorinfo_path).parent.parent)
- index = serial_to_id(self.serial)
- if index is not None:
- try:
- return NemuIpcImpl(
- nemu_folder=folder,
- instance_id=index,
- display_id=0
- ).__enter__()
- except (NemuIpcIncompatible, NemuIpcError) as e:
- logger.error(e)
- logger.error('Emulator info incorrect')
- # Search emulator instance
- # with E:\ProgramFiles\MuMuPlayer-12.0\shell\MuMuPlayer.exe
- # installation path is E:\ProgramFiles\MuMuPlayer-12.0
- if self.emulator_instance is None:
- logger.error('Unable to use NemuIpc because emulator instance not found')
- raise RequestHumanTakeover
- try:
- return NemuIpcImpl(
- nemu_folder=self.emulator_instance.emulator.abspath('../'),
- instance_id=self.emulator_instance.MuMuPlayer12_id,
- display_id=0
- ).__enter__()
- except (NemuIpcIncompatible, NemuIpcError) as e:
- logger.error(e)
- logger.error('Unable to initialize NemuIpc')
- raise RequestHumanTakeover
- def nemu_ipc_available(self) -> bool:
- if not self.is_mumu_family:
- return False
- if self.nemud_app_keep_alive == '':
- return False
- try:
- _ = self.nemu_ipc
- except RequestHumanTakeover:
- return False
- return True
- def nemu_ipc_release(self):
- if has_cached_property(self, 'nemu_ipc'):
- self.nemu_ipc.disconnect()
- del_cached_property(self, 'nemu_ipc')
- logger.info('nemu_ipc released')
- def screenshot_nemu_ipc(self):
- image = self.nemu_ipc.screenshot()
- image = cv2.cvtColor(image, cv2.COLOR_BGRA2BGR)
- cv2.flip(image, 0, dst=image)
- return image
- def click_nemu_ipc(self, x, y):
- down = ensure_time((0.010, 0.020))
- self.nemu_ipc.down(x, y)
- self.sleep(down)
- self.nemu_ipc.up()
- self.sleep(0.050 - down)
- def long_click_nemu_ipc(self, x, y, duration=1.0):
- self.nemu_ipc.down(x, y)
- self.sleep(duration)
- self.nemu_ipc.up()
- self.sleep(0.050)
- def swipe_nemu_ipc(self, p1, p2):
- points = insert_swipe(p0=p1, p3=p2)
- for point in points:
- self.nemu_ipc.down(*point)
- self.sleep(0.010)
- self.nemu_ipc.up()
- self.sleep(0.050)
- def drag_nemu_ipc(self, p1, p2, point_random=(-10, -10, 10, 10)):
- p1 = np.array(p1) - random_rectangle_point(point_random)
- p2 = np.array(p2) - random_rectangle_point(point_random)
- points = insert_swipe(p0=p1, p3=p2, speed=20)
- for point in points:
- self.nemu_ipc.down(*point)
- self.sleep(0.010)
- self.nemu_ipc.down(*p2)
- self.sleep(0.140)
- self.nemu_ipc.down(*p2)
- self.sleep(0.140)
- self.nemu_ipc.up()
- self.sleep(0.050)
|