Explorar o código

feat(device): uiautomator_2

runhey %!s(int64=3) %!d(string=hai) anos
pai
achega
42511a6377

+ 43 - 0
module/base/utils.py

@@ -51,3 +51,46 @@ def ensure_time(second, n=3, precision=3):
             return int(second)
             return int(second)
     else:
     else:
         return second
         return second
+
+
+def point2str(x, y, length=4):
+    """
+    Args:
+        x (int, float):
+        y (int, float):
+        length (int): Align length.
+
+    Returns:
+        str: String with numbers right aligned, such as '( 100,  80)'.
+    """
+    return '(%s, %s)' % (str(int(x)).rjust(length), str(int(y)).rjust(length))
+
+
+def random_rectangle_point(area, n=3):
+    """Choose a random point in an area.
+
+    Args:
+        area: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
+        n (int): The amount of numbers in simulation. Default to 3.
+
+    Returns:
+        tuple(int): (x, y)
+    """
+    x = random_normal_distribution_int(area[0], area[2], n=n)
+    y = random_normal_distribution_int(area[1], area[3], n=n)
+    return x, y
+
+def random_line_segments(p1, p2, n, random_range=(0, 0, 0, 0)):
+    """Cut a line into multiple segments.
+
+    Args:
+        p1: (x, y).
+        p2: (x, y).
+        n: Number of slice.
+        random_range: Add a random_range to points.
+
+    Returns:
+        list[tuple]: [(x0, y0), (x1, y1), (x2, y2)]
+    """
+    return [tuple((((n - index) * p1 + index * p2) / n).astype(int) + random_rectangle_point(random_range))
+            for index in range(0, n + 1)]

+ 99 - 0
module/config/server.py

@@ -0,0 +1,99 @@
+"""
+This file stores server, such as 'cn', 'en'.
+Use 'import module.config.server as server' to import, don't use 'from xxx import xxx'.
+"""
+server = 'cn'  # Setting default to cn, will avoid errors when using dev_tools
+
+VALID_SERVER = ['cn', 'en', 'jp', 'tw']
+VALID_PACKAGE = {
+    'com.netease.onmyoji.wyzymnqsd_cps': 'cn'
+}
+VALID_CHANNEL_PACKAGE = {
+    # App stores
+    'com.bilibili.blhx.huawei': ('cn', '华为'),
+    'com.bilibili.blhx.mi': ('cn', '小米'),
+    'com.tencent.tmgp.bilibili.blhx': ('cn', '腾讯应用宝'),
+    'com.bilibili.blhx.baidu': ('cn', '百度'),
+    'com.bilibili.blhx.qihoo': ('cn', '360'),
+    'com.bilibili.blhx.nearme.gamecenter': ('cn', 'oppo'),
+    'com.bilibili.blhx.vivo': ('cn', 'vivo'),
+    'com.bilibili.blhx.mz': ('cn', '魅族'),
+
+    # 3rd party gaming platforms
+    'com.bilibili.blhx.uc': ('cn', 'UC九游'),
+    'com.bilibili.blhx.mzw': ('cn', '拇指玩'),
+    'com.yiwu.blhx.yx15': ('cn', '一五游戏'),
+    'com.bilibili.blhx.m4399': ('cn', '4399')
+}
+VALID_SERVER_LIST = {
+    'cn_android': [
+        '莱茵演习', '巴巴罗萨', '霸王行动', '冰山行动', '彩虹计划',
+        '发电机计划', '瞭望台行动', '十字路口行动', '朱诺行动',
+        '杜立特空袭', '地狱犬行动', '开罗宣言', '奥林匹克行动',
+        '小王冠行动', '波茨坦公告', '白色方案', '瓦尔基里行动',
+        '曼哈顿计划', '八月风暴', '秋季旅行', '水星行动', '莱茵河卫兵',
+        '北极光计划', '长戟计划'
+    ],
+    'cn_ios': [
+        '夏威夷', '珊瑚海', '中途岛', '铁底湾', '所罗门', '马里亚纳',
+        '莱特湾', '硫磺岛', '冲绳岛', '阿留申群岛', '马耳他'
+    ],
+    'cn_channel': [
+        '皇家巡游', '大西洋宪章', '十字军行动', '龙骑兵行动', '冥王星行动'
+    ],
+    'en': [
+        'Avrora', 'Lexington', 'Sandy', 'Washington', 'Amagi',
+        'Little Enterprise'
+    ],
+    'jp': [
+        'ブレスト', '横須賀', '佐世保', '呉', '舞鶴',
+        'ルルイエ', 'サモア', '大湊', 'トラック', 'ラバウル',
+        '鹿児島', 'マドラス', 'サンディエゴ', '竹敷', 'キール',
+        '若松', 'オデッサ', 'スイートバン'
+    ]
+}
+
+
+def set_server(package_or_server: str):
+    """
+    Change server and this will effect globally,
+    including assets and server specific methods.
+
+    Args:
+        package_or_server: package name or server.
+    """
+    global server
+    server = to_server(package_or_server)
+
+    # from module.base.resource import release_resources
+    # release_resources()
+
+
+def to_server(package_or_server: str) -> str:
+    """
+    Convert package/server to server.
+    To unknown packages, consider they are a CN channel servers.
+    """
+    if package_or_server in VALID_SERVER:
+        return package_or_server
+    elif package_or_server in VALID_PACKAGE:
+        return VALID_PACKAGE[package_or_server]
+    elif package_or_server in VALID_CHANNEL_PACKAGE:
+        return VALID_CHANNEL_PACKAGE[package_or_server][0]
+    else:
+        return 'cn'
+
+
+def to_package(package_or_server: str) -> str:
+    """
+    Convert package/server to package.
+    """
+    package_or_server = package_or_server.lower()
+    if package_or_server in VALID_PACKAGE:
+        return package_or_server
+
+    for key, value in VALID_PACKAGE.items():
+        if value == package_or_server:
+            return key
+
+    raise ValueError(f'Server invalid: {package_or_server}')

+ 3 - 2
module/device/connection.py

@@ -20,6 +20,7 @@ from module.device.method.utils import (
     handle_adb_error, PackageNotInstalled,
     handle_adb_error, PackageNotInstalled,
     recv_all, possible_reasons,
     recv_all, possible_reasons,
     random_port, get_serial_pair)
     random_port, get_serial_pair)
+from module.config.server import set_server
 from module.exception import RequestHumanTakeover, EmulatorNotRunningError
 from module.exception import RequestHumanTakeover, EmulatorNotRunningError
 from module.logger import logger
 from module.logger import logger
 from module.map.map_grids import SelectedGrids
 from module.map.map_grids import SelectedGrids
@@ -108,7 +109,7 @@ class Connection(ConnectionAttr):
             self.detect_package()
             self.detect_package()
         else:
         else:
             pass
             pass
-            # set_server(self.package)
+            set_server(self.package)
         logger.attr('PackageName', self.package)
         logger.attr('PackageName', self.package)
         # logger.attr('Server', self.config.SERVER)
         # logger.attr('Server', self.config.SERVER)
 
 
@@ -842,7 +843,7 @@ class Connection(ConnectionAttr):
                 self.config.Emulator_PackageName = self.package
                 self.config.Emulator_PackageName = self.package
             # Set server
             # Set server
             logger.info('Server changed, release resources')
             logger.info('Server changed, release resources')
