taotoolkit 1.0.0__py3-none-any.whl

taotoolkit/tao_flash.py

@@ -0,0 +1,823 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+"""版本下载与烧录相关命令模块。"""
+
+import os
+import sys
+import shutil
+import zipfile
+import argparse
+import requests
+import re
+import jenkins  # pip install python-jenkins
+import threading
+import time
+from time import sleep
+from bs4 import BeautifulSoup as bs
+
+
+from .tao_common import (
+    debugCtrl,
+    eExit,
+    logi,
+    logw,
+    loge,
+    logd,
+    logh,
+    oCmd,
+    rCmd,
+    pCmd,
+    refreshWait,
+    inputSerial,
+    createFolder,
+    findFilesBySuffixKeyword,
+    sysVersion,
+    normalize_args,
+    register_command,
+)
+
+from .tao_device import DevOp
+
+
+class jenkinsTool:
+    # logging.getLogger("urllib3").setLevel(logging.WARNING)
+    def __init__(self, branch, buildTag, ciOwner, isUserDebug="1", jenkinsUser=None, jenkinsPassword=None):
+        self.jenkinsUrl = "http://build.asrmicro.com/"
+        self.jenkinsUser = jenkinsUser if jenkinsUser else os.environ.get("JENKINS_USERNAME", "")
+        self.jenkinsPassword = jenkinsPassword if jenkinsPassword else os.environ.get("JENKINS_PASSWORD", "")
+        self.baseUrl = "http://10.1.24.40/"
+        self.branch = branch
+        self.buildTag = buildTag
+        self.ciOwner = ciOwner
+        self.isUserDebug = True if isUserDebug == "1" else False
+        self.packageFile = "release.zip"
+        self.retainUserData = False  # 是否保留用户数据，默认不保留
+        if sysVersion == "Linux":
+            self.downloadPath = "/home/local/Downloads/jenkin"  # 下载路径和解压路径
+            self.extractPath = "/home/local/Downloads/jenkin"
+            self.aimgTool = "aimgtool"
+        elif sysVersion == "Windows":
+            self.downloadPath = r"D:\jenkin"  # 下载路径和解压路径
+            self.extractPath = r"D:\jenkin"
+            self.aimgTool = "aimgtool.exe"
+        # logi(f"download package to {self.downloadPath}")
+
+    def pickBuildBoard(self, build_info, jobName):
+        logi(f"在 branch[{jobName}] buildID[{build_info['number']}] 找到如下版本，请选择一个序号下载:")
+        filtered_list = []
+        logd(f"artifacts: {build_info['artifacts']}")
+        for i in build_info["artifacts"]:
+            logd(f"relativePath: {i['relativePath']}")
+            if i["fileName"].endswith(self.packageFile):
+                if self.isUserDebug:
+                    if "userdebug" in i["relativePath"]:
+                        filtered_list.append(i["relativePath"].split("/")[1])
+                else:
+                    filtered_list.append(i["relativePath"].split("/")[1])
+
+        foundBoard = {key: index for key, index in enumerate(filtered_list)}
+        if len(foundBoard) == 0:
+            buildType = "userdebug" if self.isUserDebug else "release"
+            eExit(f"no board found in {jobName} buildID {build_info['number']} buildType {buildType}")
+        for k, v in foundBoard.items():
+            print(k, v)
+
+        pickBoard = foundBoard[inputSerial(0, len(foundBoard) - 1)]
+        zip_artifact = next(
+            a
+            for a in build_info["artifacts"]
+            if a["fileName"].endswith(self.packageFile) and pickBoard in a["relativePath"]
+        )
+        zip_url = f"{self.jenkinsUrl}/job/{jobName}/{build_info['number']}/artifact/{zip_artifact['relativePath']}"
+        # print(pickBoard,zip_url)
+        return zip_url
+
+    def getZipArtifact(self, build_info, jobName, buildBoard):
+        zipList = list()
+
+        logd(f"artifacts: {build_info['artifacts']}")
+        for a in build_info["artifacts"]:
+            if (
+                a["fileName"].endswith(self.packageFile)
+                and buildBoard in a["relativePath"]
+                and "xts" not in a["relativePath"]
+            ):
+                if self.isUserDebug:
+                    if "userdebug" in a["relativePath"]:
+                        zipList.append(a)
+                else:
+                    zipList.append(a)
+
+        if len(zipList) == 1:
+            zip_artifact = zipList[0]
+        elif len(zipList) == 0:
+            loge(f"find {jobName} board[{buildBoard}] failed")
+            zip_url = self.pickBuildBoard(build_info, jobName)
+            return zip_url
+        else:
+            print(f"找到如下包含 {buildBoard} 的版本,请选择一个board用于下载:")
+            for index, value in enumerate(zipList):
+                print(f"{index}: {value['relativePath']}")
+            zip_artifact = zipList[inputSerial(0, len(zipList) - 1)]
+
+        zip_url = f"{self.jenkinsUrl}/job/{jobName}/{build_info['number']}/artifact/{zip_artifact['relativePath']}"
+        return zip_url
+
+    def _getFileserverUrl(self, jobName, buildNum, buildBoard):
+        url = f"{self.baseUrl}{jobName}/{buildNum}/{buildBoard}/{self.packageFile}"
+        return url
+
+    def _verifyFileserverUrl(self, url):
+        try:
+            resp = requests.head(url, auth=(self.jenkinsUser, self.jenkinsPassword), timeout=10)
+            return resp.status_code == 200
+        except Exception:
+            return False
+
+    def _listFileserverBoards(self, jobName, buildNum):
+        url = f"{self.baseUrl}{jobName}/{buildNum}/"
+        try:
+            resp = requests.get(url, auth=(self.jenkinsUser, self.jenkinsPassword), timeout=10)
+            resp.raise_for_status()
+            soup = bs(resp.text, "html.parser")
+            boards = []
+            for a in soup.find_all("a", href=True):
+                href = str(a["href"])
+                if href in ("/", "../", "?") or href.startswith("?"):
+                    continue
+                if href.endswith("/"):
+                    name = href.rstrip("/")
+                    if "-" in name and "sp01" in name:
+                        boards.append(name)
+            return boards
+        except Exception as e:
+            loge(f"列出文件服务器 board 失败: {e}")
+            return []
+
+    def findTargetBuild(
+        self, buildNum=0, triggerUser="taotaoli", jobName="adroid16.0_ci", buildBoard="larkpro_phone-sp01-userdebug"
+    ):
+        getDB = "ci" not in jobName
+        server = jenkins.Jenkins(self.jenkinsUrl, self.jenkinsUser, self.jenkinsPassword)
+        buildNum = int(buildNum)
+        zip_url = ""
+        build_info = None
+
+        if buildNum != 0:
+            try:
+                logi(f"getting build info for {jobName} buildNum {buildNum}")
+                build_info = server.get_build_info(jobName, buildNum)
+
+                if build_info.get("building"):
+                    eExit(f"build {buildNum} is still running, please wait")
+
+                logi(f"构建状态: {build_info.get('result')}")
+                logd(f"artifacts: {build_info.get('artifacts')}")
+
+                if build_info.get("artifacts"):
+                    # ── 正常走 Jenkins artifact ──
+                    zip_url = self.getZipArtifact(build_info, jobName, buildBoard)
+                else:
+                    # ── artifact 已被清理，回退到文件服务器 ──
+                    logw(f"build #{buildNum} artifact 已被清理，尝试从文件服务器下载")
+                    zip_url = self._fallbackFileserver(jobName, buildNum, buildBoard)
+
+            except Exception as e:
+                loge(f"获取 build info 失败: {str(e).splitlines()[0]}")
+                if build_info and build_info.get("artifacts"):
+                    zip_url = self.pickBuildBoard(build_info, jobName)
+                else:
+                    # build_info 获取失败或 artifact 为空，直接试文件服务器
+                    logw("尝试直接从文件服务器获取")
+                    zip_url = self._fallbackFileserver(jobName, buildNum, buildBoard)
+            finally:
+                if not zip_url:
+                    eExit(f"find {buildNum} {jobName} board[{buildBoard}] failed")
+            return str(build_info["number"]) if build_info else str(buildNum), zip_url
+
+        else:
+            if getDB:
+                try:
+                    # 先获取最后一次完成构建的编号
+                    last_build_number = server.get_job_info(jobName)["lastCompletedBuild"]["number"]
+                    # 再用编号获取详细信息
+                    build_info = server.get_build_info(jobName, last_build_number)
+
+                    build_time_local = time.strftime(
+                        "%Y-%m-%d %H:%M:%S", time.localtime(build_info["timestamp"] / 1000)
+                    )
+                    if build_info["result"] != "SUCCESS":
+                        logw(
+                            f"目标构建号: {build_info['number']}, 状态: {build_info['result']}, 时间: {build_time_local}"
+                        )
+                    else:
+                        logi(
+                            f"目标构建号: {build_info['number']}, 状态: {build_info['result']}, 时间: {build_time_local}"
+                        )
+
+                    if build_info.get("artifacts"):
+                        zip_url = self.getZipArtifact(build_info, jobName, buildBoard)
+                    else:
+                        logw(f"最新 build #{build_info['number']} artifact 已清理，回退文件服务器")
+                        zip_url = self._fallbackFileserver(jobName, build_info["number"], buildBoard)
+
+                    if not zip_url:
+                        raise Exception("no zip found")
+                except Exception as e:
+                    loge(f"find {jobName} board[{buildBoard}] newest DB failed: {e}")
+                    if build_info and build_info.get("artifacts"):
+                        zip_url = self.pickBuildBoard(build_info, jobName)
+                    elif build_info:
+                        zip_url = self._fallbackFileserver(jobName, build_info["number"], buildBoard)
+
+                if build_info:
+                    return str(build_info["number"]), zip_url
+                else:
+                    eExit(f"find {jobName} board[{buildBoard}] failed")
+
+            else:
+                # 获取指定用户最新 CI（逻辑不变，artifact 为空时同样回退）
+                builds = server.get_job_info(jobName, fetch_all_builds=True)["builds"]
+                buildTmp = None
+                for build in builds:
+                    build_info = server.get_build_info(jobName, build["number"])
+                    actions = build_info.get("actions", [])
+                    triggered_by = next(
+                        (action.get("causes", [{}])[0].get("userId", "") for action in actions if "causes" in action),
+                        "",
+                    )
+                    if triggerUser and triggered_by != triggerUser:
+                        continue
+                    if build_info["result"] != "SUCCESS":
+                        continue
+
+                    build_time_local = time.strftime(
+                        "%Y-%m-%d %H:%M:%S", time.localtime(build_info["timestamp"] / 1000)
+                    )
+                    logi(f"目标构建号: {build_info['number']}, 状态: {build_info['result']}, 时间: {build_time_local}")
+                    buildTmp = build_info
+
+                    if build_info.get("artifacts"):
+                        zip_url = self.getZipArtifact(build_info, jobName, buildBoard)
+                    else:
+                        logw(f"build #{build_info['number']} artifact 已清理，回退文件服务器")
+                        zip_url = self._fallbackFileserver(jobName, build_info["number"], buildBoard)
+
+                    if zip_url:
+                        return str(build_info["number"]), zip_url
+
+                logw(f"find {triggerUser} {jobName} board[{buildBoard}] newest CI failed")
+                if buildTmp:
+                    if buildTmp.get("artifacts"):
+                        zip_url = self.pickBuildBoard(buildTmp, jobName)
+                    else:
+                        zip_url = self._fallbackFileserver(jobName, buildTmp["number"], buildBoard)
+                    return str(buildTmp["number"]), zip_url
+                else:
+                    eExit("no build found")
+
+    def _fallbackFileserver(self, jobName, buildNum, buildBoard):
+        """
+        artifact 为空时从文件服务器获取下载 URL
+        优先精确匹配 buildBoard,找不到时列出所有 board 让用户选择
+        """
+        url = self._getFileserverUrl(jobName, buildNum, buildBoard)
+        logd(f"尝试文件服务器: {url}")
+
+        if self._verifyFileserverUrl(url):
+            logi(f"文件服务器找到: {url}")
+            return url
+
+        # 精确匹配失败，列出可用 board 让用户选
+        logw(f"文件服务器未找到 {buildBoard}，列出可用 board:")
+        boards = self._listFileserverBoards(jobName, buildNum)
+
+        if not boards:
+            loge(f"文件服务器 {self.baseUrl}{jobName}/{buildNum}/ 下没有找到任何 board")
+            return ""
+
+        # 先尝试模糊匹配（board 名包含 buildBoard 关键词）
+        keyword = buildBoard.split("-")[0]  # 如 larkpro_phone
+        matched = [b for b in boards if keyword in b]
+
+        if len(matched) == 1:
+            logi(f"自动匹配到: {matched[0]}")
+            return self._getFileserverUrl(jobName, buildNum, matched[0])
+
+        # 需要用户手动选择
+        candidates = matched if matched else boards
+        if self.isUserDebug:
+            candidates = [b for b in candidates if "userdebug" in b] or candidates
+
+        print(f"\n在文件服务器找到如下 board，请选择:")
+        for i, b in enumerate(candidates):
+            print(f"  {i}: {b}")
+        chosen = candidates[inputSerial(0, len(candidates) - 1)]
+        return self._getFileserverUrl(jobName, buildNum, chosen)
+
+    def getHref(self, rooturl):
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+        }
+        sleep(1)
+        with requests.Session() as session:
+            response = requests.get(rooturl, headers=headers, auth=(self.jenkinsUser, self.jenkinsPassword))
+            soup = bs(response.text, features="html.parser")
+            result = []
+            for link in soup.find_all("a"):
+                result.append(link.get("href"))
+            return result
+
+    def getJenkinsBoard(self, rooturl):
+        # 默认解码方式utf-8
+        logd(rooturl)
+        result = self.getHref(rooturl)
+
+        filtered_list = [s for s in result if "-" in s and "/" in s]
+        dict_from_list = {key: index for key, index in enumerate(filtered_list)}
+        logd(dict_from_list)
+        if dict_from_list == {}:
+            eExit(f"No board found in {rooturl}")
+        return dict_from_list
+
+    def browserDownload(self, url, timeOut=600):
+        if sysVersion == "Linux":
+            browser = "wget"
+        else:
+            browser = "C:\\Program Files\\Mozilla Firefox\\firefox.exe -headless"
+            # browser = "C:\\Program Files\\Mozilla Firefox\\firefox.exe"
+        info, err = pCmd(f"{browser} {url}", showCmd=True, showRet=False, timeOut=timeOut, logLevel="info")
+        # logi(err)
+        if "ERROR 404: Not Found" in err:
+            eExit("ERROR 404: Not Found")
+
+    def downloadByRequest(self, url, save_path, useSession=False):
+        """下载需要认证的文件（支持断点续传）"""
+
+        total_size = 0
+        if os.path.exists(save_path):
+            downloaded = os.path.getsize(save_path)
+        else:
+            downloaded = 0
+            open(save_path, "wb").close()  # 创建空文件
+
+        # 设置断点续传头部
+        headers = {"Range": f"bytes={downloaded}-"} if downloaded else {}
+        CHUNK = 4 * 1024 * 1024  # 4MB per chunk
+        if useSession:
+            session = requests.Session()
+            session.auth = (self.jenkinsUser, self.jenkinsPassword)
+            session.headers.update(headers)
+            try:
+                with session.get(url, stream=True, timeout=30) as response:
+                    response.raise_for_status()  # 检查HTTP错误
+                    if response.status_code == 401:
+                        raise PermissionError("认证失败，请检查账户密码")
+
+                    # 获取文件总大小（考虑断点续传）
+                    total_size = int(response.headers.get("content-length", 0)) + downloaded
+                    with open(save_path, "ab") as f:
+                        for chunk in response.iter_content(chunk_size=CHUNK):
+                            if chunk:  # 过滤空块
+                                f.write(chunk)
+                                downloaded += len(chunk)
+                                progress = downloaded / total_size * 100 if total_size > 0 else 0
+                                sys.stdout.write(
+                                    f"\r下载进度: {progress:.1f}% ({downloaded/1024/1024:.1f}/{total_size/1024/1024:.1f} MB)"
+                                )
+                                sys.stdout.flush()
+                print("\r")
+                logd(f"\n文件已保存至: {os.path.abspath(save_path)}")
+
+            except requests.exceptions.RequestException as e:
+                loge(f"下载失败: {str(e)}")
+                if os.path.getsize(save_path) == 0:
+                    os.remove(save_path)  # 删除空文件
+                    exit()
+        else:
+            try:
+                with requests.get(
+                    url, headers=headers, stream=True, auth=(self.jenkinsUser, self.jenkinsPassword), timeout=30
+                ) as response:
+                    response.raise_for_status()  # 检查HTTP错误
+                    if response.status_code == 401:
+                        raise PermissionError("认证失败，请检查账户密码")
+
+                    # 获取文件总大小（考虑断点续传）
+                    total_size = int(response.headers.get("content-length", 0)) + downloaded
+                    with open(save_path, "ab") as f:
+                        for chunk in response.iter_content(chunk_size=CHUNK):
+                            if chunk:  # 过滤空块
+                                f.write(chunk)
+                                downloaded += len(chunk)
+                                progress = downloaded / total_size * 100 if total_size > 0 else 0
+                                sys.stdout.write(
+                                    f"\r下载进度: {progress:.1f}% ({downloaded/1024/1024:.1f}/{total_size/1024/1024:.1f} MB)"
+                                )
+                                sys.stdout.flush()
+                    print("\r")
+                    logd(f"\n文件已保存至: {os.path.abspath(save_path)}")
+
+            except requests.exceptions.RequestException as e:
+                loge(f"下载失败: {str(e)}")
+                if os.path.getsize(save_path) == 0:
+                    os.remove(save_path)  # 删除空文件
+                    exit()
+        return total_size
+
+    def downloadByRequestMutithread(self, url, save_path):
+        """下载需要认证的文件（支持断点续传 + 多线程分块）"""
+        auth = (self.jenkinsUser, self.jenkinsPassword)
+
+        # 先获取文件总大小，顺便验证认证
+        head = requests.head(url, auth=auth, timeout=10)
+        if head.status_code == 401:
+            raise PermissionError("认证失败，请检查账户密码")
+        head.raise_for_status()
+
+        total_size = int(head.headers.get("content-length", 0))
+        supports_range = head.headers.get("Accept-Ranges", "") == "bytes"
+
+        CHUNK = 4 * 1024 * 1024  # 4MB per chunk
+        if supports_range and total_size > 0:
+            self._download_multithread(url, save_path, total_size, auth, chunk_size=CHUNK)
+        else:
+            self._download_single(url, save_path, auth, chunk_size=CHUNK)
+
+        return total_size
+
+    def _download_multithread(self, url, save_path, total_size, auth, workers=8, chunk_size=1024 * 1024):
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+
+        """并发分块下载，最后按顺序写入"""
+        chunk_count = (total_size + chunk_size - 1) // chunk_size
+        ranges = [(i * chunk_size, min((i + 1) * chunk_size - 1, total_size - 1)) for i in range(chunk_count)]
+
+        # 预分配文件大小（避免碎片）
+        with open(save_path, "wb") as f:
+            f.seek(total_size - 1)
+            f.write(b"\0")
+
+        write_lock = threading.Lock()
+        downloaded_bytes = [0]
+
+        def fetch_and_write(idx, start, end):
+            headers = {"Range": f"bytes={start}-{end}"}
+            r = requests.get(url, headers=headers, auth=auth, timeout=60)
+            r.raise_for_status()
+            data = r.content
+
+            # 直接写到正确的文件偏移位置，无需排序等待
+            with write_lock:
+                with open(save_path, "r+b") as f:
+                    f.seek(start)
+                    f.write(data)
+                downloaded_bytes[0] += len(data)
+                pct = downloaded_bytes[0] / total_size * 100
+                print(
+                    f"\r进度: {pct:.1f}% ({downloaded_bytes[0]/1024/1024:.1f}/{total_size/1024/1024:.1f} MB)",
+                    end="",
+                    flush=True,
+                )
+
+        with ThreadPoolExecutor(max_workers=workers) as pool:
+            futures = [pool.submit(fetch_and_write, i, s, e) for i, (s, e) in enumerate(ranges)]
+            for f in as_completed(futures):
+                f.result()  # 抛出异常（如有）
+        print()
+
+    def _download_single(self, url, save_path, auth, chunk_size=1024 * 1024):
+        """单线程大 chunk 下载（服务端不支持 Range 时回退）"""
+        downloaded = os.path.getsize(save_path) if os.path.exists(save_path) else 0
+        headers = {"Range": f"bytes={downloaded}-"} if downloaded else {}
+
+        with requests.get(url, headers=headers, stream=True, auth=auth, timeout=30) as r:
+            if r.status_code == 401:
+                raise PermissionError("认证失败，请检查账户密码")
+            r.raise_for_status()
+            total = int(r.headers.get("content-length", 0)) + downloaded
+            with open(save_path, "ab") as f:
+                for chunk in r.iter_content(chunk_size=chunk_size):  # 4MB chunks
+                    if chunk:
+                        f.write(chunk)
+                        downloaded += len(chunk)
+                        pct = downloaded / total * 100 if total else 0
+                        print(f"\r下载进度: {pct:.1f}%", end="", flush=True)
+        print()
+
+    def getPackage(self, url, dest_path):
+        """从 Jenkins 下载文件"""
+
+        logd(f"{url} {dest_path}")
+        start = time.time()
+
+        windowsDownloadPath = r"D:\jenkin"
+        if sysVersion == "Linux":
+            targetZip = os.path.join(os.getcwd(), self.packageFile)
+        else:
+            targetZip = os.path.join(windowsDownloadPath, self.packageFile)
+            partFile = findFilesBySuffixKeyword(windowsDownloadPath, ".part", "release")
+            for i in partFile:
+                os.remove(targetZip)
+
+        if os.path.exists(targetZip):
+            os.remove(targetZip)
+
+        logi(f"download {url}")
+        totalSize = self.downloadByRequest(url, targetZip)
+        # totalSize = self.downloadByRequestMutithread(url, targetZip)
+        shutil.move(targetZip, dest_path)
+        end = time.time()
+        costTime = end - start
+        downloadSpeed = totalSize / 1024 / 1024 / costTime if costTime > 0 else 0
+        logi(f"Download cost: {costTime:.2f}秒, 平均速度: {downloadSpeed:.2f} MB/s")
+
+    def extractPackage(self, file_path, extract_to):
+        """解压下载的文件"""
+        fpath = os.path.join(extract_to, file_path[:-4])
+        logi(f"Extracting file {os.path.split(file_path)[1]} to {fpath}")
+
+        createFolder(extract_to)
+
+        if file_path.endswith(".zip"):
+            try:
+                with zipfile.ZipFile(file_path, "r") as zip_ref:
+                    zip_ref.extractall(extract_to)
+            except zipfile.BadZipfile:
+                eExit(f"{file_path} is a bad zip file")
+        else:
+            eExit(f"Unsupported file format: {file_path}")
+
+    def getCfg(self, boardTag, imgPath):
+        fileList = os.listdir(imgPath)
+        cfgFlag = boardTag.split("-")[0]
+        boardList = list()
+        for i in fileList:
+            if i.endswith(".cfg"):
+                if cfgFlag in i:
+                    boardList.append(i)
+        if len(boardList) == 1:
+            return boardList[0]
+        elif len(boardList) == 0:
+            logw(f"get {boardTag} table cfg failed")
+            return None
+        else:
+            print("请选择一个cfg用于烧录版本:")
+            for index, value in enumerate(boardList):
+                print(f"{index}: {value}")
+            return boardList[inputSerial(0, len(boardList) - 1)]
+
+    def getInfo(self, devSerial):
+        if devSerial != None:
+            cmd = f"adb -s {devSerial} reboot download"
+        else:
+            cmd = "adb reboot download"
+        rCmd(cmd, showCmd=True, logLevel="debug")
+        info = rCmd(f"./{self.aimgTool} portscan", timeOut=5)[0]
+        sleep(0.5)
+        if "usbdownload" in info:
+            return True
+
+        return False
+
+    def replace_last_Y_with_N(self, filename, search_string):
+        """
+        在文件中找到包含 search_string 的行，并将该行最后一个字符 Y 替换为 N。
+        （假设行末没有多余空格，且最后一个字符为 Y)
+        """
+        with open(filename, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+
+        with open(filename, "w", encoding="utf-8") as f:
+            for line in lines:
+                if search_string in line:
+                    # 去掉末尾换行符，便于操作
+                    stripped = line.rstrip("\n")
+                    # 如果最后一个字符是 Y，则替换
+                    if stripped and stripped[-1] == "Y":
+                        stripped = stripped[:-1] + "N"
+                        line = stripped + "\n"  # 恢复换行符
+                f.write(line)
+
+    def downloadToBoard(self, boardTag, imgPath, devSerial):
+        logd(f"{boardTag} {imgPath}")
+        os.chdir(imgPath)
+        os.chmod(self.aimgTool, 0o755)
+        cfgList = []
+        fileList = os.listdir(imgPath)
+        for i in fileList:
+            if i.endswith(".cfg"):
+                cfgList.append(i)
+        if boardTag == None:
+            if len(cfgList) == 1:
+                cfgFIle = cfgList[0]
+            else:
+                print("请选择一个cfg用于烧录版本:")
+                for index, value in enumerate(cfgList):
+                    print(f"{index}: {value}")
+
+                cfgFIle = cfgList[inputSerial(0, len(cfgList) - 1)]
+        else:
+            cfgFIle = self.getCfg(boardTag, imgPath)
+
+        finalCfg = cfgFIle
+        if self.retainUserData:
+            logw("retainUserData is True, will replace tzdata,metadata,userdata Y to N in cfg to retain user data")
+            if cfgFIle != None:
+                finalCfg = cfgFIle.split(".")[0] + "_retain_user_data.cfg"
+                shutil.copy2(cfgFIle, finalCfg)
+                self.replace_last_Y_with_N(finalCfg, "tzdata")
+                self.replace_last_Y_with_N(finalCfg, "metadata")
+                self.replace_last_Y_with_N(finalCfg, "userdata")
+            else:
+                eExit("cfg file not found")
+
+        logi(f"download {finalCfg}, wait for download port ready ... ")
+        refreshWait("usbdownload", 60, 0.3, self.getInfo, devSerial)
+        cmd = ""
+        if sysVersion == "Linux":
+            cmd = f"./{self.aimgTool} download -t {finalCfg}"
+        elif sysVersion == "Windows":
+            cmd = f"{self.aimgTool} download -t {finalCfg}"
+        logi(cmd)
+        oCmd(cmd)
+
+    def joinBackslash(self, *args):
+        # 将字符串用/拼接起来，最后一个不加
+        return "".join(f"{arg}/" if i < len(args) - 1 else f"{arg}" for i, arg in enumerate(args))
+
+    def downloadJenkins(self, buildNumber, buildBoard):
+        package = self.packageFile
+        branch = self.branch
+        buildTag = self.buildTag
+        pattern = re.compile("adroid" + r"(\d+)")
+        adVersion = pattern.findall(branch)[0]
+
+        ciTag = branch
+        if buildTag == "ci":
+            ciTag = branch + "_ci"
+        elif buildTag == "db":
+            ciTag = branch
+
+        logh(
+            f"num={buildNumber} Board={buildBoard} branch={branch} Tag={buildTag} ciOwner={self.ciOwner} adVersion={adVersion} isUserDebug={self.isUserDebug}"
+        )
+
+        buildNumber, targetUrl = self.findTargetBuild(buildNumber, self.ciOwner, ciTag, buildBoard)
+        buildBoard = targetUrl.split("/")[-2]
+
+        logi(f"download {buildNumber} {targetUrl}")
+        # exit()
+        packageName = buildTag + buildNumber + "android" + adVersion + "_" + buildBoard
+        imgName = os.path.join(self.downloadPath, packageName + ".zip")
+        createFolder(self.downloadPath)
+
+        if not os.path.exists(imgName):
+            if self.getPackage(targetUrl, imgName) == -1:
+                # 如果下载失败，列出所有board，用户选择一个board下载
+                boardUrl = f"http://10.1.24.40/{ciTag}/{buildNumber}"
+                boardDict = self.getJenkinsBoard(boardUrl)
+                logi(f"choose a board from {self.joinBackslash(self.baseUrl,self.branch,buildNumber)}")
+                for k, v in boardDict.items():
+                    print(k, v[:-1])
+                buildBoard = boardDict[inputSerial(0, len(boardDict) - 1)]
+                buildBoard = buildBoard[:-1]
+                logi(f"choose board {buildBoard} to download")
+                targetUrl = self.joinBackslash(boardUrl, buildBoard, package)
+                packageName = buildTag + buildNumber + "android" + adVersion + "_" + buildBoard
+                imgName = os.path.join(self.downloadPath, packageName + ".zip")
+                if not os.path.exists(imgName):
+                    if self.getPackage(targetUrl, imgName) == -1:
+                        exit()
+        else:
+            logi(f"{packageName}.zip already exist, skip download from jenkins")
+
+        imgPath = os.path.join(self.extractPath, packageName)
+        if not os.path.exists(imgPath):
+            self.extractPackage(imgName, self.extractPath)
+            os.rename(os.path.join(self.extractPath, "release"), imgPath)
+        else:
+            logi(f"{imgPath} already exist, skip extract")
+
+        out, error = rCmd("adb devices -l")
+        serial = None
+        if len(out.split("\n")) == 3:
+            boardTag = None
+        else:
+            dev = DevOp()
+            serial = dev.serial
+            soc = dev.getSoc()
+            if soc == "larkl":
+                boardTag = "larkl_"
+            elif soc == "lark":
+                boardTag = "lark_"
+            elif soc == "dove":
+                boardTag = "dove_"
+            elif soc == "larkpro":
+                boardTag = "larkpro_"
+            else:
+                boardTag = dev.slectBoard() + "_"
+
+            # pCmd("adb reboot download", showCmd=True, waitDone=False)
+
+        self.downloadToBoard(boardTag, imgPath, serial)
+
+
+def CLI_downJKS(argsList):
+    parser = argparse.ArgumentParser(prog="dj", description="自动下载并烧录版本")
+    parser.add_argument("-n", "--num", type=int, default=0, help="jenkins上的编译号,0表示最新编译结果")
+    parser.add_argument("-b", "--board", type=str, default="larkpro_phone-sp01-userdebug", help="烧录板卡")
+    parser.add_argument("-t", "--type", type=str, default="db", choices=["db", "ci"], help="编译类型 db/ci")
+    parser.add_argument(
+        "-a", "--android", type=str, default="16", choices=["16", "15", "16sdk", "15sdk"], help="安卓分支"
+    )
+    parser.add_argument("-u", "--user", type=str, default="taotaoli", help="触发用户")
+    parser.add_argument("-d", "--debug", type=str, default="1", choices=["0", "1"], help="是否烧录debug版本")
+    parser.add_argument("-r", "--ratain", type=str, default="0", choices=["0", "1"], help="烧录是否保留userdata")
+    parser.add_argument("--username", type=str, default=None, help="jenkins用户名")
+    parser.add_argument("--password", type=str, default=None, help="jenkins密码或API Token")
+    args = parser.parse_args(argsList)
+    buildBranch = ("16", "15", "16sdk", "15sdk")
+    ad = args.android
+    if ad not in buildBranch:
+        eExit(f"{ad} not in {buildBranch}")
+    branchDict = {
+        "15sdk": "adroid15_sdk_r1",
+        "15": "adroid15.0",
+        "16": "adroid16.0",
+        "16sdk": "adroid16_sdk_r1",
+    }
+    branch = branchDict.get(ad)
+    jenks = jenkinsTool(branch, args.type, args.user, args.debug, args.username, args.password)
+    jenks.retainUserData = True if args.ratain == "1" else False
+    jenks.downloadJenkins(args.num, args.board)
+
+
+def getInfo(acmd):
+    rCmd("adb reboot download", showCmd=True)
+    info = rCmd(f"{acmd} portscan", timeOut=5)[0]
+    sleep(0.5)
+    return "usbdownload" in info
+
+
+def CLI_aimgDownload(args):
+    if sysVersion == "Linux":
+        aimgTool = "aimgtool"
+        acmd = "./aimgtool"
+    else:
+        aimgTool = "aimgtool.exe"
+        acmd = "aimgtool.exe"
+    aimg = os.path.join(os.path.curdir, aimgTool)
+    if not os.path.exists(aimg):
+        eExit(f"get {aimg} failed")
+    os.chmod(aimgTool, 0o755)
+    rCmd("adb reboot download")
+    fileList = os.listdir(os.path.curdir)
+    cfgList = [i for i in fileList if i.endswith(".cfg")]
+    if not cfgList:
+        eExit("get table cfg failed")
+    if len(cfgList) == 1:
+        cfgFIle = cfgList[0]
+    else:
+        print("Please select the target cfg:")
+        for index, value in enumerate(cfgList):
+            print(f"{index}: {value}")
+        cfgFIle = cfgList[inputSerial(0, len(cfgList) - 1)]
+    refreshWait("usbdownload", 60, 0.3, getInfo, acmd)
+    cmd = f"{acmd} download -t {cfgFIle}"
+    logi(cmd)
+    oCmd(cmd)
+
+
+_COMMAND_REGISTRY = {}
+
+
+def printHelp():
+    print("[flash]")
+    print("adown                :download and flash aimg")
+    print("dj -h                :download and flash jenkins build")
+
+
+CLI_aimgDownload = register_command("adown", registry=_COMMAND_REGISTRY)(CLI_aimgDownload)
+CLI_downJKS = register_command("dj", registry=_COMMAND_REGISTRY)(CLI_downJKS)
+
+
+def flashMain(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
+    flashMain(sys.argv)