ibi-ai-talk 1.0.0

package/src/utils/websocket.js

@@ -0,0 +1,565 @@
+// WebSocket消息处理模块
+import { webSocketConnect } from "./ota-connector.js";
+import { getConfig, saveConnectionUrls } from "./manager.js";
+import { getAudioPlayer } from "./player.js";
+import { getAudioRecorder } from "./recorder.js";
+import {
+  getMcpTools,
+  executeMcpTool,
+  setWebSocket as setMcpWebSocket,
+} from "./tools.js";
+
+// WebSocket处理器类
+export class WebSocketHandler {
+  constructor() {
+    this.websocket = null;
+    this.onConnectionStateChange = null;
+    this.onRecordButtonStateChange = null;
+    this.onSessionStateChange = null;
+    this.onSessionEmotionChange = null;
+    this.currentSessionId = null;
+    this.isRemoteSpeaking = false;
+    this.heartbeatTimer = null;
+
+    // 重连相关配置
+    this.reconnectConfig = {
+      maxRetries: 10, // 最大重连次数
+      baseDelay: 1000, // 基础重连延迟(ms)
+      maxDelay: 30000, // 最大重连延迟(ms)
+      retryCount: 0, // 当前重连次数
+      reconnectTimer: null, // 重连定时器
+      isReconnecting: false, // 是否正在重连中
+      manualDisconnect: false, // 是否手动断开连接
+    };
+  }
+
+  // 在 WebSocketHandler 类中添加
+  startHeartbeat() {
+    this.stopHeartbeat(); // 先清除之前的定时器
+    this.sendHeartbeat();
+  }
+
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearTimeout(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  sendHeartbeat() {
+    if (this.websocket?.readyState === WebSocket.OPEN) {
+      try {
+        this.websocket.send("1");
+      } catch (error) {
+        console.error("心跳发送失败:", error);
+      }
+    }
+
+    this.heartbeatTimer = setTimeout(() => {
+      this.sendHeartbeat();
+    }, 5000);
+  }
+
+  // 发送hello握手消息
+  async sendHelloMessage() {
+    if (!this.websocket || this.websocket.readyState !== WebSocket.OPEN)
+      return false;
+
+    this.startHeartbeat(); // 启动心跳
+    try {
+      const config = getConfig();
+
+      const helloMessage = {
+        type: "hello",
+        device_id: config.deviceId,
+        device_name: config.deviceName,
+        device_mac: config.deviceMac,
+        token: config.token,
+        seat: localStorage.getItem("SEAT"),
+        features: {
+          mcp: true,
+        },
+      };
+
+      console.log("发送hello握手消息", "info");
+      this.websocket.send(JSON.stringify(helloMessage));
+
+      return new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          console.log("等待hello响应超时", "error");
+          console.log('提示: 请尝试点击"测试认证"按钮进行连接排查', "info");
+          resolve(false);
+        }, 5000);
+
+        const onMessageHandler = (event) => {
+          try {
+            const response = JSON.parse(event.data);
+            if (response.type === "hello" && response.session_id) {
+              console.log(
+                `服务器握手成功，会话ID: ${response.session_id}`,
+                "success"
+              );
+              // 握手成功后重置重连计数器
+              this.reconnectConfig.retryCount = 0;
+              clearTimeout(timeout);
+              this.websocket.removeEventListener("message", onMessageHandler);
+              resolve(true);
+            }
+          } catch (e) {
+            // 忽略非JSON消息
+          }
+        };
+
+        this.websocket.addEventListener("message", onMessageHandler);
+      });
+    } catch (error) {
+      console.log(`发送hello消息错误: ${error.message}`, "error");
+      return false;
+    }
+  }
+
+  // 处理文本消息
+  handleTextMessage(message) {
+    if (message.type === "hello") {
+    } else if (message.type === "tts") {
+      this.handleTTSMessage(message);
+    } else if (message.type === "audio") {
+    } else if (message.type === "stt") {
+      const event = new CustomEvent("wsSendMessage", {
+        detail: message,
+      });
+      window.dispatchEvent(event);
+    } else if (message.type === "llm") {
+    } else if (message.type === "mcp") {
+      this.handleMCPMessage(message);
+    } else if (message.type === "json_data") {
+      if (message.state === "drinks") {
+        const event = new CustomEvent("drinkListEvent", {
+          detail: message.data,
+        });
+        window.dispatchEvent(event);
+      } else if (message.state === "book") {
+        const event = new CustomEvent("bookListEvent", {
+          detail: message
+        });
+        window.dispatchEvent(event);
+      }
+    } else if (message.type === "view_action") {
+      const event = new CustomEvent("viewActionEvent", {
+        detail: message.state,
+      });
+      window.dispatchEvent(event);
+    } else {
+      console.log(`未知消息类型: ${message.type}`, "warning");
+    }
+  }
+
+  // 处理TTS消息
+  handleTTSMessage(message) {
+    if (message.state === "start") {
+      console.log("服务器开始发送语音", "info");
+      this.currentSessionId = message.session_id;
+      const event = new CustomEvent("startThink");
+      window.dispatchEvent(event);
+      this.isRemoteSpeaking = true;
+      if (this.onSessionStateChange) {
+        this.onSessionStateChange(true);
+      }
+    } else if (message.state === "sentence_start") {
+      const event = new CustomEvent("startVolic", {
+        detail: message.text,
+      });
+      window.dispatchEvent(event);
+      console.log(`服务器发送语音段: ${message.text}`, "info");
+    } else if (message.state === "sentence_end") {
+      console.log(`语音段结束: ${message.text}`, "info");
+    } else if (message.state === "stop") {
+      const event = new CustomEvent("stopVolic");
+      window.dispatchEvent(event);
+      console.log("服务器语音传输结束", "info");
+      this.isRemoteSpeaking = false;
+      if (this.onRecordButtonStateChange) {
+        this.onRecordButtonStateChange(false);
+      }
+      if (this.onSessionStateChange) {
+        this.onSessionStateChange(false);
+      }
+    }
+  }
+
+  // 处理MCP消息
+  handleMCPMessage(message) {
+    const payload = message.payload || {};
+    console.log(`服务器下发: ${JSON.stringify(message)}`, "info");
+
+    if (payload.method === "tools/list") {
+      const tools = getMcpTools();
+      const replyMessage = JSON.stringify({
+        session_id: message.session_id || "",
+        type: "mcp",
+        payload: {
+          jsonrpc: "2.0",
+          id: payload.id,
+          result: {
+            tools: tools,
+          },
+        },
+      });
+      console.log(`客户端上报: ${replyMessage}`, "info");
+      this.websocket.send(replyMessage);
+      console.log(`回复MCP工具列表: ${tools.length} 个工具`, "info");
+    } else if (payload.method === "tools/call") {
+      const toolName = payload.params?.name;
+      const toolArgs = payload.params?.arguments;
+
+      console.log(
+        `调用工具: ${toolName} 参数: ${JSON.stringify(toolArgs)}`,
+        "info"
+      );
+
+      const result = executeMcpTool(toolName, toolArgs);
+
+      const replyMessage = JSON.stringify({
+        session_id: message.session_id || "",
+        type: "mcp",
+        payload: {
+          jsonrpc: "2.0",
+          id: payload.id,
+          result: {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result),
+              },
+            ],
+            isError: false,
+          },
+        },
+      });
+
+      console.log(`客户端上报: ${replyMessage}`, "info");
+      this.websocket.send(replyMessage);
+    } else if (payload.method === "initialize") {
+      console.log(
+        `收到工具初始化请求: ${JSON.stringify(payload.params)}`,
+        "info"
+      );
+    } else {
+      console.log(`未知的MCP方法: ${payload.method}`, "warning");
+    }
+  }
+
+  // 处理二进制消息
+  async handleBinaryMessage(data) {
+    try {
+      let arrayBuffer;
+      if (data instanceof ArrayBuffer) {
+        arrayBuffer = data;
+      } else if (data instanceof Blob) {
+        arrayBuffer = await data.arrayBuffer();
+        console.log(
+          `收到Blob音频数据，大小: ${arrayBuffer.byteLength}字节`,
+          "debug"
+        );
+      } else {
+        console.log(`收到未知类型的二进制数据: ${typeof data}`, "warning");
+        return;
+      }
+
+      const opusData = new Uint8Array(arrayBuffer);
+      const audioPlayer = getAudioPlayer();
+      audioPlayer.enqueueAudioData(opusData);
+    } catch (error) {
+      console.log(`处理二进制消息出错: ${error.message}`, "error");
+    }
+  }
+
+  // 计算重连延迟（指数退避策略）
+  calculateReconnectDelay() {
+    // 指数退避 + 随机抖动，避免多个客户端同时重连
+    const delay = Math.min(
+      this.reconnectConfig.baseDelay *
+        Math.pow(2, this.reconnectConfig.retryCount),
+      this.reconnectConfig.maxDelay
+    );
+    // 添加±20%的随机抖动
+    const jitter = delay * 0.2 * (Math.random() - 0.5);
+    return Math.round(delay + jitter);
+  }
+
+  // 触发自动重连
+  triggerReconnect() {
+    // 如果是手动断开连接，不进行重连
+    if (this.reconnectConfig.manualDisconnect) {
+      console.log("手动断开连接，不进行自动重连", "info");
+      return;
+    }
+
+    // 检查是否达到最大重连次数
+    if (this.reconnectConfig.retryCount >= this.reconnectConfig.maxRetries) {
+      console.log(
+        `已达到最大重连次数(${this.reconnectConfig.maxRetries})，停止重连`,
+        "error"
+      );
+      this.reconnectConfig.isReconnecting = false;
+      if (this.onConnectionStateChange) {
+        this.onConnectionStateChange(false);
+      }
+      return;
+    }
+
+    // 计算重连延迟
+    const delay = this.calculateReconnectDelay();
+    this.reconnectConfig.retryCount++;
+
+    console.log(
+      `准备进行第${this.reconnectConfig.retryCount}次重连，延迟${delay}ms`,
+      "info"
+    );
+
+    // 设置重连定时器
+    this.reconnectConfig.reconnectTimer = setTimeout(async () => {
+      console.log(`开始第${this.reconnectConfig.retryCount}次重连`, "info");
+      try {
+        const success = await this.connect();
+        if (success) {
+          console.log("重连成功", "success");
+          this.reconnectConfig.isReconnecting = false;
+        } else {
+          console.log(
+            `第${this.reconnectConfig.retryCount}次重连失败`,
+            "error"
+          );
+          this.triggerReconnect();
+        }
+      } catch (error) {
+        console.log(`重连出错: ${error.message}`, "error");
+        this.triggerReconnect();
+      }
+    }, delay);
+  }
+
+  // 停止自动重连
+  stopReconnect() {
+    if (this.reconnectConfig.reconnectTimer) {
+      clearTimeout(this.reconnectConfig.reconnectTimer);
+      this.reconnectConfig.reconnectTimer = null;
+    }
+    this.reconnectConfig.isReconnecting = false;
+    this.reconnectConfig.retryCount = 0;
+  }
+
+  // 连接WebSocket服务器
+  async connect() {
+    // 如果正在重连中，先停止之前的重连
+    this.stopReconnect();
+
+    const config = getConfig();
+    console.log("正在检查OTA状态...", "info");
+    saveConnectionUrls();
+
+    try {
+      const otaUrl = localStorage.getItem("xz_tester_otaUrl");
+      const ws = await webSocketConnect(otaUrl, config);
+      if (ws === undefined) {
+        // 连接失败，触发重连
+        if (
+          !this.reconnectConfig.isReconnecting &&
+          !this.reconnectConfig.manualDisconnect
+        ) {
+          this.reconnectConfig.isReconnecting = true;
+          this.triggerReconnect();
+        }
+        return false;
+      }
+
+      this.websocket = ws;
+
+      // 设置接收二进制数据的类型为ArrayBuffer
+      this.websocket.binaryType = "arraybuffer";
+
+      // 设置 MCP 模块的 WebSocket 实例
+      setMcpWebSocket(this.websocket);
+
+      // 设置录音器的WebSocket
+      const audioRecorder = getAudioRecorder();
+      audioRecorder.setWebSocket(this.websocket);
+
+      this.setupEventHandlers();
+
+      return true;
+    } catch (error) {
+      console.log(`连接错误: ${error.message}`, "error");
+      if (this.onConnectionStateChange) {
+        this.onConnectionStateChange(false);
+      }
+
+      // 连接出错，触发重连
+      if (
+        !this.reconnectConfig.isReconnecting &&
+        !this.reconnectConfig.manualDisconnect
+      ) {
+        this.reconnectConfig.isReconnecting = true;
+        this.triggerReconnect();
+      }
+
+      return false;
+    }
+  }
+
+  // 设置事件处理器
+  setupEventHandlers() {
+    this.websocket.onopen = async () => {
+      const url = localStorage.getItem("xz_tester_wsUrl");
+      console.log(`已连接到服务器: ${url}`, "success");
+
+      if (this.onConnectionStateChange) {
+        this.onConnectionStateChange(true);
+      }
+
+      // 连接成功后，默认状态为聆听中
+      this.isRemoteSpeaking = false;
+      if (this.onSessionStateChange) {
+        this.onSessionStateChange(false);
+      }
+
+      await this.sendHelloMessage();
+    };
+
+    this.websocket.onclose = (event) => {
+      console.log(
+        `已断开连接，代码: ${event.code}, 原因: ${event.reason}`,
+        "info"
+      );
+      this.stopHeartbeat();
+
+      // 清除MCP的WebSocket引用
+      setMcpWebSocket(null);
+
+      // 停止录音
+      const audioRecorder = getAudioRecorder();
+      audioRecorder.stop();
+
+      if (this.onConnectionStateChange) {
+        this.onConnectionStateChange(false);
+      }
+
+      // 如果不是手动断开连接，触发自动重连
+      if (
+        !this.reconnectConfig.manualDisconnect &&
+        !this.reconnectConfig.isReconnecting
+      ) {
+        // 1000: 正常关闭, 1001: 客户端离开, 这两种情况不自动重连
+        if (event.code !== 1000 && event.code !== 1001) {
+          console.log("检测到异常断开连接，准备自动重连", "warning");
+          this.reconnectConfig.isReconnecting = true;
+          this.triggerReconnect();
+        }
+      }
+
+      // 重置手动断开标记（以便下次可以重连）
+      this.reconnectConfig.manualDisconnect = false;
+    };
+
+    this.websocket.onerror = (error) => {
+      console.log(`WebSocket错误: ${error.message || "未知错误"}`, "error");
+
+      if (this.onConnectionStateChange) {
+        this.onConnectionStateChange(false);
+      }
+    };
+
+    this.websocket.onmessage = (event) => {
+      try {
+        if (typeof event.data === "string") {
+          const message = JSON.parse(event.data);
+          this.handleTextMessage(message);
+        } else {
+          this.handleBinaryMessage(event.data);
+        }
+      } catch (error) {
+        console.log(`WebSocket消息处理错误: ${error.message}`, "error");
+      }
+    };
+  }
+
+  // 断开连接
+  disconnect() {
+    // 标记为手动断开连接
+    this.reconnectConfig.manualDisconnect = true;
+    this.stopReconnect();
+
+    if (!this.websocket) return;
+
+    // 正常关闭连接
+    this.websocket.close(1000, "Manual disconnect");
+    const audioRecorder = getAudioRecorder();
+    audioRecorder.stop();
+  }
+
+  // 发送文本消息
+  sendTextMessage(text) {
+    try {
+      // 如果对方正在说话，先发送打断消息
+      const abortMessage = {
+        session_id: this.currentSessionId,
+        type: "abort",
+        reason: "wake_word_detected",
+      };
+      this.websocket.send(JSON.stringify(abortMessage));
+      console.log("发送打断消息", "info");
+
+      const listenMessage = {
+        type: "listen",
+        mode: localStorage.getItem("listenMode") || "wakeup",
+        state: "detect",
+        text: text,
+      };
+
+      this.websocket.send(JSON.stringify(listenMessage));
+      console.log(`发送文本消息: ${text}`, "info6666");
+
+      return true;
+    } catch (error) {
+      console.log(`发送消息错误: ${error.message}`, "error");
+      return false;
+    }
+  }
+
+  // 获取WebSocket实例
+  getWebSocket() {
+    return this.websocket;
+  }
+
+  // 检查是否已连接
+  isConnected() {
+    return this.websocket && this.websocket.readyState === WebSocket.OPEN;
+  }
+
+  // 获取重连状态
+  getReconnectStatus() {
+    return {
+      isReconnecting: this.reconnectConfig.isReconnecting,
+      retryCount: this.reconnectConfig.retryCount,
+      maxRetries: this.reconnectConfig.maxRetries,
+    };
+  }
+
+  // 重置重连配置
+  resetReconnectConfig() {
+    this.stopReconnect();
+    this.reconnectConfig.retryCount = 0;
+    this.reconnectConfig.isReconnecting = false;
+    this.reconnectConfig.manualDisconnect = false;
+  }
+}
+
+// 创建单例
+let wsHandlerInstance = null;
+
+export function getWebSocketHandler() {
+  if (!wsHandlerInstance) {
+    wsHandlerInstance = new WebSocketHandler();
+  }
+  return wsHandlerInstance;
+}