20250904-初步功能已完成

Module/DeviceInfo.py

@@ -30,12 +30,14 @@ class Deviceinfo(object):
 
         self._lock = threading.Lock()
         self._model_index: Dict[str, DeviceModel] = {}  # udid -> model
-        # ✅ 1. 失踪时间戳记录（替代原来的 miss_count）
-        self._last_seen: Dict[str, float] = {}
-        self._port_pool: List[int] = []
-        self._port_in_use: set[int] = set()
+        self._miss_count: Dict[str, int] = {}           # udid -> 连续未扫描到次数
+        self._port_pool: List[int] = []                 # 端口回收池
+        self._port_in_use: set[int] = set()             # 正在使用的端口
 
-        # region iproxy 初始化（原逻辑不变）
+        # 🔥1. 启动 WDA 健康检查线程
+        # threading.Thread(target=self._wda_health_checker, daemon=True).start()
+
+        # region iproxy 初始化
         try:
             self.iproxy_path = self._iproxy_path()
             self.iproxy_dir = self.iproxy_path.parent
@@ -83,11 +85,7 @@ class Deviceinfo(object):
             LogManager.error(f"初始化 iproxy 失败：{e}")
         # endregion
 
-    # ------------------------------------------------------------------
-    # ✅ 2. 主监听循环（已用“时间窗口+USB 层兜底”重写）
-    # ------------------------------------------------------------------
     def startDeviceListener(self):
-        MISS_WINDOW = 5.0          # 5 秒连续失踪才判死刑
         while True:
             try:
                 lists = Usbmux().device_list()
@@ -97,23 +95,24 @@ class Deviceinfo(object):
                 continue
 
             now_udids = {d.udid for d in lists if d.conn_type == ConnectionType.USB}
-            # ✅ USB 层真断兜底
-            usb_sn_set = self._usb_enumerate_sn()
 
-            need_remove = None
+            # 1. 失踪登记 & 累加
+            need_remove = None  # ← 新增：放锁外记录
             with self._lock:
                 for udid in list(self._model_index.keys()):
                     if udid not in now_udids:
-                        last = self._last_seen.get(udid, time.time())
-                        if time.time() - last > MISS_WINDOW and udid not in usb_sn_set:
-                            need_remove = udid
+                        self._miss_count[udid] = self._miss_count.get(udid, 0) + 1
+                        if self._miss_count[udid] >= 3:
+                            self._miss_count.pop(udid, None)
+                            need_remove = udid  # ← 只记录，不调用
                     else:
-                        self._last_seen[udid] = time.time()
+                        self._miss_count.pop(udid, None)
 
+            # 🔓 锁已释放，再删设备（不会重入）
             if need_remove:
                 self._remove_model(need_remove)
 
-            # 新增设备（原逻辑不变）
+            # 2. 全新插入（只处理未在线且信任且未满）
             for d in lists:
                 if d.conn_type != ConnectionType.USB:
                     continue
@@ -132,22 +131,14 @@ class Deviceinfo(object):
 
             time.sleep(1)
 
-    # ------------------------------------------------------------------
-    # ✅ 3. USB 层枚举 SN（跨平台）
-    # ------------------------------------------------------------------
-    def _usb_enumerate_sn(self) -> set[str]:
-        try:
-            out = subprocess.check_output(["idevice_id", "-l"], text=True, timeout=3)
-            return {line.strip() for line in out.splitlines() if line.strip()}
-        except Exception:
-            return set()
-
-    # ===================== 以下代码与原文件完全一致 =====================
+    # 🔥2. WDA 健康检查
     def _wda_health_checker(self):
         while True:
             time.sleep(1)
+            print(len(self.deviceModelList))
             with self._lock:
-                online = [m for m in self.deviceModelList if m.ready]
+                online = [m for m in self.deviceModelList if m.ready]  # ← 只检查就绪的
+                print(len(online))
             for model in online:
                 udid = model.deviceId
                 if not self._wda_ok(udid):
@@ -156,24 +147,32 @@ class Deviceinfo(object):
                         self._remove_model(udid)
                     self.connectDevice(udid)
 
+    # 🔥3. 真正做 health-check 的地方
     def _wda_ok(self, udid: str) -> bool:
+        """返回 True 表示 WDA 活着，False 表示已死"""
         try:
+            # 用 2 秒超时快速探测
             c = wda.USBClient(udid, 8100)
+            # 下面这句就是“xctest launched but check failed” 的触发点
+            # 如果 status 里返回了 WebDriverAgent 运行信息就认为 OK
             st = c.status()
             if st.get("state") != "success":
                 return False
+            # 你也可以再苛刻一点，多做一次 /wda/healthcheck
+            # c.http.get("/wda/healthcheck")
             return True
         except Exception as e:
+            # 任何异常（连接拒绝、超时、json 解析失败）都认为已死
             LogManager.error(f"WDA health-check 异常：{e}", udid)
             return False
 
