iOSAI/Module/DeviceInfo.py

import http.client
import json
import os
import socket
import subprocess
import sys
import threading
import time
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from typing import Dict, Optional
import psutil
import tidevice
import wda
from tidevice import Usbmux, ConnectionType
from tidevice._device import BaseDevice
from Entity.DeviceModel import DeviceModel
from Entity.Variables import WdaAppBundleId, wdaScreenPort, wdaFunctionPort
from Module.FlaskSubprocessManager import FlaskSubprocessManager
from Module.IOSActivator import IOSActivator
from Utils.LogManager import LogManager


def _monotonic() -> float:
    return time.monotonic()

def _is_port_free(port: int, host: str = "127.0.0.1") -> bool:
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        s.bind((host, port))
        return True
    except OSError:
        return False
    finally:
        s.close()

def _pick_free_port(low: int = 20000, high: int = 48000) -> int:
    """全局兜底的端口选择：先随机后顺扫，避免固定起点导致碰撞。支持通过环境变量覆盖范围：
    PORT_RANGE_LOW / PORT_RANGE_HIGH
    """
    try:
        low = int(os.getenv("PORT_RANGE_LOW", str(low)))
        high = int(os.getenv("PORT_RANGE_HIGH", str(high)))
    except Exception:
        pass
    if high - low < 100:
        high = low + 100
    import random
    # 随机尝试 64 次
    tried = set()
    for _ in range(64):
        p = random.randint(low, high)
        if p in tried:
            continue
        tried.add(p)
        if _is_port_free(p):
            return p
    # 顺序兜底
    for p in range(low, high):
        if p in tried:
            continue
        if _is_port_free(p):
            return p
    raise RuntimeError("未找到可用端口")


