feat(heart_rate_display_ui): 新增 WebSocket 服务器功能

- 添加 WebSocket 服务器相关 UI 和配置
- 实现 WebSocket 服务器的启动、停止和状态显示
- 在心率更新时通过 WebSocket 广播数据
- 加载和保存 WebSocket 服务器的配置

Author: ccc007ccc

config_webhook.json

@@ -19,4 +19,4 @@
         "body": "{\n    \"id\": \"heart-rate-widget\",\n    \"show_name\": \"❤\",\n    \"using\": false,\n    \"app_name\": \"未在使用\"\n}",
         "headers": "{\n    \"Content-Type\": \"application/json\",\n    \"Sleepy-Secret\": \"改成你的秘钥\"\n}"
     }
-]
+]

heart_rate_display_ui.py

@@ -15,6 +15,7 @@
 from floating_window import FloatingWindow
 from vrc_osc import VrcOscClient
 from api_server import ApiServer
+from websocket_server import WebSocketServer # [新增] 导入WebSocket服务器
 from webhook_manager import WebhookManager
 from webhook_ui import WebhookWindow
 
@@ -30,6 +31,7 @@ def __init__(self):
         self.should_stop = False
 
         self.api_server = None
+        self.websocket_server = None # [新增] WebSocket服务器实例
 
         self.floating_window = FloatingWindow(self)
 
@@ -56,6 +58,10 @@ def setup_ui(self):
         self.root.minsize(800, 500)
         self.root.resizable(True, True)
 
+        # [新增] WebSocket UI变量
+        self.websocket_server_enabled = tk.BooleanVar(value=False)
+        self.websocket_port_var = tk.StringVar(value="8001")
+        
         self.api_server_enabled = tk.BooleanVar(value=False)
         self.api_port_var = tk.StringVar(value="8000")
         self.vrc_ip_var = tk.StringVar(value="127.0.0.1")
@@ -120,6 +126,17 @@ def setup_ui(self):
         self.vrc_status_label = ttk.Label(vrc_frame, text="状态: 未连接", font=("Arial", 10), foreground="gray")
         self.vrc_status_label.grid(row=3, column=0, columnspan=2, sticky="w", pady=(5,0))
 
+        # [新增] WebSocket 服务器 UI
+        websocket_frame = ttk.LabelFrame(middle_column_frame, text="WebSocket服务器 (实时推送)", padding="10")
+        websocket_frame.pack(fill="x", pady=PAD_Y)
+        websocket_frame.columnconfigure(1, weight=1)
+        self.websocket_server_enabled.trace_add("write", self.toggle_websocket_server)
+        ttk.Checkbutton(websocket_frame, text="启用WebSocket服务器", variable=self.websocket_server_enabled).grid(row=0, column=0, sticky=tk.W, columnspan=2)
+        ttk.Label(websocket_frame, text="端口:").grid(row=1, column=0, sticky=tk.W, pady=(5,0))
+        ttk.Entry(websocket_frame, textvariable=self.websocket_port_var, width=10).grid(row=1, column=1, sticky="ew", padx=5, pady=(5,0))
+        self.websocket_status_label = ttk.Label(websocket_frame, text="状态: 已禁用", font=("Arial", 10), foreground="gray")
+        self.websocket_status_label.grid(row=2, column=0, columnspan=2, sticky="w", pady=(5,0))
+
         api_frame = ttk.LabelFrame(middle_column_frame, text="心率API服务器 (被动获取)", padding="10")
         api_frame.pack(fill="x", pady=PAD_Y)
         api_frame.columnconfigure(1, weight=1)
@@ -249,9 +266,12 @@ def update_heart_rate_display(self):
                 self.heart_rate_label.config(text=f"心率: {heart_rate}")
 
                 if heart_rate > 0:
-                    # [修改] 使用新的事件触发方法
                     self.webhook_manager.trigger_event("heart_rate_updated", heart_rate)
 
+                # [修改] 增加WebSocket广播
+                if self.websocket_server:
+                    self.websocket_server.broadcast()
+
                 if heart_rate > 0:
                     self.heart_rate_label.config(fg="green")
                     if self.vrc_connected:
@@ -267,6 +287,29 @@ def update_heart_rate_display(self):
     def clear_logs(self):
         self.log_text.delete(1.0, tk.END)
 