-    # -------------------- 增删改查唯一入口（未改动） --------------------
+    # region ===================== 增删改查唯一入口（线程安全） =====================
     def _has_model(self, udid: str) -> bool:
         return udid in self._model_index
 
     def _add_model(self, model: DeviceModel):
         if model.deviceId in self._model_index:
-            return
+            return  # 防重复
         model.ready = True
         self.deviceModelList.append(model)
         self._model_index[model.deviceId] = model
@@ -181,48 +180,60 @@ class Deviceinfo(object):
             self.manager.send(model.toDict())
         except Exception as e:
             LogManager.warning(f"{model.deviceId} 发送上线事件失败：{e}")
-        LogManager.method_info(f"{model.deviceId} 加入设备成功，当前在线数：{len(self.deviceModelList)}", method="device_count")
+        LogManager.method_info(f"{model.deviceId} 加入设备成功，当前在线数：{len(self.deviceModelList)}",method="device_count")
 
+
+    # 删除设备
     def _remove_model(self, udid: str):
         print(f"【删】进入删除方法  udid={udid}")
         LogManager.method_info(f"【删】进入删除方法  udid={udid}", method="device_count")
+        # 1. 纯内存临界区——毫秒级
         with self._lock:
             print(f"【删】拿到锁  udid={udid}")
-            LogManager.method_info(f"【删】拿到锁  udid={udid}", method="device_count")
+            LogManager.method_info(f"【删】拿到锁  udid={udid}",
+                                   method="device_count")
             model = self._model_index.pop(udid, None)
             if not model:
                 print(f"【删】模型已空，直接返回  udid={udid}")
-                LogManager.method_info(f"【删】模型已空，直接返回  udid={udid}", method="device_count")
+                LogManager.method_info(f"【删】模型已空，直接返回  udid={udid}",method="device_count")
                 return
             if model.deleting:
                 print(f"【删】正在删除中，幂等返回  udid={udid}")
                 LogManager.method_info(method="device_count", text=f"【删】正在删除中，幂等返回  udid={udid}")
                 return
             model.deleting = True
+            # 标记维删除设备
             model.type = 2
             print(f"【删】标记 deleting=True  udid={udid}")
-            LogManager.method_info("【删】标记 deleting=True  udid={udid}", "device_count")
+            LogManager.method_info("【删】标记 deleting=True  udid={udid}","device_count")
+            # 过滤列表
             before = len(self.deviceModelList)
             self.deviceModelList = [m for m in self.deviceModelList if m.deviceId != udid]
             after = len(self.deviceModelList)
             print(f"【删】列表过滤  before={before} → after={after}  udid={udid}")
-            LogManager.method_info(f"【删】列表过滤  before={before} → after={after}  udid={udid}", "device_count")
+            LogManager.method_info(f"【删】列表过滤  before={before} → after={after}  udid={udid}","device_count")
+
+            # 端口
             self._port_in_use.discard(model.screenPort)
             self._port_pool.append(model.screenPort)
             print(f"【删】回收端口  port={model.screenPort}  udid={udid}")
             LogManager.method_info(f"【删】回收端口  port={model.screenPort}  udid={udid}", method="device_count")
+
+            # 进程
             to_kill = [item for item in self.pidList if item.get("id") == udid]
             self.pidList = [item for item in self.pidList if item.get("id") != udid]
             print(f"【删】待杀进程数  count={len(to_kill)}  udid={udid}")
             LogManager.method_info(f"【删】待杀进程数  count={len(to_kill)}  udid={udid}", method="device_count")
 
+        # 2. IO 区无锁
         for idx, item in enumerate(to_kill, 1):
             print(f"【删】杀进程  {idx}/{len(to_kill)}  pid={item.get('target').pid}  udid={udid}")
-            LogManager.method_info(f"【删】杀进程  {idx}/{len(to_kill)}  pid={item.get('target').pid}  udid={udid}", method="device_count")
+            LogManager.method_error(f"【删】杀进程  {idx}/{len(to_kill)}  pid={item.get('target').pid}  udid={udid}", method="device_count")
             self._terminate_proc(item.get("target"))
         print(f"【删】进程清理完成  udid={udid}")
         LogManager.method_info(f"【删】进程清理完成  udid={udid}", method="device_count")
 
+        # 3. 网络 IO
         retry = 3
         while retry:
             try:
@@ -244,7 +255,7 @@ class Deviceinfo(object):
         print(len(self.deviceModelList))
         LogManager.method_info(f"当前剩余设备数量：{len(self.deviceModelList)}", method="device_count")
 
-    # -------------------- 端口分配与回收（未改动） --------------------
+    # region ===================== 端口分配与回收 =====================
     def _alloc_port(self) -> int:
         if self._port_pool:
             port = self._port_pool.pop()
