refactor(websocket): extract websocket message types

Author: ed

pom.xml

@@ -66,6 +66,12 @@
         </dependency>
 
 
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.32</version>
+            <scope>provided</scope>
+        </dependency>
         <!--
         <dependency>
             <groupId>org.springframework.ai</groupId>

src/main/java/com/xiaozhi/communication/common/ChatSession.java

@@ -4,6 +4,8 @@
 import com.xiaozhi.dialogue.llm.tool.ToolsSessionHolder;
 import com.xiaozhi.entity.SysDevice;
 import com.xiaozhi.entity.SysRole;
+import com.xiaozhi.enums.ListenMode;
+import lombok.Data;
 import org.springframework.ai.chat.memory.ChatMemory;
 import org.springframework.ai.chat.messages.Message;
 import org.springframework.ai.tool.ToolCallback;
@@ -15,6 +17,7 @@
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
+@Data
 public abstract class ChatSession {
     /**
      * 当前会话的sessionId
@@ -49,10 +52,14 @@ public abstract class ChatSession {
      * 是否正在说话
      */
     protected boolean playing;
+    /**
+     * 客户端停止说话
+     */
+    protected boolean clientVoiceStop = false;
     /**
      * 设备状态（auto, realTime)
      */
-    protected String mode;
+    protected ListenMode mode;
     /**
      * 会话的音频数据流
      */
@@ -109,37 +116,6 @@ public String getAssistantAudioPath() {
         return dialogueId == null ? "": (String) getAttribute("assistantAudioPath_" + dialogueId);
     }
 
-    public String getSessionId() {
-        return sessionId;
-    }
-
-    public void setSessionId(String sessionId) {
-        this.sessionId = sessionId;
-    }
-
-    public SysDevice getSysDevice() {
-        return sysDevice;
-    }
-
-    public void setSysDevice(SysDevice sysDevice) {
-        this.sysDevice = sysDevice;
-    }
-
-    public List<SysRole> getSysRoleList() {
-        return sysRoleList;
-    }
-
-    public void setSysRoleList(List<SysRole> sysRoleList) {
-        this.sysRoleList = sysRoleList;
-    }
-
-    public Map<String, IotDescriptor> getIotDescriptors() {
-        return iotDescriptors;
-    }
-
-    public void setIotDescriptors(Map<String, IotDescriptor> iotDescriptors) {
-        this.iotDescriptors = iotDescriptors;
-    }
 
     public ToolsSessionHolder getFunctionSessionHolder() {
         return toolsSessionHolder;
@@ -153,70 +129,6 @@ public List<ToolCallback> getToolCallbacks() {
         return toolsSessionHolder.getAllFunction();
     }
 
-    public boolean isCloseAfterChat() {
-        return closeAfterChat;
-    }
-
-    public void setCloseAfterChat(boolean closeAfterChat) {
-        this.closeAfterChat = closeAfterChat;
-    }
-
-    public boolean isMusicPlaying() {
-        return musicPlaying;
-    }
-
-    public void setMusicPlaying(boolean musicPlaying) {
-        this.musicPlaying = musicPlaying;
-    }
-
-    public boolean isPlaying() {
-        return playing;
-    }
-
-    public void setPlaying(boolean playing) {
-        this.playing = playing;
-    }
-
-    public String getMode() {
-        return mode;
-    }
-
-    public void setMode(String mode) {
-        this.mode = mode;
-    }
-
-    public Sinks.Many<byte[]> getAudioSinks() {
-        return audioSinks;
-    }
-
-    public void setAudioSinks(Sinks.Many<byte[]> audioSinks) {
-        this.audioSinks = audioSinks;
-    }
-
-    public boolean isStreamingState() {
-        return streamingState;
-    }
-
-    public void setStreamingState(boolean streamingState) {
-        this.streamingState = streamingState;
-    }
-
-    public Instant getLastActivityTime() {
-        return lastActivityTime;
-    }
-
-    public void setLastActivityTime(Instant lastActivityTime) {
-        this.lastActivityTime = lastActivityTime;
-    }
-
-    public ChatMemory getChatMemory() {
-        return chatMemory;
-    }
-
-    public void setChatMemory(ChatMemory chatMemory) {
-        this.chatMemory = chatMemory;
-    }
-
     public void clearMemory() {
         chatMemory.clear(sessionId);
     }

src/main/java/com/xiaozhi/communication/common/MessageHandler.java

@@ -1,6 +1,9 @@
 package com.xiaozhi.communication.common;
 
 import com.fasterxml.jackson.databind.JsonNode;
+import com.xiaozhi.communication.domain.AbortMessage;
+import com.xiaozhi.communication.domain.GoodbyeMessage;
+import com.xiaozhi.communication.domain.ListenMessage;
 import com.xiaozhi.dialogue.llm.ChatService;
 import com.xiaozhi.dialogue.llm.factory.ChatModelFactory;
 import com.xiaozhi.dialogue.llm.tool.ToolsGlobalRegistry;
@@ -13,6 +16,7 @@
 import com.xiaozhi.dialogue.tts.factory.TtsServiceFactory;
 import com.xiaozhi.entity.SysConfig;
 import com.xiaozhi.entity.SysDevice;
+import com.xiaozhi.enums.ListenState;
 import com.xiaozhi.service.SysDeviceService;
 import com.xiaozhi.service.SysRoleService;
 import jakarta.annotation.Resource;
@@ -120,7 +124,7 @@ public void afterConnection(ChatSession chatSession, String deviceIdAuth) {
                         // 注册全局函数
                         toolsSessionHolder.registerGlobalFunctionTools(chatSession);
                     }
-                    
+
                     // 更新设备状态
                     deviceService.updateNoRefreshCache(new SysDevice()
                             .setDeviceId(device.getDeviceId())
@@ -173,56 +177,6 @@ public void afterConnectionClosed(String sessionId) {
         dialogueService.cleanupSession(sessionId);
     }
 
-    /**
-     * 处理文本消息.
-     * @param sessionId
-     * @param message
-     * @param deviceId 可能为null
-     */
-    public void handleTextMessage(String sessionId, JsonNode message, String deviceId) {
-        ChatSession chatSession = sessionManager.getSession(sessionId);
-        if(chatSession == null || !chatSession.isOpen()){
-            return;
-        }
-
-        try {
-            // 首先尝试解析JSON消息
-            String messageType = message.path("type").asText();
-
-            SysDevice device = sessionManager.getDeviceConfig(sessionId);
-            // 对于其他消息类型，检查设备是否已绑定
-            if (device == null) {
-                // 设备信息不存在，需要查询
-                Thread.startVirtualThread(() -> {
-                    try {
-                        SysDevice queryDevice = deviceService.selectDeviceById(deviceId);
-                        if (ObjectUtils.isEmpty(queryDevice) || queryDevice.getModelId() == null) {
-                            // 设备未绑定，处理未绑定设备的消息
-                            queryDevice = new SysDevice();
-                            queryDevice.setDeviceId(deviceId);
-                            handleUnboundDevice(sessionId, queryDevice);
-                        } else {
-                            // 更新缓存的设备信息
-                            sessionManager.registerDevice(sessionId, queryDevice);
-                            // 继续处理消息
-                            handleMessageByType(sessionId, message, messageType);
-                        }
-                    } catch (Exception e) {
-                        logger.error("处理消息失败", e);
-                    }
-                });
-            } else if (device.getModelId() == null) {
-                // 设备存在但未绑定模型，直接处理未绑定设备
-                handleUnboundDevice(sessionId, device);
-            } else {
-                // 设备已绑定且信息已缓存，直接处理消息
-                handleMessageByType(sessionId, message, messageType);
-            }
-        } catch (Exception e) {
-            logger.error("处理文本消息失败", e);
-        }
-    }
-
     /**
      * 处理音频数据
      * @param sessionId
@@ -238,33 +192,7 @@ public void handleBinaryMessage(String sessionId, byte[] opusData) {
 
     }
 
-    private void handleMessageByType(String sessionId, JsonNode jsonNode, String messageType) {
-        ChatSession chatSession = sessionManager.getSession(sessionId);
-        if(chatSession == null || !chatSession.isOpen()){
-            return;
-        }       try {
-            switch (messageType) {
-                case "listen":
-                    handleListenMessage(chatSession, jsonNode);
-                    break;
-                case "abort":
-                    dialogueService.abortDialogue(chatSession, jsonNode.path("reason").asText());
-                    break;
-                case "iot":
-                    handleIotMessage(chatSession, jsonNode);
-                    break;
-                case "goodbye":
-                    sessionManager.closeSession(chatSession);
-                    break;
-                default:
-                    logger.warn("未知的消息类型: {}", messageType);
-            }
-        } catch (Exception e) {
-            logger.error("处理消息失败 - 类型: " + messageType, e);
-        }
-    }
-
-    private void handleUnboundDevice(String sessionId, SysDevice device) {
+    public void handleUnboundDevice(String sessionId, SysDevice device) {
         String deviceId = device.getDeviceId();
         ChatSession chatSession = sessionManager.getSession(sessionId);
         if(chatSession == null || !chatSession.isOpen()){
@@ -329,58 +257,56 @@ private void handleUnboundDevice(String sessionId, SysDevice device) {
         });
     }
 
-
-    private void handleListenMessage(ChatSession chatSession, JsonNode jsonNode) {
+    public void handleListenMessage(ChatSession chatSession, ListenMessage message) {
         String sessionId = chatSession.getSessionId();
-        // 解析listen消息中的state和mode字段
-        String state = jsonNode.path("state").asText();
-        String mode = jsonNode.path("mode").asText();
-
-        logger.info("收到listen消息 - SessionId: {}, State: {}, Mode: {}", sessionId, state, mode);
-        sessionManager.setMode(mode);
+        logger.info("收到listen消息 - SessionId: {}, State: {}, Mode: {}", sessionId, message.getState(), message.getMode());
+        chatSession.setMode(message.getMode());
 
         // 根据state处理不同的监听状态
-        switch (state) {
-            case "start":
+        switch (message.getState()) {
+            case ListenState.Start:
                 // 开始监听，准备接收音频数据
-                logger.info("开始监听 - Mode: {}", mode);
+                logger.info("开始监听 - Mode: {}", message.getMode());
 
                 // 初始化VAD会话
                 vadService.initSession(sessionId);
                 break;
 
-            case "stop":
+            case ListenState.Stop:
                 // 停止监听
                 logger.info("停止监听");
 
+                chatSession.setClientVoiceStop(true);
                 // 关闭音频流
-                sessionManager.closeAudioStream(sessionId);
-                sessionManager.setStreamingState(sessionId, false);
+                // sessionManager.closeAudioStream(sessionId);
+                // sessionManager.setStreamingState(sessionId, false);
                 // 重置VAD会话
-                vadService.resetSession(sessionId);
+                // vadService.resetSession(sessionId);
                 break;
 
-            case "text":
+            case ListenState.Text:
                 // 检测聊天文本输入
-                String text = jsonNode.path("text").asText();
                 if (audioService.isPlaying(sessionId)) {
-                    dialogueService.abortDialogue(chatSession, mode);
+                    dialogueService.abortDialogue(chatSession, message.getMode().getValue());
                 }
-                dialogueService.handleText(chatSession, text, null);
+                dialogueService.handleText(chatSession, message.getText(), null);
                 break;
 
-            case "detect":
+            case ListenState.Detect:
                 // 检测到唤醒词
-                String wakeWord = jsonNode.path("text").asText();
-                dialogueService.handleWakeWord(chatSession, wakeWord);
+                dialogueService.handleWakeWord(chatSession, message.getText());
                 break;
 
             default:
-                logger.warn("未知的listen状态: {}", state);
+                logger.warn("未知的listen状态: {}", message.getState());
         }
     }
 
-    private void handleIotMessage(ChatSession chatSession, JsonNode jsonNode) {
+    public void handleAbortMessage(ChatSession session, AbortMessage message) {
+        dialogueService.abortDialogue(session, message.getReason());
+    }
+
+    public void handleIotMessage(ChatSession chatSession, JsonNode jsonNode) {
         String sessionId = chatSession.getSessionId();
         logger.info("收到IoT消息 - SessionId: {}", sessionId);
 
@@ -400,4 +326,8 @@ private void handleIotMessage(ChatSession chatSession, JsonNode jsonNode) {
             iotService.handleDeviceStates(sessionId, states);
         }
     }
+
+    public void handleGoodbyeMessage(ChatSession session, GoodbyeMessage message) {
+        sessionManager.closeSession(session);
+    }
 }