+    # [新增] 启动/停止 WebSocket 服务器
+    def toggle_websocket_server(self, *args):
+        if self.websocket_server_enabled.get():
+            try:
+                port = int(self.websocket_port_var.get())
+                self.websocket_server = WebSocketServer(self, port, self.log_message)
+                self.websocket_server.start()
+                self.websocket_status_label.config(text=f"状态: 运行于 ws://127.0.0.1:{port}", foreground="green")
+            except ValueError:
+                self.log_message("WebSocket服务器启动失败：端口号必须是有效的数字。")
+                self.websocket_status_label.config(text="状态: 端口号无效", foreground="red")
+                self.websocket_server_enabled.set(False)
+            except Exception as e:
+                self.log_message(f"WebSocket服务器启动失败: {e}")
+                self.websocket_status_label.config(text=f"状态: 启动失败", foreground="red")
+                self.websocket_server_enabled.set(False)
+
+        else:
+            if self.websocket_server:
+                self.websocket_server.stop()
+                self.websocket_server = None
+            self.websocket_status_label.config(text="状态: 已禁用", foreground="gray")
+            
     def toggle_api_server(self, *args):
         if self.api_server_enabled.get():
             try:
@@ -313,6 +356,11 @@ def save_settings(self):
             "api_server": {
                 "enabled": self.api_server_enabled.get(),
                 "port": self.api_port_var.get()
+            },
+            # [新增] 保存 WebSocket 设置
+            "websocket_server": {
+                "enabled": self.websocket_server_enabled.get(),
+                "port": self.websocket_port_var.get()
             }
         }
         save_config(config)
@@ -367,10 +415,19 @@ def load_settings(self):
 
         api_settings = config.get("api_server")
         if api_settings:
-            self.api_port_var.set(api_settings.get("port", "8080"))
+            self.api_port_var.set(api_settings.get("port", "8000"))
             if api_settings.get("enabled", False):
                 self.root.after(100, lambda: self.api_server_enabled.set(True))
             self.log_message("已加载 API 服务器设置")
+
+        # [新增] 加载 WebSocket 设置
+        websocket_settings = config.get("websocket_server")
+        if websocket_settings:
+            self.websocket_port_var.set(websocket_settings.get("port", "8001"))
+            if websocket_settings.get("enabled", False):
+                # 延迟执行，确保UI完全加载
+                self.root.after(200, lambda: self.websocket_server_enabled.set(True))
+            self.log_message("已加载 WebSocket 服务器设置")
 
     def toggle_vrc_connection(self):
         if self.vrc_connected:
@@ -433,8 +490,11 @@ def on_closing(self):
             self.disconnect_device()
         if self.vrc_connected:
             self.vrc_osc_client.disconnect()
-        if self.api_server and self.api_server.httpd:
+        # [修改] 增加停止服务器的逻辑
+        if self.api_server:
             self.api_server.stop()
+        if self.websocket_server:
+            self.websocket_server.stop()
         if self.floating_window.is_open():
             self.floating_window.close_window()
         self.root.destroy()
@@ -588,13 +648,14 @@ def _on_connect(self):
         self.connected = True
         self.status_label.config(text="状态: 已连接", fg="green")
         self.log_message("设备连接成功，开始监控心率")
-        # [修改] 触发 "connected" 事件
         self.webhook_manager.trigger_event("connected", self.heart_rate)
+        # [新增] 连接时广播状态
+        if self.websocket_server:
+            self.websocket_server.broadcast()
 
 
     def _on_disconnect(self):
-        # [修改] 先触发事件，再更新状态
-        if self.connected: # 只有在之前是连接状态时才触发
+        if self.connected: 
             self.webhook_manager.trigger_event("disconnected", self.heart_rate)
 
         self.connected = False
@@ -605,13 +666,13 @@ def _on_disconnect(self):
         self.heart_rate_label.config(text="心率: --", fg="red")
         self.heart_rate_queue.put(0) 
         self.log_message("设备已断开连接")
+        # [新增] 断开时广播状态
+        if self.websocket_server:
+            self.websocket_server.broadcast()
 
     def disconnect_device(self):
         self.should_stop = True
         if self.ble_loop and not self.ble_loop.is_closed() and self.ble_loop.is_running():
-            # 停止事件循环可能会导致正在运行的异步任务突然中断，
-            # 这里改为在循环内通过 should_stop 标志来优雅退出
-            # self.ble_loop.call_soon_threadsafe(self.ble_loop.stop)
             pass
         self._on_disconnect()
         self.log_message("手动断开连接")

requirements.txt

@@ -1,4 +1,5 @@
 bleak
 python-osc
 Flask
-pillow
+pillow
+websockets

websocket_server.py