@@ -258,17 +269,20 @@ class Deviceinfo(object):
         if port in self._port_in_use:
             self._port_in_use.remove(port)
             self._port_pool.append(port)
+    # endregion
 
-    # -------------------- 单台设备连接（未改动） --------------------
+    # region ===================== 单台设备连接 =====================
     def connectDevice(self, udid: str):
         if not self.is_device_trusted(udid):
             LogManager.warning("设备未信任，跳过 WDA 启动", udid)
             return
+
         try:
             d = wda.USBClient(udid, 8100)
         except Exception as e:
             LogManager.error(f"启动 WDA 失败: {e}", udid)
             return
+
         width, height, scale = 0, 0, 1.0
         try:
             size = d.window_size()
@@ -276,21 +290,26 @@ class Deviceinfo(object):
             scale = d.scale
         except Exception as e:
             LogManager.warning(f"读取屏幕信息失败：{e}", udid)
+
         port = self._alloc_port()
         model = DeviceModel(udid, port, width, height, scale, type=1)
         self._add_model(model)
+
         try:
             d.app_start(WdaAppBundleId)
             d.home()
         except Exception as e:
             LogManager.warning(f"启动/切回桌面失败：{e}", udid)
+
         time.sleep(2)
+
+        # 先清旧进程再启动新进程
         self.pidList = [item for item in self.pidList if item.get("id") != udid]
         target = self.relayDeviceScreenPort(udid, port)
         if target:
             self.pidList.append({"target": target, "id": udid})
 
-    # -------------------- 工具方法（未改动） --------------------
+    # region ===================== 工具方法 =====================
     def is_device_trusted(self, udid: str) -> bool:
         try:
             d = BaseDevice(udid)
@@ -300,16 +319,22 @@ class Deviceinfo(object):
             return False
 
     def relayDeviceScreenPort(self, udid: str, port: int) -> Optional[subprocess.Popen]:
+        """启动 iproxy 前：端口若仍被占用则先杀掉占用者，再启动"""
         if not self._spawn_iproxy:
             LogManager.error("iproxy 启动器未就绪", udid)
             return None
+
+        # --- 新增：端口冲突检查 + 强制清理 ---
         while self._port_in_use and self._is_port_open(port):
+            # 先查是哪个进程占用
             pid = self._get_pid_by_port(port)
             if pid and pid != os.getpid():
                 LogManager.warning(f"端口 {port} 仍被 PID {pid} 占用，尝试释放", udid)
                 self._kill_pid_gracefully(pid)
             else:
                 break
+        # -------------------------------------
+
         try:
             p = self._spawn_iproxy(udid, port, 9100)
             self._port_in_use.add(port)
@@ -319,12 +344,14 @@ class Deviceinfo(object):
             LogManager.error(f"启动 iproxy 失败：{e}", udid)
             return None
 
+    # ------------------- 新增三个小工具 -------------------
     def _is_port_open(self, port: int) -> bool:
         import socket
         with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
             return s.connect_ex(("127.0.0.1", port)) == 0
 
     def _get_pid_by_port(self, port: int) -> Optional[int]:
+        """跨平台根据端口号查 PID，失败返回 None"""
         try:
             if os.name == "nt":
                 cmd = ["netstat", "-ano", "-p", "tcp"]
@@ -340,6 +367,7 @@ class Deviceinfo(object):
             return None
 
     def _kill_pid_gracefully(self, pid: int):
+        """先 terminate 再 kill -9"""
         try:
             os.kill(pid, signal.SIGTERM)
             time.sleep(1)
@@ -347,6 +375,7 @@ class Deviceinfo(object):
         except Exception:
             pass
 
+
     def _terminate_proc(self, p: Optional[subprocess.Popen]):
         if not p or p.poll() is not None:
             return

Module/FlaskService.py

@@ -274,6 +274,7 @@ def stopScript():
 @app.route('/passAnchorData', methods=['POST'])
 def passAnchorData():
     try:
+        LogManager.method_info("关注打招呼","关注打招呼")
         data: Dict[str, Any] = request.get_json()
         # 设备列表
         idList = data.get("deviceList", [])
@@ -431,7 +432,6 @@ def aiConfig():
 @app.route("/select_last_message", methods=['GET'])
 def select_last_message():
     data = JsonUtils.query_all_json_items()
-
     return ResultData(data=data).toJson()
 
 

Module/log/acList.json

@@ -0,0 +1,22 @@
+[
+  {
+    "anchorId": "giulia.roma",
+    "country": "意大利"
+  },
+  {
+    "anchorId": "marcelo_brasil",
+    "country": "巴西"
+  },
+  {
+    "anchorId": "anna_krasnova",
+    "country": "俄罗斯"
+  },
+  {
+    "anchorId": "lee_jiwoo",
+    "country": "韩国"
+  },
+  {
+    "anchorId": "fatima_dxb",
+    "country": "阿联酋"
+  }
+]