-            # set_server(self.package)
+            set_server(self.package)
         else:
         else:
             logger.critical(
             logger.critical(
                 f'Multiple {keywords[0]} packages found, auto package detection cannot decide which to choose, '
                 f'Multiple {keywords[0]} packages found, auto package detection cannot decide which to choose, '

+ 570 - 0
module/device/method/minitouch.py

@@ -0,0 +1,570 @@
+import asyncio
+import json
+import re
+import socket
+import time
+from functools import wraps
+from typing import List
+
+import websockets
+from adbutils.errors import AdbError
+from uiautomator2 import _Service
+
+from module.base.decorator import Config, cached_property, del_cached_property
+from module.base.timer import Timer
+from module.base.utils import *
+from module.device.connection import Connection
+from module.device.method.utils import RETRY_TRIES, retry_sleep, handle_adb_error
+from module.exception import RequestHumanTakeover, ScriptError
+from module.logger import logger
+
+
+def random_normal_distribution(a, b, n=5):
+    output = np.mean(np.random.uniform(a, b, size=n))
+    return output
+
+
+def random_theta():
+    theta = np.random.uniform(0, 2 * np.pi)
+    return np.array([np.sin(theta), np.cos(theta)])
+
+
+def random_rho(dis):
+    return random_normal_distribution(-dis, dis)
+
+
+def insert_swipe(p0, p3, speed=15, min_distance=10):
+    """
+    Insert way point from start to end.
+    First generate a cubic bézier curve
+
+    Args:
+        p0: Start point.
+        p3: End point.
+        speed: Average move speed, pixels per 10ms.
+        min_distance:
+
+    Returns:
+        list[list[int]]: List of points.
+
+    Examples:
+        > insert_swipe((400, 400), (600, 600), speed=20)
+        [[400, 400], [406, 406], [416, 415], [429, 428], [444, 442], [462, 459], [481, 478], [504, 500], [527, 522],
+        [545, 540], [560, 557], [573, 570], [584, 582], [592, 590], [597, 596], [600, 600]]
+    """
+    p0 = np.array(p0)
+    p3 = np.array(p3)
+
+    # Random control points in Bézier curve
+    distance = np.linalg.norm(p3 - p0)
+    p1 = 2 / 3 * p0 + 1 / 3 * p3 + random_theta() * random_rho(distance * 0.1)
+    p2 = 1 / 3 * p0 + 2 / 3 * p3 + random_theta() * random_rho(distance * 0.1)
+
+    # Random `t` on Bézier curve, sparse in the middle, dense at start and end
+    segments = max(int(distance / speed) + 1, 5)
+    lower = random_normal_distribution(-85, -60)
+    upper = random_normal_distribution(80, 90)
+    theta = np.arange(lower + 0., upper + 0.0001, (upper - lower) / segments)
+    ts = np.sin(theta / 180 * np.pi)
+    ts = np.sign(ts) * abs(ts) ** 0.9
+    ts = (ts - min(ts)) / (max(ts) - min(ts))
+
+    # Generate cubic Bézier curve
+    points = []
+    prev = (-100, -100)
+    for t in ts:
+        point = p0 * (1 - t) ** 3 + 3 * p1 * t * (1 - t) ** 2 + 3 * p2 * t ** 2 * (1 - t) + p3 * t ** 3
+        point = point.astype(np.int).tolist()
+        if np.linalg.norm(np.subtract(point, prev)) < min_distance:
+            continue
+
+        points.append(point)
+        prev = point
+
+    # Delete nearing points
+    if len(points[1:]):
+        distance = np.linalg.norm(np.subtract(points[1:], points[0]), axis=1)
+        mask = np.append(True, distance > min_distance)
+        points = np.array(points)[mask].tolist()
+    else:
+        points = [p0, p3]
+
+    return points
+
+
+class Command:
+    def __init__(
+            self,
+            operation: str,
+            contact: int = 0,
+            x: int = 0,
+            y: int = 0,
+            ms: int = 10,
+            pressure: int = 100
+    ):
+        """
+        See https://github.com/openstf/minitouch#writable-to-the-socket
+
+        Args:
+            operation: c, r, d, m, u, w
+            contact:
+            x:
+            y:
+            ms:
+            pressure:
+        """
+        self.operation = operation
+        self.contact = contact
+        self.x = x
+        self.y = y
+        self.ms = ms
+        self.pressure = pressure
+
+    def to_minitouch(self) -> str:
+        """
+        String that write into minitouch socket
+        """
+        if self.operation == 'c':
+            return f'{self.operation}\n'
+        elif self.operation == 'r':
+            return f'{self.operation}\n'
+        elif self.operation == 'd':
+            return f'{self.operation} {self.contact} {self.x} {self.y} {self.pressure}\n'
+        elif self.operation == 'm':
+            return f'{self.operation} {self.contact} {self.x} {self.y} {self.pressure}\n'
+        elif self.operation == 'u':
+            return f'{self.operation} {self.contact}\n'
+        elif self.operation == 'w':
+            return f'{self.operation} {self.ms}\n'
+        else:
+            return ''
+
+    def to_atx_agent(self, max_x=1280, max_y=720) -> str:
+        """
+        Dict that send to atx-agent, $DEVICE_URL/minitouch
+        See https://github.com/openatx/atx-agent#minitouch%E6%93%8D%E4%BD%9C%E6%96%B9%E6%B3%95
+        """
+        x, y = self.x / max_x, self.y / max_y
+        if self.operation == 'c':
+            out = dict(operation=self.operation)
+        elif self.operation == 'r':
+            out = dict(operation=self.operation)
+        elif self.operation == 'd':
+            out = dict(operation=self.operation, index=self.contact, pressure=self.pressure, xP=x, yP=y)
+        elif self.operation == 'm':
+            out = dict(operation=self.operation, index=self.contact, pressure=self.pressure, xP=x, yP=y)
+        elif self.operation == 'u':
+            out = dict(operation=self.operation, index=self.contact)
+        elif self.operation == 'w':
+            out = dict(operation=self.operation, milliseconds=self.ms)
+        else:
+            out = dict()
+        return json.dumps(out)
+
+
+class CommandBuilder:
+    """Build command str for minitouch.
+
+    You can use this, to custom actions as you wish::
+
+        with safe_connection(_DEVICE_ID) as connection:
+            builder = CommandBuilder()
+            builder.down(0, 400, 400, 50)
+            builder.commit()
+            builder.move(0, 500, 500, 50)
+            builder.commit()
+            builder.move(0, 800, 400, 50)
+            builder.commit()
+            builder.up(0)
+            builder.commit()
+            builder.publish(connection)
+
+    """
+    DEFAULT_DELAY = 0.05
+    max_x = 1280
+    max_y = 720
+
+    def __init__(self, device):
+        """
+        Args:
+            device:
+        """
+        self.device = device
+        self.commands = []
+        self.delay = 0
+
+    def convert(self, x, y):
+        max_x, max_y = self.device.max_x, self.device.max_y
+        orientation = self.device.orientation
+
+        if orientation == 0:
+            pass
+        elif orientation == 1:
+            x, y = 720 - y, x
+            max_x, max_y = max_y, max_x
+        elif orientation == 2:
+            x, y = 1280 - x, 720 - y
+        elif orientation == 3:
+            x, y = y, 1280 - x
+            max_x, max_y = max_y, max_x
+        else:
+            raise ScriptError(f'Invalid device orientation: {orientation}')
+
+        self.max_x, self.max_y = max_x, max_y
+        if not self.device.config.DEVICE_OVER_HTTP:
+            # Maximum X and Y coordinates may, but usually do not, match the display size.
+            x, y = int(x / 1280 * max_x), int(y / 720 * max_y)
+        else:
+            # When over http, max_x and max_y are default to 1280 and 720, skip matching display size
+            x, y = int(x), int(y)
+        return x, y
+
+    def commit(self):
+        """ add minitouch command: 'c\n' """
+        self.commands.append(Command('c'))
+        return self
+
+    def reset(self):
+        """ add minitouch command: 'r\n' """
+        self.commands.append(Command('r'))
+        return self
+
+    def wait(self, ms=10):
+        """ add minitouch command: 'w <ms>\n' """
+        self.commands.append(Command('w', ms=ms))
+        self.delay += ms
+        return self
+
+    def up(self, contact=0):
+        """ add minitouch command: 'u <contact>\n' """
+        self.commands.append(Command('u', contact=contact))
+        return self
+
+    def down(self, x, y, contact=0, pressure=100):
+        """ add minitouch command: 'd <contact> <x> <y> <pressure>\n' """
+        x, y = self.convert(x, y)
+        self.commands.append(Command('d', x=x, y=y, contact=contact, pressure=pressure))
+        return self
+
+    def move(self, x, y, contact=0, pressure=100):
+        """ add minitouch command: 'm <contact> <x> <y> <pressure>\n' """
+        x, y = self.convert(x, y)
+        self.commands.append(Command('m', x=x, y=y, contact=contact, pressure=pressure))
+        return self
+
+    def clear(self):
+        """ clear current commands """
+        self.commands = []
+        self.delay = 0
+
+    def to_minitouch(self) -> str:
+        return ''.join([command.to_minitouch() for command in self.commands])
+
+    def to_atx_agent(self) -> List[str]:
+        return [command.to_atx_agent(self.max_x, self.max_y) for command in self.commands]
+
+
+class MinitouchNotInstalledError(Exception):
+    pass
+
+
+class MinitouchOccupiedError(Exception):
+    pass
+
+
+class U2Service(_Service):
+    def __init__(self, name, u2obj):
+        self.name = name
+        self.u2obj = u2obj
+        self.service_url = self.u2obj.path2url("/services/" + name)
+
+
+def retry(func):
+    @wraps(func)
+    def retry_wrapper(self, *args, **kwargs):
+        """
+        Args:
+            self (Minitouch):
+        """
+        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
+            # When adb server was killed
+            except ConnectionResetError as e:
+                logger.error(e)
+
+                def init():
+                    self.adb_reconnect()
+            # Emulator closed
+            except ConnectionAbortedError as e:
+                logger.error(e)
+
+                def init():
+                    self.adb_reconnect()
+            # MinitouchNotInstalledError: Received empty data from minitouch
+            except MinitouchNotInstalledError as e:
+                logger.error(e)
+
+                def init():
+                    self.install_uiautomator2()
+                    if self._minitouch_port:
+                        self.adb_forward_remove(f'tcp:{self._minitouch_port}')
+                    del_cached_property(self, 'minitouch_builder')
+            # MinitouchOccupiedError: Timeout when connecting to minitouch
+            except MinitouchOccupiedError as e:
+                logger.error(e)
+
+                def init():
+                    self.restart_atx()
+                    if self._minitouch_port:
+                        self.adb_forward_remove(f'tcp:{self._minitouch_port}')
+                    del_cached_property(self, 'minitouch_builder')
+            # AdbError
+            except AdbError as e:
+                if handle_adb_error(e):
+                    def init():
+                        self.adb_reconnect()
+                else:
+                    break
+            except BrokenPipeError as e:
+                logger.error(e)
+
+                def init():
+                    del_cached_property(self, 'minitouch_builder')
+            # 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 Minitouch(Connection):
+    _minitouch_port: int = 0
+    _minitouch_client: socket.socket
+    _minitouch_pid: int
+    _minitouch_ws: websockets.WebSocketClientProtocol
+    max_x: int
+    max_y: int
+
+    @cached_property
+    def minitouch_builder(self):
+        self.minitouch_init()
+        return CommandBuilder(self)
+
+    @Config.when(DEVICE_OVER_HTTP=False)
+    def minitouch_init(self):
+        logger.hr('MiniTouch init')
+        max_x, max_y = 1280, 720
+        max_contacts = 2
+        max_pressure = 50
+        self.get_orientation()
+
+        self._minitouch_port = self.adb_forward("localabstract:minitouch")
+
+        # No need, minitouch already started by uiautomator2
+        # self.adb_shell([self.config.MINITOUCH_FILEPATH_REMOTE])
+
+        retry_timeout = Timer(2).start()
+        while 1:
+            client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            client.settimeout(1)
+            client.connect(('127.0.0.1', self._minitouch_port))
+            self._minitouch_client = client
+
+            # get minitouch server info
+            socket_out = client.makefile()
+
+            # v <version>
+            # protocol version, usually it is 1. needn't use this
+            try:
+                out = socket_out.readline().replace("\n", "").replace("\r", "")
+            except socket.timeout:
+                client.close()
+                raise MinitouchOccupiedError(
+                    'Timeout when connecting to minitouch, '
+                    'probably because another connection has been established'
+                )
+            logger.info(out)
+
+            # ^ <max-contacts> <max-x> <max-y> <max-pressure>
+            out = socket_out.readline().replace("\n", "").replace("\r", "")
+            logger.info(out)
+            try:
+                _, max_contacts, max_x, max_y, max_pressure, *_ = out.split(" ")
+                break
+            except ValueError:
+                client.close()
+                if retry_timeout.reached():
+                    raise MinitouchNotInstalledError(
+                        'Received empty data from minitouch, '
+                        'probably because minitouch is not installed'
+                    )
+                else:
+                    # Minitouch may not start that fast
+                    self.sleep(1)
+                    continue
+
+        # self.max_contacts = max_contacts
+        self.max_x = int(max_x)
+        self.max_y = int(max_y)
+        # self.max_pressure = max_pressure
+
+        # $ <pid>
+        out = socket_out.readline().replace("\n", "").replace("\r", "")
+        logger.info(out)
+        _, pid = out.split(" ")
+        self._minitouch_pid = pid
+
+        logger.info(
+            "minitouch running on port: {}, pid: {}".format(self._minitouch_port, self._minitouch_pid)
+        )
+        logger.info(
+            "max_contact: {}; max_x: {}; max_y: {}; max_pressure: {}".format(
+                max_contacts, max_x, max_y, max_pressure
+            )
+        )
+
+    @Config.when(DEVICE_OVER_HTTP=False)
+    def minitouch_send(self):
+        content = self.minitouch_builder.to_minitouch()
+        # logger.info("send operation: {}".format(content.replace("\n", "\\n")))
+        byte_content = content.encode('utf-8')
+        self._minitouch_client.sendall(byte_content)
+        self._minitouch_client.recv(0)
+        time.sleep(self.minitouch_builder.delay / 1000 + self.minitouch_builder.DEFAULT_DELAY)
+        self.minitouch_builder.clear()
+
+    @cached_property
+    def _minitouch_loop(self):
+        return asyncio.new_event_loop()
+
+    def _minitouch_loop_run(self, event):
+        """
+        Args:
+            event: Async function
+
+        Raises:
+            MinitouchOccupiedError
+        """
+        try:
+            return self._minitouch_loop.run_until_complete(event)
+        except websockets.ConnectionClosedError as e:
+            # ConnectionClosedError: no close frame received or sent
+            # ConnectionClosedError: sent 1011 (unexpected error) keepalive ping timeout; no close frame received
+            logger.error(e)
+            raise MinitouchOccupiedError(
+                'ConnectionClosedError, '
+                'probably because another connection has been established'
+            )
+
+    @Config.when(DEVICE_OVER_HTTP=True)
+    def minitouch_init(self):
+        logger.hr('MiniTouch init')
+        self.max_x, self.max_y = 1280, 720
+        self.get_orientation()
+
+        logger.info('Stop minitouch service')
+        s = U2Service('minitouch', self.u2)
+        s.stop()
+        while 1:
+            if not s.running():
+                break
+            self.sleep(0.05)
+
+        logger.info('Start minitouch service')
+        s.start()
+        while 1:
+            if s.running():
+                break
+            self.sleep(0.05)
+
+        # 'ws://127.0.0.1:7912/minitouch'
+        url = re.sub(r"^https?://", 'ws://', self.serial) + '/minitouch'
+        logger.attr('Minitouch', url)
+
+        async def connect():
+            ws = await websockets.connect(url)
+            # start @minitouch service
+            logger.info(await ws.recv())
+            # dial unix:@minitouch
+            logger.info(await ws.recv())
+            return ws
+
+        self._minitouch_ws = self._minitouch_loop_run(connect())
+
+    @Config.when(DEVICE_OVER_HTTP=True)
+    def minitouch_send(self):
+        content = self.minitouch_builder.to_atx_agent()
+
+        async def send():
+            for row in content:
+                # logger.info("send operation: {}".format(row.replace("\n", "\\n")))
+                await self._minitouch_ws.send(row)
+
+        self._minitouch_loop_run(send())
+        time.sleep(self.minitouch_builder.delay / 1000 + self.minitouch_builder.DEFAULT_DELAY)
+        self.minitouch_builder.clear()
+
+    @retry
+    def click_minitouch(self, x, y):
+        builder = self.minitouch_builder
+        builder.down(x, y).commit()
+        builder.up().commit()
+        self.minitouch_send()
+
+    @retry
+    def long_click_minitouch(self, x, y, duration=1.0):
+        duration = int(duration * 1000)
+        builder = self.minitouch_builder
+        builder.down(x, y).commit().wait(duration)
+        builder.up().commit()
+        self.minitouch_send()
+
+    @retry
+    def swipe_minitouch(self, p1, p2):
+        points = insert_swipe(p0=p1, p3=p2)
+        builder = self.minitouch_builder
+
+        builder.down(*points[0]).commit()
+        self.minitouch_send()
+
+        for point in points[1:]:
+            builder.move(*point).commit().wait(10)
+        self.minitouch_send()
+
+        builder.up().commit()
+        self.minitouch_send()
+
+    @retry
+    def drag_minitouch(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)
+        builder = self.minitouch_builder
+
+        builder.down(*points[0]).commit()
+        self.minitouch_send()
+
+        for point in points[1:]:
+            builder.move(*point).commit().wait(10)
+        self.minitouch_send()
+
+        builder.move(*p2).commit().wait(140)
+        builder.move(*p2).commit().wait(140)
+        self.minitouch_send()
+
+        builder.up().commit()
+        self.minitouch_send()

+ 1 - 0
module/device/method/scrcpy/__init__.py

@@ -0,0 +1 @@
+from .scrcpy import Scrcpy, ScrcpyError

+ 326 - 0
module/device/method/scrcpy/const.py

@@ -0,0 +1,326 @@
+"""
+This module includes all consts used in this project
+"""
+
+# Action
+ACTION_DOWN = 0
+ACTION_UP = 1
+ACTION_MOVE = 2
+
+# KeyCode
+KEYCODE_UNKNOWN = 0
+KEYCODE_SOFT_LEFT = 1
+KEYCODE_SOFT_RIGHT = 2
+KEYCODE_HOME = 3
+KEYCODE_BACK = 4
+KEYCODE_CALL = 5
+KEYCODE_ENDCALL = 6
+KEYCODE_0 = 7
+KEYCODE_1 = 8
+KEYCODE_2 = 9
+KEYCODE_3 = 10
+KEYCODE_4 = 11
+KEYCODE_5 = 12
+KEYCODE_6 = 13
+KEYCODE_7 = 14
+KEYCODE_8 = 15
+KEYCODE_9 = 16
+KEYCODE_STAR = 17
+KEYCODE_POUND = 18
+KEYCODE_DPAD_UP = 19
+KEYCODE_DPAD_DOWN = 20
+KEYCODE_DPAD_LEFT = 21
+KEYCODE_DPAD_RIGHT = 22
+KEYCODE_DPAD_CENTER = 23
+KEYCODE_VOLUME_UP = 24
+KEYCODE_VOLUME_DOWN = 25
+KEYCODE_POWER = 26
+KEYCODE_CAMERA = 27
+KEYCODE_CLEAR = 28
+KEYCODE_A = 29
+KEYCODE_B = 30
+KEYCODE_C = 31
+KEYCODE_D = 32
+KEYCODE_E = 33
+KEYCODE_F = 34
+KEYCODE_G = 35
+KEYCODE_H = 36
+KEYCODE_I = 37
+KEYCODE_J = 38
+KEYCODE_K = 39
+KEYCODE_L = 40
+KEYCODE_M = 41
+KEYCODE_N = 42
+KEYCODE_O = 43
+KEYCODE_P = 44
+KEYCODE_Q = 45
+KEYCODE_R = 46
+KEYCODE_S = 47
+KEYCODE_T = 48
+KEYCODE_U = 49
+KEYCODE_V = 50
+KEYCODE_W = 51
+KEYCODE_X = 52
+KEYCODE_Y = 53
+KEYCODE_Z = 54
+KEYCODE_COMMA = 55
+KEYCODE_PERIOD = 56
+KEYCODE_ALT_LEFT = 57
+KEYCODE_ALT_RIGHT = 58
+KEYCODE_SHIFT_LEFT = 59
+KEYCODE_SHIFT_RIGHT = 60
+KEYCODE_TAB = 61
+KEYCODE_SPACE = 62
+KEYCODE_SYM = 63
+KEYCODE_EXPLORER = 64
+KEYCODE_ENVELOPE = 65
+KEYCODE_ENTER = 66
+KEYCODE_DEL = 67
+KEYCODE_GRAVE = 68
+KEYCODE_MINUS = 69
+KEYCODE_EQUALS = 70
+KEYCODE_LEFT_BRACKET = 71
+KEYCODE_RIGHT_BRACKET = 72
+KEYCODE_BACKSLASH = 73
+KEYCODE_SEMICOLON = 74
+KEYCODE_APOSTROPHE = 75
+KEYCODE_SLASH = 76
+KEYCODE_AT = 77
+KEYCODE_NUM = 78
+KEYCODE_HEADSETHOOK = 79
+KEYCODE_PLUS = 81
+KEYCODE_MENU = 82
+KEYCODE_NOTIFICATION = 83
+KEYCODE_SEARCH = 84
+KEYCODE_MEDIA_PLAY_PAUSE = 85
+KEYCODE_MEDIA_STOP = 86
+KEYCODE_MEDIA_NEXT = 87
+KEYCODE_MEDIA_PREVIOUS = 88
+KEYCODE_MEDIA_REWIND = 89
+KEYCODE_MEDIA_FAST_FORWARD = 90
+KEYCODE_MUTE = 91
+KEYCODE_PAGE_UP = 92
+KEYCODE_PAGE_DOWN = 93
+KEYCODE_BUTTON_A = 96
+KEYCODE_BUTTON_B = 97
+KEYCODE_BUTTON_C = 98
+KEYCODE_BUTTON_X = 99
+KEYCODE_BUTTON_Y = 100
+KEYCODE_BUTTON_Z = 101
+KEYCODE_BUTTON_L1 = 102
+KEYCODE_BUTTON_R1 = 103
+KEYCODE_BUTTON_L2 = 104
+KEYCODE_BUTTON_R2 = 105
+KEYCODE_BUTTON_THUMBL = 106
+KEYCODE_BUTTON_THUMBR = 107
+KEYCODE_BUTTON_START = 108
+KEYCODE_BUTTON_SELECT = 109
+KEYCODE_BUTTON_MODE = 110
+KEYCODE_ESCAPE = 111
+KEYCODE_FORWARD_DEL = 112
+KEYCODE_CTRL_LEFT = 113
+KEYCODE_CTRL_RIGHT = 114
+KEYCODE_CAPS_LOCK = 115
+KEYCODE_SCROLL_LOCK = 116
+KEYCODE_META_LEFT = 117
+KEYCODE_META_RIGHT = 118
+KEYCODE_FUNCTION = 119
+KEYCODE_SYSRQ = 120
+KEYCODE_BREAK = 121
+KEYCODE_MOVE_HOME = 122
+KEYCODE_MOVE_END = 123
+KEYCODE_INSERT = 124
+KEYCODE_FORWARD = 125
+KEYCODE_MEDIA_PLAY = 126
+KEYCODE_MEDIA_PAUSE = 127
+KEYCODE_MEDIA_CLOSE = 128
+KEYCODE_MEDIA_EJECT = 129
+KEYCODE_MEDIA_RECORD = 130
+KEYCODE_F1 = 131
+KEYCODE_F2 = 132
+KEYCODE_F3 = 133
+KEYCODE_F4 = 134
+KEYCODE_F5 = 135
+KEYCODE_F6 = 136
+KEYCODE_F7 = 137
+KEYCODE_F8 = 138
+KEYCODE_F9 = 139
+KEYCODE_F10 = 140
+KEYCODE_F11 = 141
+KEYCODE_F12 = 142
+KEYCODE_NUM_LOCK = 143
+KEYCODE_NUMPAD_0 = 144
+KEYCODE_NUMPAD_1 = 145
+KEYCODE_NUMPAD_2 = 146
+KEYCODE_NUMPAD_3 = 147
+KEYCODE_NUMPAD_4 = 148
+KEYCODE_NUMPAD_5 = 149
+KEYCODE_NUMPAD_6 = 150
+KEYCODE_NUMPAD_7 = 151
+KEYCODE_NUMPAD_8 = 152
+KEYCODE_NUMPAD_9 = 153
+KEYCODE_NUMPAD_DIVIDE = 154
+KEYCODE_NUMPAD_MULTIPLY = 155
+KEYCODE_NUMPAD_SUBTRACT = 156
+KEYCODE_NUMPAD_ADD = 157
+KEYCODE_NUMPAD_DOT = 158
+KEYCODE_NUMPAD_COMMA = 159
+KEYCODE_NUMPAD_ENTER = 160
+KEYCODE_NUMPAD_EQUALS = 161
+KEYCODE_NUMPAD_LEFT_PAREN = 162
+KEYCODE_NUMPAD_RIGHT_PAREN = 163
+KEYCODE_VOLUME_MUTE = 164
+KEYCODE_INFO = 165
+KEYCODE_CHANNEL_UP = 166
+KEYCODE_CHANNEL_DOWN = 167
+KEYCODE_ZOOM_IN = 168
+KEYCODE_ZOOM_OUT = 169
+KEYCODE_TV = 170
+KEYCODE_WINDOW = 171
+KEYCODE_GUIDE = 172
+KEYCODE_DVR = 173
+KEYCODE_BOOKMARK = 174
+KEYCODE_CAPTIONS = 175
+KEYCODE_SETTINGS = 176
+KEYCODE_TV_POWER = 177
+KEYCODE_TV_INPUT = 178
+KEYCODE_STB_POWER = 179
+KEYCODE_STB_INPUT = 180
+KEYCODE_AVR_POWER = 181
+KEYCODE_AVR_INPUT = 182
+KEYCODE_PROG_RED = 183
+KEYCODE_PROG_GREEN = 184
+KEYCODE_PROG_YELLOW = 185
+KEYCODE_PROG_BLUE = 186
+KEYCODE_APP_SWITCH = 187
+KEYCODE_BUTTON_1 = 188
+KEYCODE_BUTTON_2 = 189
+KEYCODE_BUTTON_3 = 190
+KEYCODE_BUTTON_4 = 191
+KEYCODE_BUTTON_5 = 192
+KEYCODE_BUTTON_6 = 193
+KEYCODE_BUTTON_7 = 194
+KEYCODE_BUTTON_8 = 195
+KEYCODE_BUTTON_9 = 196
+KEYCODE_BUTTON_10 = 197
+KEYCODE_BUTTON_11 = 198
+KEYCODE_BUTTON_12 = 199
+KEYCODE_BUTTON_13 = 200
+KEYCODE_BUTTON_14 = 201
+KEYCODE_BUTTON_15 = 202
+KEYCODE_BUTTON_16 = 203
+KEYCODE_LANGUAGE_SWITCH = 204
+KEYCODE_MANNER_MODE = 205
+KEYCODE_3D_MODE = 206
+KEYCODE_CONTACTS = 207
+KEYCODE_CALENDAR = 208
+KEYCODE_MUSIC = 209
+KEYCODE_CALCULATOR = 210
+KEYCODE_ZENKAKU_HANKAKU = 211
+KEYCODE_EISU = 212
+KEYCODE_MUHENKAN = 213
+KEYCODE_HENKAN = 214
+KEYCODE_KATAKANA_HIRAGANA = 215
+KEYCODE_YEN = 216
+KEYCODE_RO = 217
+KEYCODE_KANA = 218
+KEYCODE_ASSIST = 219
+KEYCODE_BRIGHTNESS_DOWN = 220
+KEYCODE_BRIGHTNESS_UP = 221
+KEYCODE_MEDIA_AUDIO_TRACK = 222
+KEYCODE_SLEEP = 223
+KEYCODE_WAKEUP = 224
+KEYCODE_PAIRING = 225
+KEYCODE_MEDIA_TOP_MENU = 226
+KEYCODE_11 = 227
+KEYCODE_12 = 228
+KEYCODE_LAST_CHANNEL = 229
+KEYCODE_TV_DATA_SERVICE = 230
+KEYCODE_VOICE_ASSIST = 231
+KEYCODE_TV_RADIO_SERVICE = 232
+KEYCODE_TV_TELETEXT = 233
+KEYCODE_TV_NUMBER_ENTRY = 234
+KEYCODE_TV_TERRESTRIAL_ANALOG = 235
+KEYCODE_TV_TERRESTRIAL_DIGITAL = 236
+KEYCODE_TV_SATELLITE = 237
+KEYCODE_TV_SATELLITE_BS = 238
+KEYCODE_TV_SATELLITE_CS = 239
+KEYCODE_TV_SATELLITE_SERVICE = 240
+KEYCODE_TV_NETWORK = 241
+KEYCODE_TV_ANTENNA_CABLE = 242
+KEYCODE_TV_INPUT_HDMI_1 = 243
+KEYCODE_TV_INPUT_HDMI_2 = 244
+KEYCODE_TV_INPUT_HDMI_3 = 245
+KEYCODE_TV_INPUT_HDMI_4 = 246
+KEYCODE_TV_INPUT_COMPOSITE_1 = 247
+KEYCODE_TV_INPUT_COMPOSITE_2 = 248
+KEYCODE_TV_INPUT_COMPONENT_1 = 249
+KEYCODE_TV_INPUT_COMPONENT_2 = 250
+KEYCODE_TV_INPUT_VGA_1 = 251
+KEYCODE_TV_AUDIO_DESCRIPTION = 252
+KEYCODE_TV_AUDIO_DESCRIPTION_MIX_UP = 253
+KEYCODE_TV_AUDIO_DESCRIPTION_MIX_DOWN = 254
+KEYCODE_TV_ZOOM_MODE = 255
+KEYCODE_TV_CONTENTS_MENU = 256
+KEYCODE_TV_MEDIA_CONTEXT_MENU = 257
+KEYCODE_TV_TIMER_PROGRAMMING = 258
+KEYCODE_HELP = 259
+KEYCODE_NAVIGATE_PREVIOUS = 260
+KEYCODE_NAVIGATE_NEXT = 261
+KEYCODE_NAVIGATE_IN = 262
+KEYCODE_NAVIGATE_OUT = 263
+KEYCODE_STEM_PRIMARY = 264
+KEYCODE_STEM_1 = 265
+KEYCODE_STEM_2 = 266
+KEYCODE_STEM_3 = 267
+KEYCODE_DPAD_UP_LEFT = 268
+KEYCODE_DPAD_DOWN_LEFT = 269
+KEYCODE_DPAD_UP_RIGHT = 270
+KEYCODE_DPAD_DOWN_RIGHT = 271
+KEYCODE_MEDIA_SKIP_FORWARD = 272
+KEYCODE_MEDIA_SKIP_BACKWARD = 273
+KEYCODE_MEDIA_STEP_FORWARD = 274
+KEYCODE_MEDIA_STEP_BACKWARD = 275
+KEYCODE_SOFT_SLEEP = 276
+KEYCODE_CUT = 277
+KEYCODE_COPY = 278
+KEYCODE_PASTE = 279
+KEYCODE_SYSTEM_NAVIGATION_UP = 280
+KEYCODE_SYSTEM_NAVIGATION_DOWN = 281
+KEYCODE_SYSTEM_NAVIGATION_LEFT = 282
+KEYCODE_SYSTEM_NAVIGATION_RIGHT = 283
+KEYCODE_KEYCODE_ALL_APPS = 284
+KEYCODE_KEYCODE_REFRESH = 285
+KEYCODE_KEYCODE_THUMBS_UP = 286
+KEYCODE_KEYCODE_THUMBS_DOWN = 287
+
+# Event
+EVENT_INIT = "init"
+EVENT_FRAME = "frame"
+EVENT_DISCONNECT = "disconnect"
+
+# Type
+TYPE_INJECT_KEYCODE = 0
+TYPE_INJECT_TEXT = 1
+TYPE_INJECT_TOUCH_EVENT = 2
+TYPE_INJECT_SCROLL_EVENT = 3
+TYPE_BACK_OR_SCREEN_ON = 4
+TYPE_EXPAND_NOTIFICATION_PANEL = 5
+TYPE_EXPAND_SETTINGS_PANEL = 6
+TYPE_COLLAPSE_PANELS = 7
+TYPE_GET_CLIPBOARD = 8
+TYPE_SET_CLIPBOARD = 9
+TYPE_SET_SCREEN_POWER_MODE = 10
+TYPE_ROTATE_DEVICE = 11
+
+# Lock screen orientation
+LOCK_SCREEN_ORIENTATION_UNLOCKED = -1
+LOCK_SCREEN_ORIENTATION_INITIAL = -2
+LOCK_SCREEN_ORIENTATION_0 = 0
+LOCK_SCREEN_ORIENTATION_1 = 1
+LOCK_SCREEN_ORIENTATION_2 = 2
+LOCK_SCREEN_ORIENTATION_3 = 3
+
+# Screen power mode
+POWER_MODE_OFF = 0
+POWER_MODE_NORMAL = 2

+ 266 - 0
module/device/method/scrcpy/control.py

@@ -0,0 +1,266 @@
+import functools
+import socket
+import struct
+import time
+
+import module.device.method.scrcpy.const as const
+
+
+def inject(control_type: int):
+    """
+    Inject control code, with this inject, we will be able to do unit test
+
+    Args:
+        control_type: event to send, TYPE_*
+    """
+
+    def wrapper(f):
+        @functools.wraps(f)
+        def inner(self, *args, **kwargs):
+            package = struct.pack(">B", control_type) + f(self, *args, **kwargs)
+            if self.control_socket is not None:
+                with self.control_socket_lock:
+                    self.control_socket.send(package)
+            return package
+
+        return inner
+
+    return wrapper
+
+
+class ControlSender:
+    def __init__(self, parent):
+        self.parent = parent
+
+    @property
+    def control_socket(self):
+        return self.parent._scrcpy_control_socket
+
+    @property
+    def control_socket_lock(self):
+        return self.parent._scrcpy_control_socket_lock
+
+    @property
+    def resolution(self):
+        return self.parent._scrcpy_resolution
+
+    @inject(const.TYPE_INJECT_KEYCODE)
+    def keycode(
+            self, keycode: int, action: int = const.ACTION_DOWN, repeat: int = 0
+    ) -> bytes:
+        """
+        Send keycode to device
+
+        Args:
+            keycode: const.KEYCODE_*
+            action: ACTION_DOWN | ACTION_UP
+            repeat: repeat count
+        """
+        return struct.pack(">Biii", action, keycode, repeat, 0)
+
+    @inject(const.TYPE_INJECT_TEXT)
+    def text(self, text: str) -> bytes:
+        """
+        Send text to device
+
+        Args:
+            text: text to send
+        """
+
+        buffer = text.encode("utf-8")
+        return struct.pack(">i", len(buffer)) + buffer
+
+    @inject(const.TYPE_INJECT_TOUCH_EVENT)
+    def touch(
+            self, x: int, y: int, action: int = const.ACTION_DOWN, touch_id: int = -1
+    ) -> bytes:
+        """
+        Touch screen
+
+        Args:
+            x: horizontal position
+            y: vertical position
+            action: ACTION_DOWN | ACTION_UP | ACTION_MOVE
+            touch_id: Default using virtual id -1, you can specify it to emulate multi finger touch
+        """
+        x, y = max(x, 0), max(y, 0)
+        return struct.pack(
+            ">BqiiHHHi",
+            action,
+            touch_id,
+            int(x),
+            int(y),
+            int(self.resolution[0]),
+            int(self.resolution[1]),
+            0xFFFF,
+            1,
+        )
+
+    @inject(const.TYPE_INJECT_SCROLL_EVENT)
+    def scroll(self, x: int, y: int, h: int, v: int) -> bytes:
+        """
+        Scroll screen
+
+        Args:
+            x: horizontal position
+            y: vertical position
+            h: horizontal movement
+            v: vertical movement
+        """
+
+        x, y = max(x, 0), max(y, 0)
+        return struct.pack(
+            ">iiHHii",
+            int(x),
+            int(y),
+            int(self.resolution[0]),
+            int(self.resolution[1]),
+            int(h),
+            int(v),
+        )
+
+    @inject(const.TYPE_BACK_OR_SCREEN_ON)
+    def back_or_turn_screen_on(self, action: int = const.ACTION_DOWN) -> bytes:
+        """
+        If the screen is off, it is turned on only on ACTION_DOWN
+
+        Args:
+            action: ACTION_DOWN | ACTION_UP
+        """
+        return struct.pack(">B", action)
+
+    @inject(const.TYPE_EXPAND_NOTIFICATION_PANEL)
+    def expand_notification_panel(self) -> bytes:
+        """
+        Expand notification panel
+        """
+        return b""
+
+    @inject(const.TYPE_EXPAND_SETTINGS_PANEL)
+    def expand_settings_panel(self) -> bytes:
+        """
+        Expand settings panel
+        """
+        return b""
+
+    @inject(const.TYPE_COLLAPSE_PANELS)
+    def collapse_panels(self) -> bytes:
+        """
+        Collapse all panels
+        """
+        return b""
+
+    def get_clipboard(self) -> str:
+        """
+        Get clipboard
+        """
+        # Since this function need socket response, we can't auto inject it any more
+        s: socket.socket = self.control_socket
+
+        with self.control_socket_lock:
+            # Flush socket
+            s.setblocking(False)
+            while True:
+                try:
+                    s.recv(1024)
+                except BlockingIOError:
+                    break
+            s.setblocking(True)
+
+            # Read package
+            package = struct.pack(">B", const.TYPE_GET_CLIPBOARD)
+            s.send(package)
+            (code,) = struct.unpack(">B", s.recv(1))
+            assert code == 0
+            (length,) = struct.unpack(">i", s.recv(4))
+
+            return s.recv(length).decode("utf-8")
+
+    @inject(const.TYPE_SET_CLIPBOARD)
+    def set_clipboard(self, text: str, paste: bool = False) -> bytes:
+        """
+        Set clipboard
+
+        Args:
+            text: the string you want to set
+            paste: paste now
+        """
+        buffer = text.encode("utf-8")
+        return struct.pack(">?i", paste, len(buffer)) + buffer
+
+    @inject(const.TYPE_SET_SCREEN_POWER_MODE)
+    def set_screen_power_mode(self, mode: int = const.POWER_MODE_NORMAL) -> bytes:
+        """
+        Set screen power mode
+
+        Args:
+            mode: POWER_MODE_OFF | POWER_MODE_NORMAL
+        """
+        return struct.pack(">b", mode)
+
+    @inject(const.TYPE_ROTATE_DEVICE)
+    def rotate_device(self) -> bytes:
+        """
+        Rotate device
+        """
+        return b""
+
+    def swipe(
+            self,
+            start_x: int,
+            start_y: int,
+            end_x: int,
+            end_y: int,
+            move_step_length: int = 5,
+            move_steps_delay: float = 0.005,
+    ) -> None:
+        """
+        Swipe on screen
+
+        Args:
+            start_x: start horizontal position
+            start_y: start vertical position
+            end_x: start horizontal position
+            end_y: end vertical position
+            move_step_length: length per step
+            move_steps_delay: sleep seconds after each step
+        :return:
+        """
+
+        self.touch(start_x, start_y, const.ACTION_DOWN)
+        next_x = start_x
+        next_y = start_y
+
+        if end_x > self.resolution[0]:
+            end_x = self.resolution[0]
+
+        if end_y > self.resolution[1]:
+            end_y = self.resolution[1]
+
+        decrease_x = True if start_x > end_x else False
+        decrease_y = True if start_y > end_y else False
+        while True:
+            if decrease_x:
+                next_x -= move_step_length
+                if next_x < end_x:
+                    next_x = end_x
+            else:
+                next_x += move_step_length
+                if next_x > end_x:
+                    next_x = end_x
+
+            if decrease_y:
+                next_y -= move_step_length
+                if next_y < end_y:
+                    next_y = end_y
+            else:
+                next_y += move_step_length
+                if next_y > end_y:
+                    next_y = end_y
+
+            self.touch(next_x, next_y, const.ACTION_MOVE)
+
+            if next_x == end_x and next_y == end_y:
+                self.touch(next_x, next_y, const.ACTION_UP)
+                break
+            time.sleep(move_steps_delay)

+ 216 - 0
module/device/method/scrcpy/core.py

@@ -0,0 +1,216 @@
+import socket
+import struct
+import threading
+import time
+import typing as t
+from time import sleep
+
+import numpy as np
+from adbutils import _AdbStreamConnection, AdbError, Network
+
+from module.base.decorator import cached_property
+from module.base.timer import Timer
+from module.device.connection import Connection
+from module.device.method.scrcpy.control import ControlSender
+from module.device.method.scrcpy.options import ScrcpyOptions
+from module.device.method.utils import recv_all
+from module.exception import RequestHumanTakeover
+from module.logger import logger
+
+
+class ScrcpyError(Exception):
+    pass
+
+
+class ScrcpyCore(Connection):
+    """
+    Scrcpy: https://github.com/Genymobile/scrcpy
+    Module from https://github.com/leng-yue/py-scrcpy-client
+    """
+
+    _scrcpy_last_frame: t.Optional[np.ndarray] = None
+    _scrcpy_last_frame_time: float = 0.
+
+    _scrcpy_alive = False
+    _scrcpy_server_stream: t.Optional[_AdbStreamConnection] = None
+    _scrcpy_video_socket: t.Optional[socket.socket] = None
+    _scrcpy_control_socket: t.Optional[socket.socket] = None
+    _scrcpy_control_socket_lock = threading.Lock()
+
+    _scrcpy_stream_loop_thread = None
+    _scrcpy_resolution: t.Tuple[int, int] = (1280, 720)
+
+    @cached_property
+    def _scrcpy_control(self) -> ControlSender:
+        return ControlSender(self)
+
+    def scrcpy_init(self):
+        self._scrcpy_server_stop()
+
+        logger.hr('Scrcpy init')
+        logger.info(f'pushing {self.config.SCRCPY_FILEPATH_LOCAL}')
+        self.adb_push(self.config.SCRCPY_FILEPATH_LOCAL, self.config.SCRCPY_FILEPATH_REMOTE)
+
+        self._scrcpy_alive = False
+        self.scrcpy_ensure_running()
+
+    def scrcpy_ensure_running(self):
+        if not self._scrcpy_alive:
+            with self._scrcpy_control_socket_lock:
+                self._scrcpy_server_start()
+
+    def _scrcpy_server_start(self):
+        """
+        Connect to scrcpy server, there will be two sockets, video and control socket.
+
+        Raises:
+            ScrcpyError:
+        """
+        logger.hr('Scrcpy server start')
+        commands = ScrcpyOptions.command_v120(jar_path=self.config.SCRCPY_FILEPATH_REMOTE)
+        self._scrcpy_server_stream: _AdbStreamConnection = self.adb.shell(
+            commands,
+            stream=True,
+        )
+
+        logger.info('Create server stream')
+        ret = self._scrcpy_server_stream.read(10)
+        # b'Aborted \r\n'
+        # Probably because file not exists
+        if b'Aborted' in ret:
+            raise ScrcpyError('Aborted')
+        if ret == b'[server] E':
+            # [server] ERROR: ...
+            ret += recv_all(self._scrcpy_server_stream)
+            logger.error(ret)
+            # java.lang.IllegalArgumentException: The server version (1.25) does not match the client (...)
+            if b'does not match the client' in ret:
+                raise ScrcpyError('Server version does not match the client')
+            else:
+                raise ScrcpyError('Unknown scrcpy error')
+        else:
+            # [server] INFO: Device: ...
+            ret += self._scrcpy_receive_from_server_stream()
+            logger.info(ret)
+            pass
+
+        logger.info('Create video socket')
+        timeout = Timer(3).start()
+        while 1:
+            if timeout.reached():
+                raise ScrcpyError('Connect scrcpy-server timeout')
+
+            try:
+                self._scrcpy_video_socket = self.adb.create_connection(
+                    Network.LOCAL_ABSTRACT, "scrcpy"
+                )
+                break
+            except AdbError:
+                sleep(0.1)
+        dummy_byte = self._scrcpy_video_socket.recv(1)
+        if not len(dummy_byte) or dummy_byte != b"\x00":
+            raise ScrcpyError('Did not receive Dummy Byte from video stream')
+
+        logger.info('Create control socket')
+        self._scrcpy_control_socket = self.adb.create_connection(
+            Network.LOCAL_ABSTRACT, "scrcpy"
+        )
+
+        logger.info('Fetch device info')
+        device_name = self._scrcpy_video_socket.recv(64).decode("utf-8").rstrip("\x00")
+        if len(device_name):
+            logger.attr('Scrcpy Device', device_name)
+        else:
+            raise ScrcpyError('Did not receive Device Name')
+        ret = self._scrcpy_video_socket.recv(4)
+        self._scrcpy_resolution = struct.unpack(">HH", ret)
+        logger.attr('Scrcpy Resolution', self._scrcpy_resolution)
+
+        self._scrcpy_video_socket.setblocking(False)
+        self._scrcpy_alive = True
+
+        logger.info('Start video stream loop thread')
+        self._scrcpy_stream_loop_thread = threading.Thread(
+            target=self._scrcpy_stream_loop, daemon=True
+        )
+        self._scrcpy_stream_loop_thread.start()
+        while 1:
+            if self._scrcpy_stream_loop_thread is not None and self._scrcpy_stream_loop_thread.is_alive():
+                break
+            self.sleep(0.001)
+
+        logger.info('Scrcpy server is up')
+
+    def _scrcpy_server_stop(self):
+        """
+        Stop listening (both threaded and blocked)
+        """
+        logger.hr('Scrcpy server stop')
+        # err = self._scrcpy_receive_from_server_stream()
+        # if err:
+        #     logger.error(err)
+
+        self._scrcpy_alive = False
+        if self._scrcpy_server_stream is not None:
+            try:
+                self._scrcpy_server_stream.close()
+            except Exception:
+                pass
+
+        if self._scrcpy_control_socket is not None:
+            try:
+                self._scrcpy_control_socket.close()
+            except Exception:
+                pass
+
+        if self._scrcpy_video_socket is not None:
+            try:
+                self._scrcpy_video_socket.close()
+            except Exception:
+                pass
+
+        logger.info('Scrcpy server stopped')
+
+    def _scrcpy_receive_from_server_stream(self):
+        if self._scrcpy_server_stream is not None:
+            try:
+                return self._scrcpy_server_stream.conn.recv(4096)
+            except Exception:
+                pass
+
+    def _scrcpy_stream_loop(self) -> None:
+        """
+        Core loop for video parsing
+        """
+        try:
+            from av.codec import CodecContext
+            from av.error import InvalidDataError
+        except ImportError as e:
+            logger.error(e)
+            logger.error('You must have `av` installed to use scrcpy screenshot, please update dependencies')
+            raise RequestHumanTakeover
+
+        codec = CodecContext.create("h264", "r")
+        while self._scrcpy_alive:
+            try:
+                raw_h264 = self._scrcpy_video_socket.recv(0x10000)
+                if raw_h264 == b"":
+                    raise ScrcpyError("Video stream is disconnected")
+                packets = codec.parse(raw_h264)
+                for packet in packets:
+                    frames = codec.decode(packet)
+                    for frame in frames:
+                        # logger.info('frame received')
+                        frame = frame.to_ndarray(format="rgb24")
+                        self._scrcpy_last_frame = frame
+                        self._scrcpy_last_frame_time = time.time()
+                        self._scrcpy_resolution = (frame.shape[1], frame.shape[0])
+            except (BlockingIOError, InvalidDataError):
+                # only return nonempty frames, may block cv2 render thread
+                time.sleep(0.001)
+            except (ConnectionError, OSError) as e:  # Socket Closed
+                if self._scrcpy_alive:
+                    logger.error(f'_scrcpy_stream_loop_thread: {repr(e)}')
+                    raise
+
+        raise ScrcpyError('_scrcpy_stream_loop stopped')

+ 132 - 0
module/device/method/scrcpy/options.py

@@ -0,0 +1,132 @@
+import typing as t
+
+import module.device.method.scrcpy.const as const
+
+
+class ScrcpyOptions:
+    frame_rate = 6
+
+    @classmethod
+    def codec_options(cls) -> str:
+        """
+        Custom codec options passing through scrcpy.
+        https://developer.android.com/reference/android/media/MediaFormat
+
+        Returns:
+            key_profile=1,key_level=4096,...
+        """
+        options = dict(
+            # H.264 profile and level
+            # https://developer.android.com/reference/android/media/MediaCodecInfo.CodecProfileLevel
+            # Baseline, which only has I/P frames
+            key_profile=1,
+            # Level 4.1, for 1280x720@30fps
+            key_level=4096,
+            # Max quality
+            key_quality=100,
+            # https://developer.android.com/reference/android/media/MediaCodecInfo.EncoderCapabilities
+            # Constant quality
+            key_bitrate_mode=0,
+            # A zero value means a stream containing all key frames is requested.
+            key_i_frame_interval=0,
+            # https://developer.android.com/reference/android/media/MediaCodecInfo.CodecCapabilities
+            # COLOR_Format24bitBGR888
+            key_color_format=12,
+            # The same as output frame rate to lower CPU consumption
+            key_capture_rate=cls.frame_rate,
+            # 20Mbps, the maximum output bitrate of scrcpy
+            key_bit_rate=20000000,
+        )
+        return ','.join([f'{k}={v}' for k, v in options.items()])
+
+    @classmethod
+    def arguments(cls) -> t.List[str]:
+        """
+        https://github.com/Genymobile/scrcpy/blob/master/server/src/main/java/com/genymobile/scrcpy/Server.java
+        https://github.com/Genymobile/scrcpy/blob/master/server/src/main/java/com/genymobile/scrcpy/Options.java
+
+        Returns:
+            ['log_level=info', 'max_size=1280', ...]
+        """
+        options = [
+            'log_level=info',
+            'max_size=1280',
+            # 20Mbps, the maximum output bitrate of scrcpy
+            # If a higher value is set, scrcpy fallback to 8Mbps default.
+            'bit_rate=20000000',
+            # Screenshot time cost <= 300ms is enough for human speed.
+            f'max_fps={cls.frame_rate}',
+            # No orientation lock
+            f'lock_video_orientation={const.LOCK_SCREEN_ORIENTATION_UNLOCKED}',
+            # Always true
+            'tunnel_forward=true',
+            # Always true for controlling via scrcpy
+            'control=true',
+            # Default to 0
+            'display_id=0',
+            # Useless, always false
+            'show_touches=false',
+            # Not determined, leave it as default
+            'stay_awake=false',
+            # Encoder name
+            # Should in [
+            #     "OMX.google.h264.encoder",
+            #     "OMX.qcom.video.encoder.avc",
+            #     "c2.qti.avc.encoder",
+            #     "c2.android.avc.encoder",
+            # ]
+            # Empty value, let scrcpy to decide
+            # 'encoder_name=',
+            # Codec options
+            f'codec_options={cls.codec_options()}',
+            # Useless, always false
+            'power_off_on_close=false',
+            'clipboard_autosync=false',
+            'downsize_on_error=false',
+        ]
+        return options
+
+    @classmethod
+    def command_v125(cls, jar_path='/data/local/tmp/scrcpy-server.jar') -> t.List[str]:
+        """
+        Generate the commands to run scrcpy.
+        """
+        commands = [
+            f'CLASSPATH={jar_path}',
+            'app_process',
+            '/',
+            'com.genymobile.scrcpy.Server',
+            '1.25',
+        ]
+        commands += cls.arguments()
+        return commands
+
+    @classmethod
+    def command_v120(cls, jar_path='/data/local/tmp/scrcpy-server.jar') -> t.List[str]:
+        commands = [
+            f"CLASSPATH={jar_path}",
+            "app_process",
+            "/",
+            "com.genymobile.scrcpy.Server",
+            "1.20",  # Scrcpy server version
+            "info",  # Log level: info, verbose...
+            f"1280",  # Max screen width (long side)
+            f"20000000",  # Bitrate of video
+            f"{cls.frame_rate}",  # Max frame per second
+            f"{const.LOCK_SCREEN_ORIENTATION_UNLOCKED}",  # Lock screen orientation: LOCK_SCREEN_ORIENTATION
+            "true",  # Tunnel forward
+            "-",  # Crop screen
+            "false",  # Send frame rate to client
+            "true",  # Control enabled
+            "0",  # Display id
+            "false",  # Show touches
+            "false",  # Stay awake
+            cls.codec_options(),  # Codec (video encoding) options
+            "-",  # Encoder name
+            "false",  # Power off screen after server closed
+        ]
+        return commands
+
+
+if __name__ == '__main__':
+    print(' '.join(ScrcpyOptions.command_v120()))

+ 152 - 0
module/device/method/scrcpy/scrcpy.py

@@ -0,0 +1,152 @@
+import time
+from functools import wraps
+
+import numpy as np
+from adbutils.errors import AdbError
+
+import module.device.method.scrcpy.const as const
+from module.base.utils import random_rectangle_point
+from module.device.method.minitouch import insert_swipe
+from module.device.method.scrcpy.core import ScrcpyCore, ScrcpyError
+from module.device.method.uiautomator_2 import Uiautomator2
+from module.device.method.utils import RETRY_TRIES, retry_sleep, handle_adb_error
+from module.exception import RequestHumanTakeover
+from module.logger import logger
+
+
+def retry(func):
+    @wraps(func)
+    def retry_wrapper(self, *args, **kwargs):
+        """
+        Args:
+            self (Minitouch):
+        """
+        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
+            # When adb server was killed
+            except ConnectionResetError as e:
+                logger.error(e)
+
+                def init():
+                    self.adb_reconnect()
+            # Emulator closed
+            except ConnectionAbortedError as e:
+                logger.error(e)
+
+                def init():
+                    self.adb_reconnect()
+            # ScrcpyError
+            except ScrcpyError as e:
+                logger.error(e)
+
+                def init():
+                    self.scrcpy_init()
+            # AdbError
+            except AdbError as e:
+                if handle_adb_error(e):
+                    def init():
+                        self.adb_reconnect()
+                else:
+                    break
+            # 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 Scrcpy(ScrcpyCore, Uiautomator2):
+    def _scrcpy_resolution_check(self):
+        if not self._scrcpy_alive:
+            with self._scrcpy_control_socket_lock:
+                self.resolution_check_uiautomator2()
+
+    @retry
+    def screenshot_scrcpy(self):
+        self._scrcpy_resolution_check()
+        self.scrcpy_ensure_running()
+
+        with self._scrcpy_control_socket_lock:
+            # Wait new frame
+            now = time.time()
+            while 1:
+                time.sleep(0.001)
+                if self._scrcpy_stream_loop_thread is None or not self._scrcpy_stream_loop_thread.is_alive():
+                    raise ScrcpyError('_scrcpy_stream_loop_thread died')
+                if self._scrcpy_last_frame_time > now:
+                    screenshot = self._scrcpy_last_frame.copy()
+                    return screenshot
+
+    @retry
+    def click_scrcpy(self, x, y):
+        self.scrcpy_ensure_running()
+
+        with self._scrcpy_control_socket_lock:
+            self._scrcpy_control.touch(x, y, const.ACTION_DOWN)
+            self._scrcpy_control.touch(x, y, const.ACTION_UP)
+            self.sleep(0.05)
+
+    @retry
+    def long_click_scrcpy(self, x, y, duration=1.0):
+        self.scrcpy_ensure_running()
+
+        with self._scrcpy_control_socket_lock:
+            self._scrcpy_control.touch(x, y, const.ACTION_DOWN)
+            self.sleep(duration)
+            self._scrcpy_control.touch(x, y, const.ACTION_UP)
+            self.sleep(0.05)
+
+    @retry
+    def swipe_scrcpy(self, p1, p2):
+        self.scrcpy_ensure_running()
+
+        with self._scrcpy_control_socket_lock:
+            # Unlike minitouch, scrcpy swipes needs to be continuous
+            # So 5 times smother
+            points = insert_swipe(p0=p1, p3=p2, speed=4, min_distance=2)
+            self._scrcpy_control.touch(*p1, const.ACTION_DOWN)
+
+            for point in points[1:-1]:
+                self._scrcpy_control.touch(*point, const.ACTION_MOVE)
+                self.sleep(0.002)
+
+            self._scrcpy_control.touch(*p2, const.ACTION_MOVE)
+            self._scrcpy_control.touch(*p2, const.ACTION_UP)
+            self.sleep(0.05)
+
+    @retry
+    def drag_scrcpy(self, p1, p2, point_random=(-10, -10, 10, 10)):
+        self.scrcpy_ensure_running()
+
+        with self._scrcpy_control_socket_lock:
+            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=4, min_distance=2)
+
+            self._scrcpy_control.touch(*p1, const.ACTION_DOWN)
+
+            for point in points[1:-1]:
+                self._scrcpy_control.touch(*point, const.ACTION_MOVE)
+                self.sleep(0.002)
+
+            # Hold 280ms
+            for _ in range(int(0.14 // 0.002) * 2):
+                self._scrcpy_control.touch(*p2, const.ACTION_MOVE)
+                self.sleep(0.002)
+
+            self._scrcpy_control.touch(*p2, const.ACTION_UP)
+            self.sleep(0.05)

+ 333 - 0
module/device/method/uiautomator_2.py

@@ -0,0 +1,333 @@
+import typing as t
+import numpy as np
+import cv2
+from dataclasses import dataclass
+from functools import wraps
+from json.decoder import JSONDecodeError
+from subprocess import list2cmdline
+
+import uiautomator2 as u2
+from adbutils.errors import AdbError
+from lxml import etree
+
+from module.base.utils import point2str, random_rectangle_point, random_line_segments
+from module.device.connection import Connection
+from module.device.method.utils import (RETRY_TRIES, retry_sleep, handle_adb_error,
+                                        ImageTruncated, PackageNotInstalled, possible_reasons)
+from module.exception import RequestHumanTakeover
+from module.logger import logger
+
+
+def retry(func):
+    @wraps(func)
+    def retry_wrapper(self, *args, **kwargs):
+        """
+        Args:
+            self (Uiautomator2):
+        """
+        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
+            # When adb server was killed
+            except ConnectionResetError as e:
+                logger.error(e)
+
+                def init():
+                    self.adb_reconnect()
+            # In `device.set_new_command_timeout(604800)`
+            # json.decoder.JSONDecodeError: Expecting value: line 1 column 2 (char 1)
+            except JSONDecodeError as e:
+                logger.error(e)
+
+                def init():
+                    self.install_uiautomator2()
+            # AdbError
+            except AdbError as e:
+                if handle_adb_error(e):
+                    def init():
+                        self.adb_reconnect()
+                else:
+                    break
+            # RuntimeError: USB device 127.0.0.1:5555 is offline
+            except RuntimeError as e:
+                if handle_adb_error(e):
+                    def init():
+                        self.adb_reconnect()
+                else:
+                    break
+            # In `assert c.read string(4) == _OKAY`
+            # ADB on emulator not enabled
+            except AssertionError as e:
+                logger.exception(e)
+                possible_reasons(
+                    'If you are using BlueStacks or LD player or WSA, '
+                    'please enable ADB in the settings of your emulator'
+                )
+                break
+            # Package not installed
+            except PackageNotInstalled as e:
+                logger.error(e)
+
+                def init():
+                    self.detect_package()
+            # ImageTruncated
+            except ImageTruncated as e:
+                logger.error(e)
+
+                def init():
+                    pass
+            # Unknown
+            except Exception as e:
+                logger.exception(e)
+
+                def init():
+                    pass
+
+        logger.critical(f'Retry {func.__name__}() failed')
+        raise RequestHumanTakeover
+
+    return retry_wrapper
+
+
+@dataclass
+class ProcessInfo:
+    pid: int
+    ppid: int
+    thread_count: int
+    cmdline: str
+    name: str
+
+
+@dataclass
+class ShellBackgroundResponse:
+    success: bool
+    pid: int
+    description: str
+
+
+class Uiautomator2(Connection):
+    @retry
+    def screenshot_uiautomator2(self):
+        image = self.u2.screenshot(format='raw')
+        image = np.frombuffer(image, np.uint8)
+        if image is None:
+            raise ImageTruncated('Empty image after reading from buffer')
+
+        image = cv2.imdecode(image, cv2.IMREAD_COLOR)
+        if image is None:
+            raise ImageTruncated('Empty image after cv2.imdecode')
+
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        if image is None:
+            raise ImageTruncated('Empty image after cv2.cvtColor')
+
+        return image
+
+    @retry
+    def click_uiautomator2(self, x, y):
+        self.u2.click(x, y)
+
+    @retry
+    def long_click_uiautomator2(self, x, y, duration=(1, 1.2)):
+        self.u2.long_click(x, y, duration=duration)
+
+    @retry
+    def swipe_uiautomator2(self, p1, p2, duration=0.1):
+        self.u2.swipe(*p1, *p2, duration=duration)
+
+    @retry
+    def _drag_along(self, path):
+        """Swipe following path.
+
+        Args:
+            path (list): (x, y, sleep)
+
+        Examples:
+            al.drag_along([
+                (403, 421, 0.2),
+                (821, 326, 0.1),
+                (821, 326-10, 0.1),
+                (821, 326+10, 0.1),
+                (821, 326, 0),
+            ])
+            Equals to:
+            al.device.touch.down(403, 421)
+            time.sleep(0.2)
+            al.device.touch.move(821, 326)
+            time.sleep(0.1)
+            al.device.touch.move(821, 326-10)
+            time.sleep(0.1)
+            al.device.touch.move(821, 326+10)
+            time.sleep(0.1)
+            al.device.touch.up(821, 326)
+        """
+        length = len(path)
+        for index, data in enumerate(path):
+            x, y, second = data
+            if index == 0:
+                self.u2.touch.down(x, y)
+                logger.info(point2str(x, y) + ' down')
+            elif index - length == -1:
+                self.u2.touch.up(x, y)
+                logger.info(point2str(x, y) + ' up')
+            else:
+                self.u2.touch.move(x, y)
+                logger.info(point2str(x, y) + ' move')
+            self.sleep(second)
+
+    def drag_uiautomator2(self, p1, p2, segments=1, shake=(0, 15), point_random=(-10, -10, 10, 10),
+                          shake_random=(-5, -5, 5, 5), swipe_duration=0.25, shake_duration=0.1):
+        """Drag and shake, like:
+                     /\
+        +-----------+  +  +
+                        \/
+        A simple swipe or drag don't work well, because it only has two points.
+        Add some way point to make it more like swipe.
+
+        Args:
+            p1 (tuple): Start point, (x, y).
+            p2 (tuple): End point, (x, y).
+            segments (int):
+            shake (tuple): Shake after arrive end point.
+            point_random: Add random to start point and end point.
+            shake_random: Add random to shake array.
+            swipe_duration: Duration between way points.
+            shake_duration: Duration between shake points.
+        """
+        p1 = np.array(p1) - random_rectangle_point(point_random)
+        p2 = np.array(p2) - random_rectangle_point(point_random)
+        path = [(x, y, swipe_duration) for x, y in random_line_segments(p1, p2, n=segments, random_range=point_random)]
+        path += [
+            (*p2 + shake + random_rectangle_point(shake_random), shake_duration),
+            (*p2 - shake - random_rectangle_point(shake_random), shake_duration),
+            (*p2, shake_duration)
+        ]
+        path = [(int(x), int(y), d) for x, y, d in path]
+        self._drag_along(path)
+
+    @retry
+    def app_current_uiautomator2(self):
+        """
+        Returns:
+            str: Package name.
+        """
+        result = self.u2.app_current()
+        return result['package']
+
+    @retry
+    def app_start_uiautomator2(self, package_name=None):
+        if not package_name:
+            package_name = self.package
+        try:
+            self.u2.app_start(package_name)
+        except u2.exceptions.BaseError as e:
+            # BaseError: package "com.bilibili.azurlane" not found
+            logger.error(e)
+            raise PackageNotInstalled(package_name)
+
+    @retry
+    def app_stop_uiautomator2(self, package_name=None):
+        if not package_name:
+            package_name = self.package
+        self.u2.app_stop(package_name)
+
+    @retry
+    def dump_hierarchy_uiautomator2(self) -> etree._Element:
+        content = self.u2.dump_hierarchy(compressed=True)
+        hierarchy = etree.fromstring(content.encode('utf-8'))
+        return hierarchy
+
+    @retry
+    def resolution_uiautomator2(self) -> t.Tuple[int, int]:
+        """
+        Faster u2.window_size(), cause that calls `dumpsys display` twice.
+
+        Returns:
+            (width, height)
+        """
+        info = self.u2.http.get('/info').json()
+        w, h = info['display']['width'], info['display']['height']
+        rotation = self.get_orientation()
+        if (w > h) != (rotation % 2 == 1):
+            w, h = h, w
+        return w, h
+
+    def resolution_check_uiautomator2(self):
+        """
+        Alas does not actively check resolution but the width and height of screenshots.
+        However, some screenshot methods do not provide device resolution, so check it here.
+
+        Returns:
+            (width, height)
+
+        Raises:
+            RequestHumanTakeover: If resolution is not 1280x720
+        """
+        width, height = self.resolution_uiautomator2()
+        logger.attr('Screen_size', f'{width}x{height}')
+        if width == 1280 and height == 720:
+            return (width, height)
+        if width == 720 and height == 1280:
+            return (width, height)
+
+        logger.critical(f'Resolution not supported: {width}x{height}')
+        logger.critical('Please set emulator resolution to 1280x720')
+        raise RequestHumanTakeover
+
+    @retry
+    def proc_list_uiautomator2(self) -> t.List[ProcessInfo]:
+        """
+        Get info about current processes.
+        """
+        resp = self.u2.http.get("/proc/list", timeout=10)
+        resp.raise_for_status()
+        result = [
+            ProcessInfo(
+                pid=proc['pid'],
+                ppid=proc['ppid'],
+                thread_count=proc['threadCount'],
+                cmdline=' '.join(proc['cmdline']) if proc['cmdline'] is not None else '',
+                name=proc['name'],
+            ) for proc in resp.json()
+        ]
+        return result
+
+    @retry
+    def u2_shell_background(self, cmdline, timeout=10) -> ShellBackgroundResponse:
+        """
+        Run at background.
+
+        Note that this function will always return a success response,
+        as this is a untested and hidden method in ATX.
+        """
+        if isinstance(cmdline, (list, tuple)):
+            cmdline = list2cmdline(cmdline)
+        elif isinstance(cmdline, str):
+            cmdline = cmdline
+        else:
+            raise TypeError("cmdargs type invalid", type(cmdline))
+
+        data = dict(command=cmdline, timeout=str(timeout))
+        ret = self.u2.http.post("/shell/background", data=data, timeout=timeout + 10)
+        ret.raise_for_status()
+
+        resp = ret.json()
+        resp = ShellBackgroundResponse(
+            success=bool(resp.get('success', False)),
+            pid=resp.get('pid', 0),
+            description=resp.get('description', '')
+        )
+        return resp
+
+if __name__ == '__main__':
+    ui2 = Uiautomator2(config='oas1')
+    ui2.app_start_uiautomator2()
+    cv2.imshow("iiii", ui2.screenshot_uiautomator2())
+    cv2.waitKey(0)

+ 377 - 0
module/map/map_grids.py

@@ -0,0 +1,377 @@
+import operator
+import typing as t
+
+
+class SelectedGrids:
+    def __init__(self, grids):
+        self.grids = grids
+        self.indexes: t.Dict[tuple, SelectedGrids] = {}
+
+    def __iter__(self):
+        return iter(self.grids)
+
+    def __getitem__(self, item):
+        if isinstance(item, int):
+            return self.grids[item]
+        else:
+            return SelectedGrids(self.grids[item])
+
+    def __contains__(self, item):
+        return item in self.grids
+
+    def __str__(self):
+        # return str([str(grid) for grid in self])
+        return '[' + ', '.join([str(grid) for grid in self]) + ']'
+
+    def __len__(self):
+        return len(self.grids)
+
+    def __bool__(self):
+        return self.count > 0
+
+    # def __getattr__(self, item):
+    #     return [grid.__getattribute__(item) for grid in self.grids]
+
+    @property
+    def location(self):
+        """
+        Returns:
+            list[tuple]:
+        """
+        return [grid.location for grid in self.grids]
+
+    @property
+    def cost(self):
+        """
+        Returns:
+            list[int]:
+        """
+        return [grid.cost for grid in self.grids]
+
+    @property
+    def weight(self):
+        """
+        Returns:
+            list[int]:
+        """
+        return [grid.weight for grid in self.grids]
+
+    @property
+    def count(self):
+        """
+        Returns:
+            int:
+        """
+        return len(self.grids)
+
+    def select(self, **kwargs):
+        """
+        Args:
+            **kwargs: Attributes of Grid.
+
+        Returns:
+            SelectedGrids:
+        """
+        def matched(obj):
+            flag = True
+            for k, v in kwargs.items():
+                obj_v = obj.__getattribute__(k)
+                if type(obj_v) != type(v) or obj_v != v:
+                    flag = False
+            return flag
+
+        return SelectedGrids([grid for grid in self.grids if matched(grid)])
+
+    def create_index(self, *attrs):
+        indexes = {}
+        # index_keys = [(grid.__getattribute__(attr) for attr in attrs) for grid in self.grids]
+        for grid in self.grids:
+            k = tuple(grid.__getattribute__(attr) for attr in attrs)
+            try:
+                indexes[k].append(grid)
+            except KeyError:
+                indexes[k] = [grid]
+
+        indexes = {k: SelectedGrids(v) for k, v in indexes.items()}
+        self.indexes = indexes
+        return indexes
+
+    def indexed_select(self, *values):
+        return self.indexes.get(values, SelectedGrids([]))
+
+    def left_join(self, right, on_attr, set_attr, default=None):
+        """
+        Args:
+            right (SelectedGrids): Right table to join
+            on_attr:
+            set_attr:
+            default:
+
+        Returns:
+            SelectedGrids:
+        """
+        right.create_index(*on_attr)
+        for grid in self:
+            attr_value = tuple([grid.__getattribute__(attr) for attr in on_attr])
+            right_grid = right.indexed_select(*attr_value).first_or_none()
+            if right_grid is not None:
+                for attr in set_attr:
+                    grid.__setattr__(attr, right_grid.__getattribute__(attr))
+            else:
+                for attr in set_attr:
+                    grid.__setattr__(attr, default)
+
+        return self
+
+    def filter(self, func):
+        """
+        Filter grids by a function.
+
+        Args:
+            func (callable): Function should receive an grid as argument, and return a bool.
+
+        Returns:
+            SelectedGrids:
+        """
+        return SelectedGrids([grid for grid in self if func(grid)])
+
+    def set(self, **kwargs):
+        """
+        Set attribute to each grid.
+
+        Args:
+            **kwargs:
+        """
+        for grid in self:
+            for key, value in kwargs.items():
+                grid.__setattr__(key, value)
+
+    def get(self, attr):
+        """
+        Get an attribute from each grid.
+
+        Args:
+            attr: Attribute name.
+
+        Returns:
+            list:
+        """
+        return [grid.__getattribute__(attr) for grid in self.grids]
+
+    def call(self, func, **kwargs):
+        """
+        Call a function in reach grid, and get results.
+
+        Args:
+            func (str): Function name to call.
+            **kwargs:
+
+        Returns:
+            list:
+        """
+        return [grid.__getattribute__(func)(**kwargs) for grid in self]
+
+    def first_or_none(self):
+        """
+        Returns:
+
+        """
+        try:
+            return self.grids[0]
+        except IndexError:
+            return None
+
+    def add(self, grids):
+        """
+        Args:
+            grids(SelectedGrids):
+
+        Returns:
+            SelectedGrids:
+        """
+        return SelectedGrids(list(set(self.grids + grids.grids)))
+
+    def add_by_eq(self, grids):
+        """
+        Another `add()` method, but de-duplicates with `__eq__` instead of `__hash__`.
+
+        Args:
+            grids(SelectedGrids):
+
+        Returns:
+            SelectedGrids:
+        """
+        new = []
+        for grid in self.grids + grids.grids:
+            if grid not in new:
+                new.append(grid)
+
+        return SelectedGrids(new)
+
+    def intersect(self, grids):
+        """
+        Args:
+            grids(SelectedGrids):
+
+        Returns:
+            SelectedGrids:
+        """
+        return SelectedGrids(list(set(self.grids).intersection(set(grids.grids))))
+
+    def intersect_by_eq(self, grids):
+        """
+        Another `intersect()` method, but de-duplicates with `__eq__` instead of `__hash__`.
+
+        Args:
+            grids(SelectedGrids):
+
+        Returns:
+            SelectedGrids:
+        """
+        new = []
+        for grid in self.grids:
+            if grid in grids.grids:
+                new.append(grid)
+
+        return SelectedGrids(new)
+
+    def delete(self, grids):
+        """
+        Args:
+            grids(SelectedGrids):
+
+        Returns:
+            SelectedGrids:
+        """
+        g = [grid for grid in self.grids if grid not in grids]
+        return SelectedGrids(g)
+
+    def sort(self, *args):
+        """
+        Args:
+            args (str): Attribute name to sort.
+
+        Returns:
+            SelectedGrids:
+        """
+        if not self:
+            return self
+        if len(args):
+            grids = sorted(self.grids, key=operator.attrgetter(*args))
+            return SelectedGrids(grids)
+        else:
+            return self
+
+    def sort_by_camera_distance(self, camera):
+        """
+        Args:
+            camera (tuple):
+
+        Returns:
+            SelectedGrids:
+        """
+        import numpy as np
+        if not self:
+            return self
+        location = np.array(self.location)
+        diff = np.sum(np.abs(location - camera), axis=1)
+        # grids = [x for _, x in sorted(zip(diff, self.grids))]
+        grids = tuple(np.array(self.grids)[np.argsort(diff)])
+        return SelectedGrids(grids)
+
+    def sort_by_clock_degree(self, center=(0, 0), start=(0, 1), clockwise=True):
+        """
+        Args:
+            center (tuple): Origin point.
+            start (tuple): Start coordinate, this point will be considered as theta=0.
+            clockwise (bool): True for clockwise, false for counterclockwise.
+
+        Returns:
+            SelectedGrids:
+        """
+        import numpy as np
+        if not self:
+            return self
+        vector = np.subtract(self.location, center)
+        theta = np.arctan2(vector[:, 1], vector[:, 0]) / np.pi * 180
+        vector = np.subtract(start, center)
+        theta = theta - np.arctan2(vector[1], vector[0]) / np.pi * 180
+        if not clockwise:
+            theta = -theta
+        theta[theta < 0] += 360
+        grids = tuple(np.array(self.grids)[np.argsort(theta)])
+        return SelectedGrids(grids)
+
+
+class RoadGrids:
+    def __init__(self, grids):
+        """
+        Args:
+            grids (list):
+        """
+        self.grids = []
+        for grid in grids:
+            if isinstance(grid, list):
+                self.grids.append(SelectedGrids(grids=grid))
+            else:
+                self.grids.append(SelectedGrids(grids=[grid]))
+
+    def __str__(self):
+        return str(' - '.join([str(grid) for grid in self.grids]))
+
+    def roadblocks(self):
+        """
+        Returns:
+            SelectedGrids:
+        """
+        grids = []
+        for block in self.grids:
+            if block.count == block.select(is_enemy=True).count:
+                grids += block.grids
+        return SelectedGrids(grids)
+
+    def potential_roadblocks(self):
+        """
+        Returns:
+            SelectedGrids:
+        """
+        grids = []
+        for block in self.grids:
+            if any([grid.is_fleet for grid in block]):
+                continue
+            if any([grid.is_cleared for grid in block]):
+                continue
+            if block.count - block.select(is_enemy=True).count == 1:
+                grids += block.select(is_enemy=True).grids
+        return SelectedGrids(grids)
+
+    def first_roadblocks(self):
+        """
+        Returns:
+            SelectedGrids:
+        """
+        grids = []
+        for block in self.grids:
+            if any([grid.is_fleet for grid in block]):
+                continue
+            if any([grid.is_cleared for grid in block]):
+                continue
+            if block.select(is_enemy=True).count >= 1:
+                grids += block.select(is_enemy=True).grids
+        return SelectedGrids(grids)
+
+    def combine(self, road):
+        """
+        Args:
+            road (RoadGrids):
+
+        Returns:
+            RoadGrids:
+        """
+        out = RoadGrids([])
+        for select_1 in self.grids:
+            for select_2 in road.grids:
+                select = select_1.add(select_2)
+                out.grids.append(select)
+
+        return out

+ 3 - 2
requirements-in.txt

@@ -1,8 +1,9 @@
 pyside6==6.4.3
 pyside6==6.4.3
-adbutils==1.2.9
-uiautomator2==2.16.23
+adbutils==0.11.0
+uiautomator2==2.16.17
 
 
 rich==13.3.5
 rich==13.3.5
 pyyaml==6.0
 pyyaml==6.0
 numpy==1.24.3
 numpy==1.24.3
 opencv-python==4.7.0.72
 opencv-python==4.7.0.72
+websockets==11.0.3