@@ -0,0 +1,116 @@
+# websocket_server.py
+
+import asyncio
+import json
+import threading
+from typing import Set, Optional, Callable, TYPE_CHECKING
+import websockets
+from websockets.server import ServerProtocol
+
+if TYPE_CHECKING:
+    from heart_rate_display_ui import HeartRateMonitor
+
+
+class WebSocketServer:
+    """
+    运行在独立线程中的WebSocket服务器，用于实时推送心率数据。
+    """
+
+    def __init__(self, monitor_instance: 'HeartRateMonitor', port: int, logger_func: Callable[[str], None]):
+        self.monitor_instance = monitor_instance
+        self.port = port
+        self.logger = logger_func
+        self.server_thread: Optional[threading.Thread] = None
+        self.loop: Optional[asyncio.AbstractEventLoop] = None
+        self.server = None
+        self.connected_clients: Set[ServerProtocol] = set()
+
+    # [修正] 从函数签名中移除未使用的 'path' 参数，以解决 TypeError
+    async def _handler(self, websocket: ServerProtocol):
+        """处理新的客户端连接和消息"""
+        self.connected_clients.add(websocket)
+        self.logger(f"[WebSocket] 客户端连接: {websocket.remote_address}") # type: ignore
+        try:
+            # 发送当前状态
+            await self.send_data(websocket)
+            # 持续监听，直到客户端断开
+            async for message in websocket: # type: ignore
+                pass
+        except websockets.exceptions.ConnectionClosed:
+            self.logger(f"[WebSocket] 客户端断开连接: {websocket.remote_address}") # type: ignore
+        finally:
+            # 确保即使在发生异常时也能移除客户端
+            if websocket in self.connected_clients:
+                self.connected_clients.remove(websocket)
+
+    async def _run_server(self):
+        """启动WebSocket服务器的异步任务"""
+        try:
+            async with websockets.serve(self._handler, "0.0.0.0", self.port) as server: # type: ignore
+                self.server = server
+                self.logger(f"WebSocket 服务器已在 ws://0.0.0.0:{self.port} 启动")
+                await server.wait_closed()
+        except OSError as e:
+            self.logger(f"[WebSocket] 服务器启动失败: {e}. 端口可能已被占用。")
+        except Exception as e:
+            self.logger(f"[WebSocket] 服务器发生未知错误: {e}")
+
+    def _start_server_thread(self):
+        """在新的事件循环和线程中运行服务器"""
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+        self.loop.run_until_complete(self._run_server())
+
+    def start(self):
+        """在独立线程中启动WebSocket服务器"""
+        if self.server_thread and self.server_thread.is_alive():
+            self.logger("[WebSocket] 服务器已在运行中。")
+            return
+        self.server_thread = threading.Thread(target=self._start_server_thread, daemon=True)
+        self.server_thread.start()
+
+    def stop(self):
+        """停止WebSocket服务器"""
+        if self.server and self.loop:
+            self.logger("[WebSocket] 正在停止服务器...")
+            # 优雅地关闭所有客户端连接
+            for client in self.connected_clients:
+                self.loop.call_soon_threadsafe(asyncio.create_task, client.close()) # type: ignore
+
+            # 停止服务器
+            self.loop.call_soon_threadsafe(self.server.close)
+
+            # 等待服务器完全关闭
+            if self.server_thread:
+                 self.server_thread.join(timeout=2)
+
+        if self.loop and self.loop.is_running():
+            self.loop.call_soon_threadsafe(self.loop.stop)
+
+        self.logger("[WebSocket] 服务器已停止。")
+        self.server = None
+        self.server_thread = None
+        self.loop = None
+
+    async def send_data(self, websocket: ServerProtocol):
+        """向单个客户端发送当前的心率数据"""
+        data = {
+            "heart_rate": self.monitor_instance.heart_rate,
+            "connected": self.monitor_instance.connected,
+            "status": "connected" if self.monitor_instance.connected else "disconnected"
+        }
+        try:
+            await websocket.send(json.dumps(data)) # type: ignore
+        except websockets.exceptions.ConnectionClosed:
+            pass # 连接已关闭，无需处理
+
+    def broadcast(self):
+        """向所有连接的客户端广播心率数据"""
+        if not self.connected_clients or not self.loop:
+            return
+
+        # 使用 call_soon_threadsafe 从主线程安排协程在服务器的事件循环中执行
+        for client in list(self.connected_clients):
+            self.loop.call_soon_threadsafe(
+                asyncio.create_task, self.send_data(client)
+            )