class DeviceInfo:
    _instance = None
    _instance_lock = threading.Lock()

    def __new__(cls, *args, **kwargs):
        # 双重检查锁，确保线程安全单例
        if not cls._instance:
            with cls._instance_lock:
                if not cls._instance:
                    cls._instance = super().__new__(cls)
        return cls._instance

    # ---- 端口分配：加一个最小的“保留池”，避免并发选到同一个端口 ----
    def _alloc_port(self) -> int:
        with self._lock:
            busy = set(self._port_by_udid.values()) | set(self._reserved_ports)
        # 优先随机尝试若干次，减少并发碰撞
        import random
        low = int(os.getenv("PORT_RANGE_LOW", "20000"))
        high = int(os.getenv("PORT_RANGE_HIGH", "48000"))
        for _ in range(128):
            p = random.randint(low, high)
            with self._lock:
                if p not in busy and p not in self._reserved_ports and _is_port_free(p):
                    self._reserved_ports.add(p)
                    return p
        # 兜底顺序扫描
        for p in range(low, high):
            with self._lock:
                if p in self._reserved_ports or p in busy:
                    continue
            if _is_port_free(p):
                with self._lock:
                    self._reserved_ports.add(p)
                return p
        raise RuntimeError("端口分配失败：没有可用端口")

    def _release_port(self, port: int):
        with self._lock:
            self._reserved_ports.discard(port)

    ADD_STABLE_SEC = float(os.getenv("ADD_STABLE_SEC", "2.0"))
    REMOVE_GRACE_SEC = float(os.getenv("REMOVE_GRACE_SEC", "6.0"))

    def __init__(self) -> None:
        # 防止多次初始化（因为 __init__ 每次调用 DeviceInfo() 都会执行）
        if getattr(self, "_initialized", False):
            return

        self._lock = threading.RLock()
        self._models: Dict[str, DeviceModel] = {}
        self._iproxy: Dict[str, subprocess.Popen] = {}
        self._port_by_udid: Dict[str, int] = {}
        self._reserved_ports: set[int] = set()
        self._first_seen: Dict[str, float] = {}
        self._last_seen: Dict[str, float] = {}
        self._manager = FlaskSubprocessManager.get_instance()
        self._iproxy_path = self._find_iproxy()

        # 懒加载线程池属性（供 _add_device 并发使用）
        self._add_lock: Optional[threading.RLock] = None
        self._adding_udids: Optional[set[str]] = None
        self._add_executor: Optional["ThreadPoolExecutor"] = None

        # iproxy 连续失败计数（守护用）
        self._iproxy_fail_count: Dict[str, int] = {}

        LogManager.info("DeviceInfo 初始化完成", udid="system")
        print("[Init] DeviceInfo 初始化完成")

        # iproxy 守护线程（端口+HTTP探活 → 自愈重启 → 达阈值才移除）
        threading.Thread(target=self.check_iproxy_ports, daemon=True).start()

        self._initialized = True  # 标记已初始化

    # =============== 并发添加设备：最小改动（包装 _add_device） ===============
    def _ensure_add_executor(self):
        """
        懒加载：首次调用 _add_device 时初始化线程池与去重集合。
        注意：不要只用 hasattr；属性可能已在 __init__ 里置为 None。
        """
        # 1) 锁
        if getattr(self, "_add_lock", None) is None:
            self._add_lock = threading.RLock()

        # 2) 去重集合
        if getattr(self, "_adding_udids", None) is None:
            self._adding_udids = set()

        # 3) 线程池
        if getattr(self, "_add_executor", None) is None:
            from concurrent.futures import ThreadPoolExecutor
            import os
            max_workers = 6
            self._add_executor = ThreadPoolExecutor(
                max_workers=max_workers,
                thread_name_prefix="dev-add"
            )
            try:
                LogManager.info(f"[Init] Device add executor started, max_workers={max_workers}", udid="system")
            except Exception:
                pass

    def _safe_add_device(self, udid: str):
        """
        后台执行真正的新增实现（_add_device_impl）：
        - 任何异常只记日志，不抛出
        - 无论成功与否，都在 finally 里清理“正在添加”标记
        """
        try:
            self._add_device_impl(udid)  # ← 这是你原来的重逻辑（见下方）
        except Exception as e:
            try:
                LogManager.method_error(f"_add_device_impl 异常：{e}", "_safe_add_device", udid=udid)
            except Exception:
                pass
        finally:
            lock = getattr(self, "_add_lock", None)
            if lock is None:
                # 极端容错，避免再次抛异常
                self._add_lock = lock = threading.RLock()
            with lock:
                self._adding_udids.discard(udid)

    def _add_device(self, udid: str):
        """并发包装器：保持所有调用点不变。"""
        self._ensure_add_executor()

        # 保险：即使极端情况下属性仍是 None，也就地补齐一次
        lock = getattr(self, "_add_lock", None)
        if lock is None:
            self._add_lock = lock = threading.RLock()
        adding = getattr(self, "_adding_udids", None)
        if adding is None:
            self._adding_udids = adding = set()

        # 去重：同一 udid 只提交一次
        with lock:
            if udid in adding:
                return
            adding.add(udid)

        try:
            # 注意：submit(fn, udid) —— 这里不是 *args=udid，直接传第二个位置参数即可
            self._add_executor.submit(self._safe_add_device, udid)
        except Exception as e:
            # 提交失败要把去重标记清掉
            with lock:
                adding.discard(udid)
            try:
                LogManager.method_error(text=f"提交新增任务失败：{e}", method="_add_device", udid=udid)
            except Exception:
                pass

    def _iproxy_health_ok(self, port: int) -> bool:
        try:
            conn = http.client.HTTPConnection("127.0.0.1", int(port), timeout=1.5)
            conn.request("GET", "/")
            resp = conn.getresponse()

            status = getattr(resp, "status", 0)
            ctype = resp.getheader("Content-Type", "") or ""

            conn.close()

            ok = (200 <= status < 400) and ("multipart" in ctype.lower())

            if not ok:
                LogManager.error(
                    f"[iproxy] 健康检查失败: status={status}, ctype={ctype!r}, port={port}"
                )
            return ok

        except Exception as e:
            LogManager.error(f"[iproxy] 健康检查异常 port={port}: {e}")
            return False


    def _restart_iproxy(self, udid: str, port: int) -> bool:
        """干净重启 iproxy：先杀旧的，再启动新的，并等待监听。"""
        print(f"[iproxy-guard] 准备重启 iproxy {udid} on {port}")
        proc = None
        with self._lock:
            old = self._iproxy.get(udid)
        try:
            if old:
                self._kill(old)
        except Exception as e:
            print(f"[iproxy-guard] 杀旧进程异常 {udid}: {e}")

        # 重新拉起
        try:
            proc = self._start_iproxy(udid, local_port=port)
        except Exception as e:
            print(f"[iproxy-guard] 重启失败 {udid}: {e}")
            proc = None

        if not proc:
            return False

        # 写回进程表
        with self._lock:
            self._iproxy[udid] = proc

        print(f"[iproxy-guard] 重启成功 {udid} port={port}")
        return True

    def _restart_wda(self, udid: str) -> bool:
        """
        重启指定设备上的 WDA（用于已在系统中“在线”的设备）：
          - 假定该设备已经完成过信任/配对，不再重复配对
          - iOS 17+：直接调用 IOSActivator().activate(udid)
          - iOS <=16：走 tidevice.app_start(WdaAppBundleId)
        如果当前已存在映射端口，则在该端口上等待 WDA /status 就绪。
        """
        print(f"[WDA-guard] 尝试重启 WDA: {udid}")

        try:
            dev = tidevice.Device(udid)
            try:
                major = int(dev.product_version.split(".")[0])
            except Exception:
                major = 0
            print(f"[WDA-guard] 设备 {udid} iOS 主版本号 = {major}")

            if major >= 17:
                # -------- iOS 17+：不再重复配对，直接激活 --------
                print(f"[WDA-guard] iOS17+ 设备，直接通过 IOSActivator 激活 {udid}")
                try:
                    IOSActivator().activate(udid)
                    print(f"[WDA-guard] iOS17+ 通过 IOSActivator 激活完成 {udid}")
                except Exception as e:
                    print(f"[WDA-guard] iOS17+ 激活 WDA 异常: {e}")
                    return False

            else:
                # -------- iOS 16 及以下：直接 app_start WDA --------
                print(f"[WDA-guard] iOS<=16 设备，准备通过 tidevice.app_start 启动 WDA {udid}")
                # app_stop 失败不致命，做一下容错
                try:
                    dev.app_stop(WdaAppBundleId)
                except Exception as e:
                    print(f"[WDA-guard] app_stop 异常（忽略）：{e}")
                try:
                    dev.app_start(WdaAppBundleId)
                    print(f"[WDA-guard] app_start 已调用 {udid}")
                except Exception as e:
                    print(f"[WDA-guard] app_start 异常: {e}")
                    return False

            # -------- 如果这台设备已经有固定的 screenPort，就在该端口上等 WDA Ready --------
            port = None
            with self._lock:
                port = self._port_by_udid.get(udid)

            if port:
                print(f"[WDA-guard] 已有现成端口 {port}，等待 WDA 在该端口就绪 {udid}")
                ok = self._wait_wda_ready_on_port(
                    udid,
                    local_port=wdaFunctionPort,
                )
                if not ok:
                    print(f"[WDA-guard] WDA 在端口 {port} 未在超时内就绪 {udid}")
                    return False
            else:
                print(f"[WDA-guard] 当前无已记录端口（_port_by_udid 无 {udid}），仅完成 WDA 启动，不做就绪检测")

            print(f"[WDA-guard] WDA 重启完成 {udid}")
            return True

        except Exception as e:
            print(f"[WDA-guard] 重启 WDA 总体异常: {e}")
            return False

    # =============== 一轮检查：先自愈，仍失败才考虑移除 =================
    def check_iproxy_ports(self):

        print("[Guard] iproxy+WDA 守护线程启动")

        while True:
            try:
                with self._lock:
                    udids = list(self._models.keys())

                for udid in udids:
                    with self._lock:
                        port = self._port_by_udid.get(udid)
                        fail = self._iproxy_fail_count.get(udid, 0)

                    if not port:
                        continue

                    # ==== 第一层：视频流健康检查 ====
                    ok_stream = self._iproxy_health_ok(port)

                    if ok_stream:
                        # 成功 → 清零失败计数
                        with self._lock:
                            self._iproxy_fail_count[udid] = 0
                        continue

                    # ------ 以下为失败处理 ------
                    fail += 1
                    with self._lock:
                        self._iproxy_fail_count[udid] = fail

                    print(f"[Guard] 第 {fail} 次失败 udid={udid}, port={port}")

                    # ==== 第 1～2 次失败 → 优先重启 iproxy ====
                    if fail in (1, 2):
                        print(f"[Guard] 尝试重启 iproxy（第 {fail} 次）{udid}")
                        if self._restart_iproxy(udid, port):
                            time.sleep(1.5)
                            continue

                    # ==== 第 3～4 次失败 → 检查 WDA 状态 ====
                    if fail in (3, 4):
                        print(f"[Guard] 检查 WDA 状态 {udid}")
                        wda_ok = self._wait_wda_ready_on_port(udid, wdaFunctionPort)

                        if not wda_ok:
                            print(f"[Guard] WDA 异常 → 尝试重启 WDA（第 {fail} 次）{udid}")
                            if self._restart_wda(udid):
                                time.sleep(1.2)
                                continue
                        else:
                            print(f"[Guard] WDA 正常，但视频流挂了 → 再重启 iproxy")
                            if self._restart_iproxy(udid, port):
                                time.sleep(1.5)
                                continue

                    # ==== 第 5 次失败 → 移除设备 ====
                    if fail >= 5:
                        print(f"[Guard] 连续 5 次失败，移除设备 {udid}")
                        try:
                            self._remove_device(udid)
                        except Exception as e:
                            print(f"[Guard] 移除异常: {e}")
                        continue

            except Exception as e:
                print(f"[Guard] 守护线程异常: {e}")

            time.sleep(2.0)


    def listen(self):
        LogManager.method_info("进入主循环", "listen", udid="system")
        print("[Listen] 开始监听设备上下线...")
        while True:
            try:
                usb = Usbmux().device_list()
                online = {d.udid for d in usb if d.conn_type == ConnectionType.USB}
            except Exception as e:
                LogManager.warning(f"[device_list] 异常：{e}", udid="system")
                print(f"[Listen] 获取设备列表异常: {e}")
                time.sleep(1)
                continue

            now = _monotonic()
            for u in online:
                self._first_seen.setdefault(u, now)
                self._last_seen[u] = now

            with self._lock:
                known = set(self._models.keys())

            for udid in online - known:
                if (now - self._first_seen.get(udid, now)) >= self.ADD_STABLE_SEC:
                    try:
                        self._add_device(udid)  # ← 并发包装器
                    except Exception as e:
                        LogManager.method_error(f"新增失败：{e}", "listen", udid=udid)
                        print(f"[Add] 新增失败 {udid}: {e}")

            for udid in list(known):
                if udid in online:
                    continue
                last = self._last_seen.get(udid, 0.0)
                if (now - last) >= self.REMOVE_GRACE_SEC:
                    print(f"[Remove] 检测到设备离线: {udid}")
                    try:
                        self._remove_device(udid)
                    except Exception as e:
                        LogManager.method_error(f"移除失败：{e}", "listen", udid=udid)
                        print(f"[Remove] 移除失败 {udid}: {e}")

            time.sleep(1)

    # 检测设备wda状态
    def _wait_wda_ready_on_port(self, udid: str, local_port: int) -> bool:
        try:
            dev = wda.USBClient(udid, local_port)
            info = dev.status()  # 调用成功即可说明 WDA 正常
            return info["ready"]
        except Exception as e:
            print(f"[WDA] status 异常({udid}): {e}")
            return False


    def _send_snapshot_to_flask(self):
        """把当前 _models 的全量快照发送给 Flask 进程"""
        try:
            # 1. 把 _models 里的设备转成可 JSON 的 dict 列表
            with self._lock:
                devices = [m.toDict() for m in self._models.values()]

            payload = json.dumps({"devices": devices}, ensure_ascii=False)

            # 2. 建立到 Flask 的本地 socket 连接并发送
            port = int(os.getenv("FLASK_COMM_PORT", "34566"))
            if port <= 0:
                LogManager.warning("[SNAPSHOT] 无有效端口，跳过发送")
                return

            with socket.create_connection(("127.0.0.1", port), timeout=1.5) as s:
                s.sendall(payload.encode("utf-8") + b"\n")
            print(f"[SNAPSHOT] 已发送 {len(devices)} 台设备快照到 Flask")
            LogManager.info(f"[SNAPSHOT] 已发送 {len(devices)} 台设备快照到 Flask")
        except Exception as e:
            # 不要让异常影响主循环，只打个日志
            LogManager.warning(f"[SNAPSHOT] 发送快照失败: {e}")

    def _device_online_via_tidevice(self, udid: str) -> bool:
        try:
            from tidevice import Usbmux, ConnectionType
            devs = Usbmux().device_list()
            return any(d.udid == udid and d.conn_type == ConnectionType.USB for d in devs)
        except Exception:
            # 容错：tidevice 异常时，假定在线，避免误判；后续命令会再校验
            return True

    def _pair_if_needed_for_ios17(self, udid: str, timeout_sec: float | None = None) -> bool:
        """
        iOS 17+ 配对：已信任直接 True；否则触发配对并无限等待（设备离线则 False）
        使用 “python -m pymobiledevice3 lockdown pair -u <udid>” 做配对，规避 API 版本差异。
        timeout_sec=None 表示无限等待；若传入数字则为最多等待秒数。
        """
        # 已信任直接过
        if self._trusted(udid):
            return True

        print(f"[Pair][CLI] iOS17+ 需要配对，等待手机上点击“信任”… {udid}")
        last_log = 0.0

        # 轮询直到配对成功/超时/设备离线
        while True:
            # 1) 设备在线性检查（防止卡等已拔掉的设备）
            if not self._device_online_via_tidevice(udid):
                print(f"[Pair][CLI] 设备已离线，停止等待 {udid}")
                return False

            # 2) 触发一次配对尝试
            cmd = [sys.executable, "-m", "pymobiledevice3", "lockdown", "pair", "-u", udid]
            try:
                # 不打印子进程输出，保持你现有日志风格；需要可改为 PIPE 查看
                res = subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                if res.returncode == 0:
                    print(f"[Pair][CLI] 配对成功 {udid}")
                    return True
            except Exception as e:
                print(f"[Pair][CLI] 调用失败：{e}")

            # 3) 日志节流 + 可选超时
            now = time.monotonic()
            if now - last_log >= 10.0:
                print(f"[Pair][CLI] 仍在等待用户在手机上点“信任”… {udid}")
                last_log = now

            if timeout_sec is not None:
                timeout_sec -= 2.0
                if timeout_sec <= 0:
                    print(f"[Pair][CLI] 等待配对超时（达到设定时长）{udid}")
                    return False

            time.sleep(2.0)

    # ---------------- 原 _add_device 实现：整体改名为 _add_device_impl ----------------
    def _add_device_impl(self, udid: str):
        print(f"[Add] 开始新增设备 {udid}")

        if not self._trusted(udid):
            print(f"[Add] 未信任设备 {udid}, 跳过")
            return

        # 先分配一个“正式使用”的本地端口，并立即起 iproxy（只起这一回）
        port = self._alloc_port()
        print(f"[iproxy] 准备启动 iproxy 映射 {port}->{wdaScreenPort} (正式)")
        proc = self._start_iproxy(udid, local_port=port)
        if not proc:
            self._release_port(port)
            print(f"[iproxy] 启动失败，放弃新增 {udid}")
            return

        # 判断 WDA 是否已就绪；如果未就绪，按原逻辑拉起 WDA 并等到就绪
        try:
            dev = tidevice.Device(udid)
            major = int(dev.product_version.split(".")[0])
        except Exception:
            major = 0

        # 直接用“正式端口”探测 /status，避免再启一次临时 iproxy
        if not self._wait_wda_ready_on_port(udid, local_port=wdaFunctionPort):
            # 如果还没起来，按你原逻辑拉起 WDA 再等
            if major >= 17:
                print("进入 iOS17+ 设备的分支")
                if not self._pair_if_needed_for_ios17(udid, timeout_sec=None):  # 无限等；传秒数则有限时
                    print(f"[WDA] iOS17+ 配对失败或设备离线，放弃新增 {udid}")
                    try:
                        self._kill(proc)
                    except Exception:
                        pass
                    self._release_port(port)
                    return

                try:
                    IOSActivator().activate(udid)
                    print("wda启动完成")
                except Exception as e:
                    print(f"[WDA] iOS17 激活异常: {e}")
            else:
                print(f"[WDA] iOS<=17 启动 WDA app_start (port={wdaScreenPort})")
                try:
                    dev = tidevice.Device(udid)
                    dev.app_start(WdaAppBundleId)
                    time.sleep(2)
                except Exception as e:
                    print(f"[WDA] app_start 异常: {e}")

            if not self._wait_wda_ready_on_port(udid, local_port=wdaFunctionPort):
                print(f"[WDA] WDA 未在超时内就绪, 放弃新增 {udid}")
                # 清理已起的正式 iproxy
                try:
                    self._kill(proc)
                except Exception:
                    pass
                self._release_port(port)
                return

        print(f"[WDA] WDA 就绪，准备获取屏幕信息 {udid}")
        time.sleep(0.5)

        # 带超时的屏幕信息获取（保留你原有容错/重试）
        w, h, s = self._screen_info_with_timeout(udid, timeout=3.5)
        if not (w and h and s):
            for i in range(4):
                print(f"[Screen] 第{i + 1}次获取失败, 重试中... {udid}")
                time.sleep(0.6)
                w, h, s = self._screen_info_with_timeout(udid, timeout=3.5)
                if w and h and s:
                    break
        if not (w and h and s):
            print(f"[Screen] 屏幕信息仍为空，继续添加 {udid}")

        # 写入模型 & 发送前端
        with self._lock:
            model = DeviceModel(deviceId=udid, screenPort=port, width=w, height=h, scale=s, type=1)
            model.ready = True
            self._models[udid] = model
            self._iproxy[udid] = proc
            self._port_by_udid[udid] = port
            if hasattr(self, "_iproxy_fail_count"):
                self._iproxy_fail_count[udid] = 0

        print(f"[Manager] 准备发送设备数据到前端 {udid}")
        self._manager_send()
        print(f"[Add] 设备添加成功 {udid}, port={port}, {w}x{h}@{s}")

    def _remove_device(self, udid: str):
        """
        移除设备及其转发，通知上层。
        幂等：重复调用不会出错。
        """
        print(f"[Remove] 正在移除设备 {udid}")

        # --- 1. 锁内执行所有轻量字典操作 ---
        with self._lock:
            model = self._models.pop(udid, None)
            proc = self._iproxy.pop(udid, None)
            self._port_by_udid.pop(udid, None)
            self._first_seen.pop(udid, None)
            self._last_seen.pop(udid, None)
            self._iproxy_fail_count.pop(udid, None)

        # --- 2. 锁外执行重操作 ---
        # 杀进程
        try:
            self._kill(proc)
        except Exception as e:
            print(f"[Remove] 杀进程异常 {udid}: {e}")

        # 准备下线模型（model 可能为 None）
        if model is None:
            model = DeviceModel(
                deviceId=udid, screenPort=-1, width=0, height=0, scale=0.0, type=2
            )

        # 标记状态为离线
        model.type = 2
        model.ready = False
        model.screenPort = -1

        # 通知上层
        try:
            self._manager_send()
        except Exception as e:
            print(f"[Remove] 通知上层异常 {udid}: {e}")

        print(f"[Remove] 设备移除完成 {udid}")

    def _trusted(self, udid: str) -> bool:
        try:
            BaseDevice(udid).get_value("DeviceName")
            print(f"[Trust] 设备 {udid} 已信任")
            return True
        except Exception:
            print(f"[Trust] 设备 {udid} 未信任")
            return False

    def _screen_info(self, udid: str):
        try:
            # 避免 c.home() 可能触发的阻塞，直接取 window_size
            c = wda.USBClient(udid, wdaFunctionPort)
            size = c.window_size()
            print(f"[Screen] 成功获取屏幕 {int(size.width)}x{int(size.height)} {udid}")
            return int(size.width), int(size.height), float(c.scale)
        except Exception as e:
            print(f"[Screen] 获取屏幕信息异常: {e} {udid}")
            return 0, 0, 0.0

    def _screen_info_with_timeout(self, udid: str, timeout: float = 3.5):
        """在线程里调用 _screen_info，超时返回 0 值，防止卡死。"""
        import threading
        result = {"val": (0, 0, 0.0)}
        done = threading.Event()

        def _target():
            try:
                result["val"] = self._screen_info(udid)
            finally:
                done.set()

        t = threading.Thread(target=_target, daemon=True)
        t.start()
        if not done.wait(timeout):
            print(f"[Screen] 获取屏幕信息超时({timeout}s) {udid}")
            return 0, 0, 0.0
        return result["val"]

    def _wait_until_listening(self, port: int, timeout: float) -> bool:
        for to in (1.5, 2.5, 3.5):
            deadline = _monotonic() + to
            while _monotonic() < deadline:
                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                    s.settimeout(0.25)
                    if s.connect_ex(("127.0.0.1", port)) == 0:
                        print(f"[Port] 端口 {port} 已监听")
                        return True
                time.sleep(0.05)
        print(f"[Port] 端口 {port} 未监听")
        return False

    def _spawn_iproxy(self, udid: str, local_port: int, remote_port: int) -> Optional[subprocess.Popen]:
        creationflags = 0
        startupinfo = None
        if os.name == "nt":
            creationflags = getattr(subprocess, "CREATE_NO_WINDOW", 0x08000000) | \
                            getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0x00000200)
            si = subprocess.STARTUPINFO()
            si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
            si.wShowWindow = 0
            startupinfo = si
        cmd = [self._iproxy_path, "-u", udid, str(local_port), str(remote_port)]
        try:
            print(f"[iproxy] 启动进程 {cmd}")
            return subprocess.Popen(
                cmd,
                stdout=subprocess.DEVNULL,
                stderr=subprocess.DEVNULL,
                creationflags=creationflags,
                startupinfo=startupinfo,
            )
        except Exception as e:
            print(f"[iproxy] 创建进程失败: {e}")
            return None

    def _start_iproxy(self, udid: str, local_port: int) -> Optional[subprocess.Popen]:
        proc = self._spawn_iproxy(udid, local_port=local_port, remote_port=wdaScreenPort)
        if not proc:
            print(f"[iproxy] 启动失败 {udid}")
            return None
        if not self._wait_until_listening(local_port, 3.0):
            self._kill(proc)
            print(f"[iproxy] 未监听, 已杀死 {udid}")
            return None
        print(f"[iproxy] 启动成功 port={local_port} {udid}")
        return proc

    def _kill(self, proc: Optional[subprocess.Popen]):
        if not proc:
            return
        try:
            p = psutil.Process(proc.pid)
            p.terminate()
            try:
                p.wait(timeout=1.5)
            except psutil.TimeoutExpired:
                p.kill(); p.wait(timeout=1.5)
            print(f"[Proc] 已结束进程 PID={proc.pid}")
        except Exception as e:
            print(f"[Proc] 结束进程异常: {e}")

    def _manager_send(self):
        """对外统一的“通知 Flask 有设备变动”的入口（无参数）。
           作用：把当前所有设备的全量快照发给 Flask。
        """
        # 第 1 次：直接发快照
        try:
            self._send_snapshot_to_flask()
            return
        except Exception as e:
            print(f"[Manager] 首次发送快照异常: {e}")

        # 自愈：尝试拉起 Flask 子进程
        try:
            self._manager.start()
        except Exception as e:
            print(f"[Manager] 拉起 Flask 子进程异常: {e}")

        # 第 2 次：再发快照
        try:
            self._send_snapshot_to_flask()
            print(f"[Manager] 重试发送快照成功")
        except Exception as e:
            print(f"[Manager] 重试发送快照仍失败: {e}")

    def _find_iproxy(self) -> str:
        env_path = os.getenv("IPROXY_PATH")
        if env_path and Path(env_path).is_file():
            print(f"[iproxy] 使用环境变量路径 {env_path}")
            return env_path
        base = Path(__file__).resolve().parent.parent
        name = "iproxy.exe" if os.name == "nt" else "iproxy"
        path = base / "resources" / "iproxy" / name
        if path.is_file():
            print(f"[iproxy] 使用默认路径 {path}")
            return str(path)
        raise FileNotFoundError(f"iproxy 不存在: {path}")