taotoolkit 1.0.0__py3-none-any.whl

taotoolkit/tao_device.py

@@ -0,0 +1,1011 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+"""设备操作层, adb/设备 设备描述json、打开相机, 拍照, 截屏, 录屏。"""
+
+import os
+import re
+
+import subprocess
+import sys
+import threading
+import time
+import json
+import argparse
+from time import sleep
+from colorama import Fore
+
+try:
+    import uiautomator2 as u2
+except Exception:  # pragma: no cover
+    u2 = None
+
+from func_timeout import FunctionTimedOut, func_timeout
+
+from .tao_common import (
+    debugCtrl,
+    checkMsg,
+    eExit,
+    exit,
+    iExit,
+    findFilesBySuffixKeyword,
+    inputSerial,
+    logd,
+    loge,
+    logh,
+    logi,
+    logw,
+    oCmd,
+    sysVersion,
+    pCmd,
+    parseArgs,
+    parseDeviceInfo,
+    rCmd,
+    normalize_args,
+    register_command,
+)
+
+CACHE_FILE = os.path.join(os.path.dirname(__file__), ".dev_cache.json")
+CACHE_TTL = 3600
+
+
+def _load_cache():
+    try:
+        if not os.path.exists(CACHE_FILE):
+            return None
+        with open(CACHE_FILE) as f:
+            c = json.load(f)
+        if time.time() - c.get("ts", 0) > CACHE_TTL:
+            return None
+        return c
+    except Exception:
+        return None
+
+
+def _save_cache(serial, screen_w, screen_h, android_ver):
+    try:
+        with open(CACHE_FILE, "w") as f:
+            json.dump(
+                {
+                    "ts": time.time(),
+                    "serial": serial,
+                    "screen_w": screen_w,
+                    "screen_h": screen_h,
+                    "android_ver": android_ver,
+                },
+                f,
+            )
+    except Exception:
+        pass
+
+
+class DevOp:
+    """android device operate"""
+
+    def __init__(self, serial="", needRoot=False):
+        logd(f"serial = {serial} needroot ={needRoot}")
+
+        cache = _load_cache()
+        out, _ = pCmd("adb devices -l", 1, False, waitDone=True, timeOut=5, logLevel="debug")
+
+        if cache != None and cache["serial"] in out:
+            cache_hit = True
+        else:
+            cache_hit = False
+
+        if cache_hit:
+            if cache == None:
+                eExit("cache file error")
+            else:
+                logd(f"[cache] 命中缓存，跳过设备扫描: {cache['serial']}")
+                self.serial = cache["serial"]
+                self.curScreenW = cache["screen_w"]
+                self.curScreenH = cache["screen_h"]
+                self.androidVersion = cache["android_ver"]
+                self.devices = [{"serial": self.serial}]
+        else:
+            logd("[cache] 未命中，完整初始化")
+            self.devices = self.getConnectedDevices()
+            if serial == "":
+                self.serial = self.getSerial()
+            else:
+                self.serial = serial
+                self.checkSerial(serial)
+            self.curScreenW, self.curScreenH = self.getScreenSize()
+            self.androidVersion = self.getAndroidVersion()
+            _save_cache(self.serial, self.curScreenW, self.curScreenH, self.androidVersion)
+
+        self.curPath = os.getcwd()
+        self.refScreenW = 720
+        self.refScreenH = 1600
+        self.xRatio = self.curScreenW / self.refScreenW
+        self.yRatio = self.curScreenH / self.refScreenH
+        self.soc = None
+
+        if needRoot:
+            self.adbRoot()
+            info, err = self.adbRemount()
+            if "reboot" in err or "reboot" in info:
+                self.adbReboot()
+                logh("Now reboot your device for settings to take effect")
+                exit()
+
+    def checkSerial(self, serial):
+        serialList = []
+        if self.devices == None:
+            eExit(f"no devices detected")
+        else:
+            for i in self.devices:
+                serialList.append(i["serial"])
+                if serial == i["serial"]:
+                    return True
+            eExit(f"[{serial}] no such a device, detected {' , '.join(serialList)}")
+
+    def getConnectedDevices(self):
+        try:
+            out, error = pCmd("adb devices -l", 1, True, waitDone=True, timeOut=6, logLevel="debug")
+            if "offline" in out or "unauthorized" in out:
+                tmp = out.split("\n")[1].split(" ")[0]
+                eExit(f"{tmp} devices offline or unauthorized")
+            if len(out.split("\n")) == 3:
+                eExit("no device detected")
+            logd(out)
+            lines = out.strip().split("\n")
+            devices = []
+            for line in lines[1:]:
+                device_info = line.split("\t")[0]
+                devices.append(parseDeviceInfo(device_info))
+            if len(devices) == 0:
+                eExit("no devices detect")
+            return devices
+        except subprocess.CalledProcessError as e:
+            loge(str(e))
+            return None
+
+    def getSerial(self):
+        if self.devices is None:
+            eExit("no devices detected")
+        devices = self.devices or []
+        serial_index = 0
+        if len(devices) == 1:
+            serial_index = 0
+        elif len(devices) > 1:
+            logi(f"more than one devices connect, {len(devices)}")
+            for index, value in enumerate(devices):
+                logi(f"{index} {value['serial']} {value['model']}")
+            serial_index = inputSerial(0, len(devices) - 1)
+
+        return devices[serial_index]["serial"]
+
+    def getAndroidVersion(self):
+        cmd = f"adb -s {self.serial} shell getprop |grep ro.build.version.release"
+        out = rCmd(cmd)[0]
+        logd(out)
+        if out == "":
+            logw("get android version failed, set it to 16 by default")
+            return "16"
+        return out.split("[")[2].split("]")[0]
+
+    def getProductBoard(self):
+        cmd = f"adb -s {self.serial} shell getprop |grep ro.product.board"
+        out = rCmd(cmd)[0]
+        return out.split("[")[2].split("]")[0]
+
+    def getScreenSize(self):
+        cmd = f"adb -s {self.serial} shell wm size"
+        out, _error = rCmd(cmd, checkErr=True)
+        if "Physical size:" in out:
+            size_str = out.split(":")[1].strip()
+            width, height = map(int, size_str.split("x"))
+            return width, height
+        logw(f"get {self.serial} lcd size failed, set it to 720x1600 by default")
+        return 720, 1600
+
+    def slectBoard(self):
+        boardList = ["dove", "larkl", "lark", "larkpro"]
+        while True:
+            try:
+                user_input = input(f"{Fore.GREEN}请输入SOC型号 {boardList}: {Fore.RESET}")
+                if user_input in boardList:
+                    return user_input
+                loge("无效的SOC型号,请重新输入")
+            except ValueError:
+                loge("输入无效,请输入SOC型号.")
+
+    def getASRDevice(self):
+        if self.devices:
+            for device in self.devices:
+                prop = ["ro.boot.hardware.soc", "ro.product.model", "ro.soc.model"]
+                for i in prop:
+                    cmd = f"adb -s {device['serial']} shell getprop |grep -iE {i} "
+                    out = rCmd(cmd)[0]
+                    logd(out)
+                    if "asr" in out.lower():
+                        if "8601" in out.lower():
+                            self.soc = "dove"
+                        elif "8602" in out.lower():
+                            self.soc = "dovelite"
+                        elif "8661" in out.lower():
+                            self.soc = "lark"
+                        elif "8662" in out.lower():
+                            self.soc = "larkl"
+                        elif "8861" in out.lower():
+                            self.soc = "larkpro"
+                        else:
+                            self.soc = None
+                        if self.soc is not None:
+                            return self.soc
+            logw("get SOC from prop failed, manual set it")
+            self.soc = self.slectBoard()
+            return self.soc
+        eExit("No device connected.")
+
+    def getSoc(self):
+        if self.devices:
+            prop = ["ro.boot.hardware.soc", "ro.product.model", "ro.soc.model"]
+            for i in prop:
+                cmd = f"adb -s {self.serial} shell getprop |grep -iE {i} "
+                out = rCmd(cmd)[0]
+                logd(out)
+                if "asr" in out.lower():
+                    if "8601" in out.lower():
+                        self.soc = "dove"
+                    elif "8602" in out.lower():
+                        self.soc = "dovelite"
+                    elif "8661" in out.lower():
+                        self.soc = "lark"
+                    elif "8662" in out.lower():
+                        self.soc = "larkl"
+                    elif "8861" in out.lower():
+                        self.soc = "larkpro"
+                    else:
+                        self.soc = None
+                    if self.soc is not None:
+                        return self.soc
+            logw("get SOC from prop failed, manual set it")
+            self.soc = self.slectBoard()
+            return self.soc
+        eExit("ASR SOC not found")
+
+    def checkCameraOpened(self):
+        cmd = f"adb -s {self.serial} shell dumpsys window | grep mFocus"
+        out, error = rCmd(cmd)
+        if "camera" in out.lower():
+            return True
+        loge("camera not open, start camera ...")
+        rCmd("adb shell am start -a android.media.action.STILL_IMAGE_CAMERA", 1)
+        sleep(2)
+
+    def adbRoot(self):
+        cmd = f"adb -s {self.serial} root"
+        return rCmd(cmd, 0.5, showCmd=True, timeOut=10, showRet=True, logLevel="info")
+
+    def adbRemount(self):
+        cmd = f"adb -s {self.serial} remount"
+        info, err = rCmd(cmd, 0.5, timeOut=10)
+        self.setLcdTimeout()
+        if err != "":
+            logi(err.split("\n")[0])
+            logi(err.split("\n")[-2])
+        elif info != "":
+            logi(info.split("\n")[0])
+        return info, err
+
+    def setLcdTimeout(self, time_s=3600):
+        cmd = f"adb -s {self.serial} shell settings put system screen_off_timeout {time_s * 1000}"
+        _ = rCmd(cmd, 0.5, showCmd=True, timeOut=3, logLevel="debug", showRet=True)
+
+    def adbReboot(self):
+        cmd = f"adb -s {self.serial} reboot"
+        return rCmd(cmd, 0.5, timeOut=10)
+
+    def adbScreenBrightness(self, brightness=255):
+        cmd = f'adb -s {self.serial} shell "settings put system screen_brightness {brightness}"'
+        oCmd(cmd, showCmd=True, logLevel="info")
+
+    def adbSocket(self):
+        cmd = f"adb -s {self.serial} forward tcp:12218 localabstract:camera_tuning_server"
+        rCmd(cmd, 0.5, checkErr=True)
+
+    def adbTap(self, cordinateABS, slp=1):
+        cordinate = [cordinateABS[0] * self.xRatio, cordinateABS[1] * self.yRatio]
+        cordinate = list(map(int, cordinate))
+        cmd = f"adb -s {self.serial} shell input tap {cordinate[0]} {cordinate[1]}"
+        rCmd(cmd, slp, True, logLevel="info")
+
+    def adbSwipe(self, cordinateABS, slp=2, time_ms=600):
+        cordinate = [
+            cordinateABS[0] * self.xRatio,
+            cordinateABS[1] * self.yRatio,
+            cordinateABS[2] * self.xRatio,
+            cordinateABS[3] * self.yRatio,
+        ]
+        cordinate = list(map(int, cordinate))
+        cmd = f"adb -s {self.serial} shell input swipe {cordinate[0]} {cordinate[1]} {cordinate[2]} {cordinate[3]} {time_ms}"
+        rCmd(cmd, slp, True, logLevel="info")
+
+    def take_screenshot(self, outPath):
+        success = self._try_screencap(args=["-p"], outPath=outPath)
+        if success:
+            return True
+        return self._try_screencap(args=["--preserve-display-colors", "-p"], outPath=outPath)
+
+    def _try_screencap(self, args, outPath):
+        try:
+            cmd = ["adb", "-s", self.serial, "exec-out", "screencap"] + args
+            result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=15)
+            if result.returncode != 0:
+                logi(f"failed: {result.stderr.decode()}")
+                return False
+            data = result.stdout
+            if len(data) < 8 or data[:4] != b"\x89PNG":
+                logw(f"invalid PNG, size={len(data)}, args={args}")
+                return False
+            os.makedirs(os.path.dirname(outPath), exist_ok=True)
+            with open(outPath, "wb") as f:
+                f.write(data)
+            logi(f"success: {outPath}, size={len(data)}")
+            return True
+        except subprocess.TimeoutExpired:
+            loge(f"timeout, args={args}")
+            return False
+        except Exception as e:
+            loge(f"exception: {e}")
+            return False
+
+    def adbScreenCap(self, fileName):
+        outPath = os.path.join(self.curPath, fileName + ".png")
+        self.take_screenshot(outPath)
+
+    def adbScreenRec(
+        self,
+        fileName,
+        limitTime_s="30",
+        bitRate_Mbps="2",
+        inputWidth=None,
+        inputHeight=None,
+        debug=True,
+        isThread=False,
+    ):
+        limitTime_s = int(limitTime_s)
+        bitRate_Mbps = int(float(bitRate_Mbps) * 1000000)
+        inputWidth = int(inputWidth) if inputWidth is not None else None
+        inputHeight = int(inputHeight) if inputHeight is not None else None
+        mp4Name = fileName + ".mp4"
+        cmd1 = f"adb -s {self.serial} shell screenrecord --time-limit {limitTime_s}"
+        cmd2 = f"--bugreport --bit-rate {bitRate_Mbps}" if debug else f"--bit-rate {int(bitRate_Mbps)}"
+        if inputWidth is None or inputHeight is None:
+            recordWidth, recordHeight = self.curScreenW, self.curScreenH
+        elif inputWidth > self.curScreenW or inputHeight > self.curScreenH:
+            logw(
+                f"inputWidth {inputWidth} or inputHeight {inputHeight} > lcdWidth {self.curScreenW} or lcdHeight {self.curScreenH}, use lcd size"
+            )
+            recordWidth, recordHeight = self.curScreenW, self.curScreenH
+        else:
+            recordWidth, recordHeight = inputWidth, inputHeight
+
+        cmd3 = f"--size {recordWidth}x{recordHeight} /sdcard/{mp4Name}"
+        cmd = f"{cmd1} {cmd2} {cmd3}"
+        if sysVersion == "Linux":
+            pCmd(cmd, showCmd=True, splitCmd=False, shell=True, logLevel="info", waitDone=False)
+        else:
+            pCmd(cmd, showCmd=True, splitCmd=False, shell=False, logLevel="info", waitDone=False)
+        try:
+            if isThread:
+                logi(
+                    f"等待{limitTime_s}s 自动结束录制 {mp4Name} {bitRate_Mbps / 1000000}Mbps {recordWidth}x{recordHeight}"
+                )
+                sleep(float(limitTime_s))
+            else:
+                logi(
+                    f"回车或等待{limitTime_s}s 结束录制 {mp4Name} {bitRate_Mbps / 1000000}Mbps {recordWidth}x{recordHeight}"
+                )
+                char = func_timeout(float(limitTime_s), lambda: input())
+                if char or char == "":
+                    pass
+        except FunctionTimedOut:
+            pass
+        finally:
+            stopCmd = f"adb -s {self.serial} shell pkill -2 -f screenrecord"
+            pCmd(stopCmd, 0.5, showCmd=True, splitCmd=False, shell=True, logLevel="info")
+            outfile = os.path.join(self.curPath, mp4Name)
+            cmd = f"adb -s {self.serial} pull sdcard/{mp4Name} {outfile}"
+            pCmd(cmd, 1, showCmd=True, splitCmd=False, shell=True, timeOut=10, logLevel="info")
+
+    def keyHome(self, slp=0.5):
+        cmd = f"adb -s {self.serial} shell input keyevent KEYCODE_HOME"
+        rCmd(cmd, slp)
+
+    def keyBack(self, slp=0.5):
+        cmd = f"adb -s {self.serial} shell input keyevent BACK"
+        rCmd(cmd, slp)
+
+    def keyMenu(self, slp=0.5):
+        cmd = f"adb -s {self.serial} shell input keyevent KEYCODE_MENU"
+        rCmd(cmd, slp)
+
+    def keyPower(self, slp=0.5):
+        cmd = f"adb -s {self.serial} shell input keyevent KEYCODE_POWER"
+        rCmd(cmd, slp)
+
+    def keyWakeup(self, slp=0.5):
+        cmd = f"adb -s {self.serial} shell input keyevent KEYCODE_WAKEUP"
+        rCmd(cmd, slp)
+
+    def adbCmd(self, cmdStr, withShell=True, slp=0.5):
+        if withShell:
+            cmd = f"adb -s {self.serial} shell {cmdStr}"
+        else:
+            cmd = f"adb -s {self.serial} {cmdStr}"
+        rCmd(cmd, slp, showCmd=True, logLevel="info")
+
+    def keyCapture(self, slp=0.5):
+        cmd = f"adb -s {self.serial} shell input keyevent 27"
+        rCmd(cmd, slp)
+
+    def pushFile(self, local, target):
+        cmd = f"adb -s {self.serial} push {local} {target}"
+        out, err = rCmd(cmd, 0.5, showCmd=True, logLevel="info")
+        logi(out)
+        checkMsg(err, "failed", "device may need remount")
+        if "Read-only" in out:
+            eExit("device is Read-only, may need remount")
+
+    def isLcdOn(self):
+        cmd = f"adb -s {self.serial} shell dumpsys window policy"
+        out, _ = rCmd(cmd, 0.5)
+        return not re.search("screenState=SCREEN_STATE_OFF", out)
+
+    def isScreenLock(self):
+        try:
+            cmd = f"adb -s {self.serial} shell dumpsys window policy"
+            out, _ = rCmd(cmd, 0.5)
+            return bool(re.search("showing=true", out))
+        except Exception as e:
+            loge(f"获取手机lock状态异常{e}")
+            return False
+
+    def lcdOnAndUnlock(self, on=1):
+        if on == 0:
+            if self.isLcdOn():
+                self.keyPower(1)
+                if self.isLcdOn():
+                    self.keyPower(1)
+        else:
+            if self.isLcdOn():
+                if self.isScreenLock():
+                    self.keyMenu(1)
+                    if self.isScreenLock():
+                        self.keyPower(1)
+            else:
+                self.keyWakeup(1)
+                self.keyMenu(1)
+                if self.isScreenLock():
+                    self.keyPower(1)
+
+    def openCam(self, id=0):
+        if id == 0:
+            rCmd("adb shell am start -a android.media.action.STILL_IMAGE_CAMERA", 1)
+        else:
+            rCmd("adb shell am start -a android.media.action.STILL_IMAGE_CAMERA", 2)
+            sleep(1)
+            self.adbTap((600, 1400))
+        sleep(2)
+
+    def getSuffixList(self, path: str, *suffix: str):
+        fileList = []
+        cmd = f"adb -s {self.serial} shell ls -t {path}"
+        allFileList = rCmd(cmd)[0].split("\n")[0:-1]
+        logd(str(allFileList))
+        for file in allFileList:
+            for i in suffix:
+                if file.lower().endswith(i) and "thumb" not in file:
+                    fileList.append(file)
+        return fileList
+
+    def capJPG(self, name="null", wait=3):
+        outPath = self.curPath
+        logi(f"capture {os.path.join(outPath, name)}.jpg")
+        jpgPath = r"/sdcard/DCIM/Camera/"
+        oldFileList = self.getSuffixList(jpgPath, "jpg", "jpeg")
+        cmd = f"adb -s {self.serial} shell input keyevent 27"
+        rCmd(cmd, 0.5, True, logLevel="info")
+        sleep(wait)
+
+        founded = False
+        for i in range(5):
+            fileList = self.getSuffixList(jpgPath, "jpg", "jpeg")
+            for f in fileList:
+                if "~" in f:
+                    fileList.remove(f)
+            jpgNameList = list(set(fileList) - set(oldFileList))
+            if jpgNameList != []:
+                jpgName = jpgNameList[0]
+                founded = True
+                if name == "null":
+                    cmd = f"adb -s {self.serial} pull {jpgPath}{jpgName}"
+                else:
+                    cmd = f"adb -s {self.serial} pull {jpgPath}{jpgName} {name}.jpg"
+                rCmd(cmd, 0.5, True, logLevel="info")
+                break
+            else:
+                sleep(1.0)
+        if not founded:
+            loge(f"capture {os.path.join(outPath, name)}.jpg failed")
+            return False
+        return True
+
+    def killCamera(self):
+        cmd = f"adb -s {self.serial} shell input keyevent KEYCODE_HOME"
+        rCmd(cmd, 0.5)
+        rCmd("adb shell pm clear com.asrmicro.camera", 0.5, showCmd=True, logLevel="info")
+        keyStr = "camera"
+        cmd = f"adb -s {self.serial} shell ps -e |grep {keyStr}"
+        out, _err = rCmd(cmd, showCmd=True, logLevel="info")
+        for i in out.splitlines():
+            PID = i.split()[1]
+            if r"android.hardware.camera.provider@2" in i.split()[8]:
+                cmd = f"adb -s {self.serial} shell kill -9 {PID}"
+                out, err = rCmd(cmd, 0.5, showCmd=True, logLevel="info")
+                if "Operation not permitted" in err:
+                    eExit("Operation not permitted,device need need remount")
+        sleep(2)
+
+    def backUpSo(self, so):
+        backUpName = so + ".ori"
+        cmd = f"adb -s {self.serial} shell ls vendor/lib64/ | grep {backUpName}"
+        out, _ = pCmd(cmd, showCmd=True, showRet=False, logLevel="debug")
+        if out == "":
+            logi(f"{backUpName} not exist, backup {so}")
+            cmd = f"adb -s {self.serial} shell cp vendor/lib64/{so} vendor/lib64/{backUpName}"
+            _, _ = pCmd(cmd, showCmd=True, showRet=True, logLevel="debug")
+        else:
+            logi(f"{backUpName} already exist, skip backup")
+
+    def pushso(self, so):
+        for i in so:
+            soWithOutPath = os.path.basename(i)
+            self.backUpSo(soWithOutPath)
+            cmd = f"adb -s {self.serial} push {i} vendor/lib64/{soWithOutPath}"
+            out, err = pCmd(cmd, showCmd=True, showRet=True, logLevel="info")
+            if "Read-only" in out:
+                eExit("device is Read-only, may need remount")
+        self.killCamera()
+
+    def pushI2cTransfer(self):
+        cmd = f"adb -s {self.serial} shell ls /system/bin/ |grep i2c_transfer"
+        out = rCmd(cmd)[0]
+        if "i2c_transfer" not in out:
+            i2cttPath = os.path.join(sys.path[0], "i2c_transfer")
+            if not os.path.exists(i2cttPath):
+                loge(f"{i2cttPath} not exist!")
+                return
+            cmd = f"adb -s {self.serial} push {i2cttPath} system/bin"
+            out, err = rCmd(cmd, showCmd=True, logLevel="debug")
+            checkMsg(err, "failed", "device may need remount")
+            cmd = f"adb -s {self.serial} shell chmod a+x /system/bin/i2c_transfer"
+            out, err = rCmd(cmd, showCmd=True, logLevel="debug")
+
+    def i2cTest(self, dev, addr):
+        self.pushI2cTransfer()
+        cmd = f"adb shell /system/bin/i2c_transfer {dev} w2@{addr} 0x0 0x0 r1"
+        info, _ = rCmd(cmd, showCmd=True, logLevel="debug")
+        return info != ""
+
+    def i2cDet(self, devID=None):
+        self.pushI2cTransfer()
+        if devID is not None:
+            for j in range(0x10, 0x77):
+                print("\r" + f"detecting dev[{devID}] addr[{hex(j)}]", end=" ")
+                if self.i2cTest(devID, hex(j)):
+                    print(f"| dev-{devID} detected {hex(j)}")
+            print("")
+        else:
+            for i in range(0, 2):
+                for j in range(0x10, 0x77):
+                    print("\r" + f"detecting dev[{i}] addr[{hex(j)}]", end=" ")
+                    if self.i2cTest(i, hex(j)):
+                        print(f"| dev-{i} detected {hex(j)}")
+                print("")
+
+    def i2cDump(self, busID, devAddr):
+        cmd = f"adb -s {self.serial} shell /system/bin/i2cdump -f -y {busID} {devAddr}"
+        rCmd(cmd, showCmd=True, showRet=True, logLevel="info")
+
+    def i2c(self, devID, devAddr, regAddr, regValue=None, readNum=1):
+        self.pushI2cTransfer()
+        addr_len = 2 if len(regAddr) > 4 else 1
+        preCmdStr = f"adb -s {self.serial} shell /system/bin/i2c_transfer {devID}"
+        if regValue == None:
+            if readNum == 1:
+                if addr_len == 2:
+                    regAddrH = hex(int(regAddr, 16) >> 8)
+                    regAddrL = hex(int(regAddr, 16) & 0xFF)
+                    cmd = f"{preCmdStr} w2@{devAddr} {regAddrH} {regAddrL} r1"
+                else:
+                    cmd = f"{preCmdStr} w1@{devAddr} {regAddr} r1"
+                info, err = rCmd(cmd, showCmd=True)
+                checkMsg(err, "inaccessible", "device may need remount")
+                info = info.strip().split("\n")[0].strip("'")
+                logi(f"read bus[{devID}] dev[{devAddr}] {regAddr} = {info}")
+            else:
+                regAddr = int(regAddr, 16)
+                for i in range(readNum):
+                    if addr_len == 2:
+                        regAddrH = hex(regAddr >> 8)
+                        regAddrL = hex(regAddr & 0xFF)
+                        cmd = f"{preCmdStr} w{addr_len}@{devAddr} {regAddrH} {regAddrL} r1"
+                    else:
+                        cmd = f"{preCmdStr} w{addr_len}@{devAddr} {regAddr} r1"
+                    info, err = rCmd(cmd, showCmd=True)
+                    checkMsg(err, "inaccessible", "device may need remount")
+                    info = info.strip().split("\n")[0].strip("'")
+                    logi(f"read bus[{devID}] dev[{devAddr}] {hex(regAddr)} = {info}")
+                    regAddr = regAddr + 1
+        else:
+            cmd = ""
+            value_len = 2 if len(regValue) > 4 else 1
+            if addr_len == 2:
+                regAddrH = hex(int(regAddr, 16) >> 8)
+                regAddrL = hex(int(regAddr, 16) & 0xFF)
+                if value_len == 1:
+                    cmd = f"{preCmdStr} w3@{devAddr} {regAddrH} {regAddrL} {regValue}"
+                elif value_len == 2:
+                    regValueH = hex(int(regValue, 16) >> 8)
+                    regValueL = hex(int(regValue, 16) & 0xFF)
+                    cmd = f"{preCmdStr} w4@{devAddr} {regAddrH} {regAddrL} {regValueH} {regValueL}"
+            else:
+                cmd = f"{preCmdStr} w2@{devAddr} {regAddr} {regValue}"
+            info, err = rCmd(cmd, showCmd=True)
+            checkMsg(err, "inaccessible", "device may need remount")
+            info = info.strip().split("\n")[0].strip("'")
+            logi(f"write bus[{devID}] dev[{devAddr}] {regAddr} = {regValue}")
+
+    def i2c_write_addr16_value8(self, devID, devAddr, regAddr, value):
+        regValue = str(hex(value))
+        regAddrH = hex(int(regAddr, 16) >> 8)
+        regAddrL = hex(int(regAddr, 16) & 0xFF)
+        preCmdStr = f"adb -s {self.serial} shell /system/bin/i2c_transfer {devID}"
+        cmd = f"{preCmdStr} w3@{devAddr} {regAddrH} {regAddrL} {regValue}"
+        info, err = rCmd(cmd, showCmd=True)
+        checkMsg(err, "inaccessible", "device may need remount")
+        info = info.strip().split("\n")[0].strip("'")
+        logi(f"write bus[{devID}] dev[{devAddr}] {regAddr} = {regValue}")
+
+
+def CLI_pushSo(argsList):
+    parser = argparse.ArgumentParser(prog="pushso", description="android设备push so文件")
+    parser.add_argument("-p", "--path", required=True, nargs="+", help="so文件名或路径,支持多so文件 push")
+    parser.add_argument("-s", "--serial", type=str, default="", help="设备SN号(多设备需指定)")
+    args = parser.parse_args(argsList)
+
+    dev = DevOp(args.serial)
+    so = []
+    if len(args.path) == 1:
+        if os.path.isdir(args.path[0]):
+            so = findFilesBySuffixKeyword(args.path[0], ".so", "")
+            dev.pushso(so)
+        else:
+            dev.pushso(args.path)
+    else:
+        dev.pushso(args.path)
+
+
+def CLI_scrcpy(argsList):
+    parser = argparse.ArgumentParser(prog="scrcpy", description="android设备投屏")
+    parser.add_argument("-s", "--serial", type=str, default="", help="设备SN号(多设备需指定)")
+    parser.add_argument("--top", action="store_true", dest="top", help="投屏置顶")
+    parser.set_defaults(top=False)
+    parser.add_argument("--lcdoff", action="store_true", dest="lcdoff", help="关闭lcd")
+    parser.set_defaults(lcdoff=False)
+    args = parser.parse_args(argsList)
+
+    dev = DevOp(args.serial)
+    args_top = "scrcpy --always-on-top" if args.top else "scrcpy"
+    lcd_off = "-SKw -s" if args.lcdoff else "-Kw -s"
+    cmd = f"{args_top} {lcd_off} {dev.serial} --shortcut-mod=lctrl"
+    info, err = pCmd(cmd, showCmd=True, waitDone=False, logLevel="info")
+    # print(err)
+    checkMsg(err, "Device disconnected", err)
+
+
+def CLI_power(argsList):
+    parser = argparse.ArgumentParser(prog="power", description="android power on/off")
+    parser.add_argument("-s", "--serial", type=str, default="", help="设备SN号(多设备需指定)")
+    parser.add_argument("--off", action="store_false", dest="power", help="关闭屏幕")
+    parser.set_defaults(power=True)
+    args = parser.parse_args(argsList)
+
+    dev = DevOp(args.serial)
+    logi("power on" if args.power else "power off")
+    dev.lcdOnAndUnlock(args.power)
+
+
+def CLI_cam(args):
+    dev = DevOp()
+    if len(args) == 0:
+        dev.openCam()
+    else:
+        # TODO 支持切换前摄
+        dev.openCam(int(args[0]))
+
+
+def CLI_screenCap(argsList):
+    parser = argparse.ArgumentParser(prog="screenCap", description="android设备截屏")
+    parser.add_argument(
+        "-f", "--file", required=False, default="tmp", help="截屏文件名,自动添加后缀.png (默认tmp,可选)"
+    )
+    parser.add_argument("-s", "--serial", type=str, default="", help="设备SN号(多设备需指定)")
+    args = parser.parse_args(argsList)
+
+    dev = DevOp(args.serial)
+    if not dev.isLcdOn():
+        eExit("lcd off")
+    dev.adbScreenCap(args.file)
+
+
+def CLI_screenRec(argsList):
+    parser = argparse.ArgumentParser(prog="screenRec", description="对android设备录屏")
+    parser.add_argument(
+        "-f", "--file", required=False, default="tmp", help="录制文件名,自动添加后缀.mp4 (默认tmp,可选)"
+    )
+    parser.add_argument("-t", "--time", required=False, default="30", help="录制时间,单位秒 (默认30秒,可选)")
+    parser.add_argument("-b", "--bitrate", required=False, default="2", help="录制比特率,单位Mbps (默认2,可选)")
+    parser.add_argument("-s", "--serial", type=str, default="", help="设备SN号(多设备需指定)")
+    parser.add_argument("--width", required=False, default=None, help="录制宽度 (默认lcd size,可选)")
+    parser.add_argument("--height", required=False, default=None, help="录制高度 (默认lcd size,可选)")
+    parser.add_argument(
+        "--no-debug", action="store_false", dest="debug", help="禁用调试模式,开启可在视频上添加时间戳等额外信息"
+    )
+    parser.set_defaults(debug=True)  # 设置默认值为 True
+    args = parser.parse_args(argsList)
+
+    dev = DevOp(args.serial)
+    if not dev.isLcdOn():
+        eExit("lcd off")
+    dev.adbScreenRec(
+        fileName=args.file,
+        limitTime_s=args.time,
+        bitRate_Mbps=args.bitrate,
+        inputWidth=args.width if args.width else None,
+        inputHeight=args.height if args.height else None,
+        debug=args.debug,
+    )
+
+
+def i2cParseArguments(argsList):
+    parser = argparse.ArgumentParser(prog="iic", description="对android设备进行iic操作")
+
+    # 创建子解析器
+    subparsers = parser.add_subparsers(dest="operation", required=True, help="操作类型")
+
+    # 1. rw 操作
+    parser_rw = subparsers.add_parser("rw", help="读写操作")
+    parser_rw.add_argument("-b", "--busid", required=True, choices=["0", "1", "2"], help="设备ID (必须)")
+    parser_rw.add_argument("-d", "--devaddr", required=True, help="设备地址 (必须)")
+    parser_rw.add_argument("-a", "--addr", required=True, help="设备寄存器地址 (必须)")
+    parser_rw.add_argument("-v", "--value", required=False, default=None, help="设备寄存器值 (读取不用设)")
+    parser_rw.add_argument("-r", "--readnum", type=str, default="1", help="读取寄存器数量 (可选)")
+
+    # 2. det 操作
+    parser_det = subparsers.add_parser("det", help="检测操作")
+    parser_det.add_argument("-b", "--busid", choices=["0", "1", "2"], help="设备ID (可选)")
+
+    # 3. dump 操作
+    parser_dump = subparsers.add_parser("dump", help="总线检查操作")
+    parser_dump.add_argument("-b", "--busid", required=True, choices=["0", "1", "2"], help="设备ID (必须)")
+    parser_dump.add_argument("-d", "--devaddr", required=True, help="设备地址 (必须)")
+
+    args = parser.parse_args(argsList)
+    return args
+
+
+def CLI_i2c(argsList):
+    args = i2cParseArguments(argsList)
+    dev = DevOp(needRoot=False)
+
+    if args.operation == "det":
+        # det 操作：busid 可选
+        if args.busid is not None:
+            dev.i2cDet(int(args.busid))
+        else:
+            dev.i2cDet()
+
+    elif args.operation == "dump":
+        # dump 操作：busid 和 devaddr 必须
+        dev.i2cDump(args.busid, args.devaddr)
+
+    elif args.operation == "rw":
+        # rw 操作：
+        dev.i2c(args.busid, args.devaddr, args.addr, args.value, int(args.readnum))
+
+
+def CLI_kcam(args):
+    dev = DevOp()
+    dev.killCamera()
+
+
+def CLI_capjpg(argsList):
+    parser = argparse.ArgumentParser(prog="capjpg", description="拍摄jpg并导出到PC指定文件名")
+    parser.add_argument("-f", "--file", type=str, default="null", help="jpg名称")
+    parser.add_argument("-s", "--serial", type=str, default="", help="设备SN号")
+    parser.add_argument("-w", "--wait", type=int, default=3, help="拍照之后等待时间,单位秒,deault 3s")
+    parser.add_argument("-d", "--devname", type=str, default=None, help="jpg名称后缀标签")
+    parser.add_argument("--reset", action="store_true", help="清除缓存，重新扫描设备")
+    args = parser.parse_args(argsList)
+    if args.reset and os.path.exists(CACHE_FILE):
+        os.remove(CACHE_FILE)
+        logi("[cache] 缓存已清除")
+    dev = DevOp(args.serial)
+    dev.checkCameraOpened()
+    name = args.file + args.devname if args.devname else args.file
+    dev.capJPG(name, wait=args.wait)
+
+
+def CLI_capjpgThread(argsList):
+    parser = argparse.ArgumentParser(prog="capjpg2", description="同时拍摄两台机器jpg并导出到PC指定文件名")
+    parser.add_argument("-f", "--file", type=str, default="null", help="jpg名称")
+    parser.add_argument("-s1", "--serial1", type=str, required=True, help="设备1 SN号")
+    parser.add_argument("-s2", "--serial2", type=str, required=True, help="设备2 SN号")
+    parser.add_argument("-w", "--wait", type=int, default=3, help="拍照之后等待时间,单位秒")
+    parser.add_argument("-d1", "--devname1", type=str, required=True, help="设备1 jpg名称后缀标签")
+    parser.add_argument("-d2", "--devname2", type=str, required=True, help="设备2 jpg名称后缀标签")
+    args = parser.parse_args(argsList)
+    d1 = f"-f {args.file} -s {args.serial1} -w {args.wait} -d {args.devname1}".split()
+    d2 = f"-f {args.file} -s {args.serial2} -w {args.wait} -d {args.devname2}".split()
+    thread1 = threading.Thread(target=CLI_capjpg, args=(d1,))
+    thread2 = threading.Thread(target=CLI_capjpg, args=(d2,))
+    thread1.start()
+    thread2.start()
+    thread1.join()
+    thread2.join()
+
+
+def CLI_wirelessHelp(args=None):
+    print(" linux: 10.1.164.212")
+    print(" windows: 10.1.176.39")
+    print(" 手机开启热点,PC连接热点")
+    print(' adb shell ifconfig |grep "inet addr"    #查看ip')
+    print(" adb shell ip route    #查看ip")
+    print(" adb tcpip 5 ")
+    print(" adb connect 192.168.191.2:5 ")
+    print(" adb disconnect 192.168.191.2:5   #断开连接")
+    print(" adb usb  #切换回usb")
+
+
+def CLI_rootRemount(argsList):
+    parser = argparse.ArgumentParser(prog="rootRemount", description="android设备root,remount")
+    parser.add_argument("-s", "--serial", type=str, default="", help="设备SN号(多设备需指定)")
+    args = parser.parse_args(argsList)
+
+    dev = DevOp(args.serial, needRoot=True)
+
+
+def _dsrPrepare(dev_1: DevOp, dev_2: DevOp):
+    dev_1.adbTap((500, 1500), 0)
+    dev_1.adbTap((500, 1500), 0)
+    dev_1.adbTap((580, 128), 0)
+    dev_1.adbTap((580, 128), 0)
+    dev_2.adbTap((580, 128), 0)
+    dev_2.adbTap((580, 128), 0)
+    sleep(1)
+    dev_1.adbTap((580, 128), 0)
+    dev_2.adbTap((580, 128), 0)
+
+
+def CLI_threadScreenRec(argsList):
+    parser = argparse.ArgumentParser(prog="screenRec", description="对android设备录屏")
+    parser.add_argument(
+        "-f", "--file", required=False, default="tmp", help="录制文件名,自动添加后缀.mp4 (默认tmp,可选)"
+    )
+    parser.add_argument("-t", "--time", required=False, default="30", help="录制时间,单位秒 (默认30秒,可选)")
+    parser.add_argument("-b", "--bitrate", required=False, default="2", help="录制比特率,单位Mbps (默认2,可选)")
+    parser.add_argument("--width", required=False, default=None, help="录制宽度 (默认lcd size,可选)")
+    parser.add_argument("--height", required=False, default=None, help="录制高度 (默认lcd size,可选)")
+    parser.add_argument(
+        "--no-debug", action="store_false", dest="debug", help="禁用调试模式,开启可在视频上添加时间戳等额外信息"
+    )
+    parser.set_defaults(debug=True)  # 设置默认值为 True
+
+    parser.add_argument("--serial1", required=True, help="设备1 SN号")
+    parser.add_argument("--serial2", required=True, help="设备2 SN号")
+    args = parser.parse_args(argsList)
+    s1 = args.serial1
+    s2 = args.serial2
+    dev_1 = DevOp(s1)
+    dev_2 = DevOp(s2)
+    _dsrPrepare(dev_1, dev_2)
+
+    thread1 = threading.Thread(
+        target=dev_1.adbScreenRec,
+        kwargs={
+            "fileName": f"{args.file}_{s1}",
+            "limitTime_s": args.time,
+            "bitRate_Mbps": args.bitrate,
+            "inputWidth": args.width,
+            "inputHeight": args.height,
+            "debug": args.debug,
+            "isThread": True,
+        },
+    )
+
+    thread2 = threading.Thread(
+        target=dev_2.adbScreenRec,
+        kwargs={
+            "fileName": f"{args.file}_{s2}",
+            "limitTime_s": args.time,
+            "bitRate_Mbps": args.bitrate,
+            "inputWidth": args.width,
+            "inputHeight": args.height,
+            "debug": args.debug,
+            "isThread": True,
+        },
+    )
+
+    thread1.start()
+    thread2.start()
+    thread1.join()
+    thread2.join()
+
+
+def CLI_clenDevCache(argsList):
+    if os.path.exists(CACHE_FILE):
+        os.remove(CACHE_FILE)
+        logi("[cache] 缓存已清除")
+
+
+_COMMAND_REGISTRY = {}
+
+
+def printHelp():
+    print("[device]")
+    print("pushso -h            :push so to vendor/lib64")
+    print("scr -h               :android 投屏")
+    print("po -h                :android power {--off}")
+    print("cam                  :open camera")
+    print("sc -h                :android 截屏- {name}:without suffix")
+    print("sr -h                :android 录屏- {name}:without suffix")
+    print("dsr -h               :android 双设备同时录屏")
+    print("iic {rw/det/dump} -h :android i2c 操作")
+    print("kcam                 :kill android cameraserver and clean camera app")
+    print("capjpg -h            :capture jpg")
+    print("capjpg2 -h           :capture jpg in a threaded way")
+    print("wi                   :show wireless help")
+    print("rt -h                :root and remount")
+    print("cl                   :clear device cache")
+
+
+CLI_pushSo = register_command("pushso", registry=_COMMAND_REGISTRY)(CLI_pushSo)
+CLI_scrcpy = register_command("scr", registry=_COMMAND_REGISTRY)(CLI_scrcpy)
+CLI_power = register_command("po", registry=_COMMAND_REGISTRY)(CLI_power)
+CLI_cam = register_command("cam", registry=_COMMAND_REGISTRY)(CLI_cam)
+CLI_screenCap = register_command("sc", registry=_COMMAND_REGISTRY)(CLI_screenCap)
+CLI_screenRec = register_command("sr", registry=_COMMAND_REGISTRY)(CLI_screenRec)
+CLI_threadScreenRec = register_command("dsr", registry=_COMMAND_REGISTRY)(CLI_threadScreenRec)
+CLI_i2c = register_command("iic", registry=_COMMAND_REGISTRY)(CLI_i2c)
+CLI_kcam = register_command("kcam", registry=_COMMAND_REGISTRY)(CLI_kcam)
+CLI_capjpg = register_command("capjpg", registry=_COMMAND_REGISTRY)(CLI_capjpg)
+CLI_capjpgThread = register_command("capjpg2", registry=_COMMAND_REGISTRY)(CLI_capjpgThread)
+CLI_wirelessHelp = register_command("wi", registry=_COMMAND_REGISTRY)(CLI_wirelessHelp)
+CLI_rootRemount = register_command("rt", registry=_COMMAND_REGISTRY)(CLI_rootRemount)
+CLI_clenDevCache = register_command("cl", registry=_COMMAND_REGISTRY)(CLI_clenDevCache)
+
+
+def deviceMain(args):
+    debugCtrl(1) if "debug" in args else debugCtrl(0)
+    args.remove("debug") if "debug" in args else args
+    args = normalize_args(args)
+    if len(args) < 1 or args[0] in {"help", "-h", "--help"}:
+        printHelp()
+        return
+    cmd = args[0]
+    handler = _COMMAND_REGISTRY.get(cmd)
+    if handler is None:
+        loge(f"unsupport command {cmd}")
+        return
+    handler(args[1:])
+
+
+if __name__ == "__main__":
+    debugCtrl(1) if "debug" in sys.argv else debugCtrl(0)
+    sys.argv.remove("debug") if "debug" in sys.argv else sys.argv
+    deviceMain(sys.argv)