refactor(messaging): replace WebSocket with SSE for real-time message handling

Replace WebSocket-based real-time communication with Server-Sent Events (SSE) across the messaging infrastructure. This includes:

- Create new SSEClient datasource to manage SSE connections
- Create new SSEMessageHandler to process SSE events
- Update ProcessMessageUseCase to use SSEClient instead of WebSocketClient
- Update MessageManager and MessageStateManager to work with SSE handlers
- Rename connection state variables from `isWebSocketConnected` to `isSSEConnected`
- Update type definitions in dto.ts (WSEventType → SSEEventType, etc.)
- Delete obsolete WebSocketClient and WebSocketMessageHandler files
- Update comments and documentation to reflect SSE terminology

This refactoring aligns with the backend's SSE implementation for better compatibility with React Native's networking capabilities.

src/stores/message/MessageManager.ts

@@ -3,40 +3,40 @@
  * 作为协调者，整合各个专注的服务模块
  */
 
-import { messageStateManager, MessageStateManager } from './message/MessageStateManager';
-import { webSocketMessageHandler, WebSocketMessageHandler } from './message/WebSocketMessageHandler';
-import { messageSyncService, MessageSyncService } from './message/MessageSyncService';
-import { readReceiptManager, ReadReceiptManager } from './message/ReadReceiptManager';
-import { messageRepository } from '../data/repositories/MessageRepository';
-import { useAuthStore } from './authStore';
-import type { Message, Conversation } from '../core/entities/Message';
-import type { ConversationResponse, MessageResponse } from '../types/dto';
+import { messageStateManager, MessageStateManager } from './MessageStateManager';
+import { sseMessageHandler, SSEMessageHandler } from './SSEMessageHandler';
+import { messageSyncService, MessageSyncService } from './MessageSyncService';
+import { readReceiptManager, ReadReceiptManager } from './ReadReceiptManager';
+import { messageRepository } from '../../data/repositories/MessageRepository';
+import { useAuthStore } from '../authStore';
+import type { Message, Conversation } from '../../core/entities/Message';
+import type { ConversationResponse, MessageResponse } from '../../types/dto';
 
 export type {
   MessageEventType,
   MessageEvent,
   MessageSubscriber,
-} from './message/MessageStateManager';
+} from './MessageStateManager';
 
 export class MessageManager {
   private stateManager: MessageStateManager;
-  private wsHandler: WebSocketMessageHandler;
+  private sseHandler: SSEMessageHandler;
   private syncService: MessageSyncService;
   private readManager: ReadReceiptManager;
 
   private initialized: boolean = false;
   private authUnsubscribe: (() => void) | null = null;
-  private wsUnsubscribe: (() => void) | null = null;
+  private sseUnsubscribe: (() => void) | null = null;
   private currentUserId: string | null = null;
 
   constructor() {
     this.stateManager = messageStateManager;
-    this.wsHandler = webSocketMessageHandler;
+    this.sseHandler = sseMessageHandler;
     this.syncService = messageSyncService;
     this.readManager = readReceiptManager;
 
     this.readManager.setStateManager(this.stateManager);
-    this.setupWebSocketHandlers();
+    this.setupSSEHandlers();
     this.initAuthListener();
   }
 
@@ -58,8 +58,8 @@ export class MessageManager {
     });
   }
 
-  private setupWebSocketHandlers(): void {
-    this.wsUnsubscribe = this.wsHandler.subscribe((event) => {
+  private setupSSEHandlers(): void {
+    this.sseUnsubscribe = this.sseHandler.subscribe((event) => {
       switch (event.type) {
         case 'chat_message':
         case 'group_message':
@@ -89,7 +89,7 @@ export class MessageManager {
     try {
       console.log('[MessageManager] Initializing...');
 
-      this.wsHandler.connect();
+      this.sseHandler.connect();
 
       const conversations = await this.syncService.syncConversations();
       this.stateManager.setConversations(conversations);
@@ -224,14 +224,14 @@ export class MessageManager {
   }
 
   isConnected(): boolean {
-    return this.wsHandler.isConnected();
+    return this.sseHandler.isConnected();
   }
 
   reset(): void {
     this.initialized = false;
     this.stateManager.reset();
     this.readManager.reset();
-    this.wsHandler.disconnect();
+    this.sseHandler.disconnect();
   }
 
   destroy(): void {
@@ -239,9 +239,9 @@ export class MessageManager {
       this.authUnsubscribe();
       this.authUnsubscribe = null;
     }
-    if (this.wsUnsubscribe) {
-      this.wsUnsubscribe();
-      this.wsUnsubscribe = null;
+    if (this.sseUnsubscribe) {
+      this.sseUnsubscribe();
+      this.sseUnsubscribe = null;
     }
     this.reset();
   }

src/stores/message/MessageStateManager.ts

@@ -31,7 +31,7 @@ export interface MessageState {
   conversationList: Conversation[];
   messagesMap: Map<string, Message[]>;
   unreadCount: UnreadCount;
-  isWebSocketConnected: boolean;
+  isSSEConnected: boolean;
   currentConversationId: string | null;
   isLoading: boolean;
   typingUsersMap: Map<string, string[]>;
@@ -50,7 +50,7 @@ export class MessageStateManager {
       conversationList: [],
       messagesMap: new Map(),
       unreadCount: { total: 0, system: 0 },
-      isWebSocketConnected: false,
+      isSSEConnected: false,
       currentConversationId: null,
       isLoading: false,
       typingUsersMap: new Map(),
@@ -86,7 +86,7 @@ export class MessageStateManager {
   }
 
   isConnected(): boolean {
-    return this.state.isWebSocketConnected;
+    return this.state.isSSEConnected;
   }
 
   getTypingUsers(groupId: string): string[] {
@@ -188,8 +188,8 @@ export class MessageStateManager {
     this.notify({ type: 'unread_count_updated', payload: count });
   }
 
-  setWebSocketConnected(connected: boolean): void {
-    this.state.isWebSocketConnected = connected;
+  setSSEConnected(connected: boolean): void {
+    this.state.isSSEConnected = connected;
     this.notify({ type: 'connection_changed', payload: connected });
   }
 
@@ -287,7 +287,7 @@ export class MessageStateManager {
       conversationList: [],
       messagesMap: new Map(),
       unreadCount: { total: 0, system: 0 },
-      isWebSocketConnected: false,
+      isSSEConnected: false,
       currentConversationId: null,
       isLoading: false,
       typingUsersMap: new Map(),

src/stores/message/SSEMessageHandler.ts

@@ -0,0 +1,148 @@
+/**
+ * SSE 消息处理器
+ * 只负责处理 SSE 消息，不管理状态
+ */
+
+import { sseService, WSChatMessage, WSGroupChatMessage, WSReadMessage, WSGroupReadMessage, WSRecallMessage, WSGroupRecallMessage, WSGroupTypingMessage, WSGroupNoticeMessage, GroupNoticeType, WSMessage } from '../../services/sseService';
+import type { Message, GroupNotice } from '../../core/entities/Message';
+
+export type SSEEventType =
+  | 'chat_message'
+  | 'group_message'
+  | 'read_receipt'
+  | 'group_read_receipt'
+  | 'message_recalled'
+  | 'group_message_recalled'
+  | 'typing'
+  | 'group_notice';
+
+export interface SSEEvent {
+  type: SSEEventType;
+  payload: any;
+  raw: any;
+}
+
+export type SSEEventHandler = (event: SSEEvent) => void;
+
+export class SSEMessageHandler {
+  private unsubscribeFns: Array<() => void> = [];
+  private handlers: Set<SSEEventHandler> = new Set();
+
+  connect(): void {
+    if (this.unsubscribeFns.length > 0) return;
+
+    // 监听私聊消息
+    const unsubChat = sseService.on('chat', (message) => {
+      this.emit('chat_message', this.parseChatMessage(message), message);
+    });
+
+    // 监听群聊消息
+    const unsubGroupMessage = sseService.on('group_message', (message) => {
+      this.emit('group_message', this.parseGroupMessage(message), message);
+    });
+
+    // 监听私聊已读回执
+    const unsubRead = sseService.on('read', (message) => {
+      this.emit('read_receipt', message, message);
+    });
+
+    // 监听群聊已读回执
+    const unsubGroupRead = sseService.on('group_read', (message) => {
+      this.emit('group_read_receipt', message, message);
+    });
+
+    // 监听私聊消息撤回
+    const unsubRecall = sseService.on('recall', (message) => {
+      this.emit('message_recalled', message, message);
+    });
+
+    // 监听群聊消息撤回
+    const unsubGroupRecall = sseService.on('group_recall', (message) => {
+      this.emit('group_message_recalled', message, message);
+    });
+
+    // 监听群聊输入状态
+    const unsubGroupTyping = sseService.on('group_typing', (message) => {
+      this.emit('typing', message, message);
+    });
+
+    // 监听群通知
+    const unsubGroupNotice = sseService.on('group_notice', (message) => {
+      this.emit('group_notice', this.parseGroupNotice(message), message);
+    });
+
+    this.unsubscribeFns = [
+      unsubChat,
+      unsubGroupMessage,
+      unsubRead,
+      unsubGroupRead,
+      unsubRecall,
+      unsubGroupRecall,
+      unsubGroupTyping,
+      unsubGroupNotice,
+    ];
+  }
+
+  disconnect(): void {
+    this.unsubscribeFns.forEach((fn) => fn());
+    this.unsubscribeFns = [];
+    this.handlers.clear();
+  }
+
+  subscribe(handler: SSEEventHandler): () => void {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+
+  private emit(type: SSEEventType, payload: any, raw: any): void {
+    const event: SSEEvent = { type, payload, raw };
+    this.handlers.forEach(handler => {
+      try {
+        handler(event);
+      } catch (error) {
+        console.error('[SSEMessageHandler] Handler error:', error);
+      }
+    });
+  }
+
+  private parseChatMessage(data: WSChatMessage): Message {
+    return {
+      id: data.id || '',
+      conversationId: data.conversation_id || '',
+      senderId: data.sender_id || '',
+      seq: data.seq || 0,
+      segments: data.segments || [],
+      createdAt: data.created_at || new Date().toISOString(),
+      status: 'normal',
+    };
+  }
+
+  private parseGroupMessage(data: WSGroupChatMessage): Message {
+    return {
+      id: data.id || '',
+      conversationId: data.conversation_id || '',
+      senderId: data.sender_id || '',
+      seq: data.seq || 0,
+      segments: data.segments || [],
+      createdAt: data.created_at || new Date().toISOString(),
+      status: 'normal',
+    };
+  }
+
+  private parseGroupNotice(data: WSGroupNoticeMessage): GroupNotice {
+    return {
+      type: data.notice_type || 'member_join',
+      groupId: String(data.group_id || ''),
+      data: data.data || {},
+      timestamp: data.timestamp || Date.now(),
+      messageId: data.message_id,
+      seq: data.seq,
+    };
+  }
+
+  isConnected(): boolean {
+    return sseService.isConnected();
+  }
+}
+
+export const sseMessageHandler = new SSEMessageHandler();

src/stores/message/WebSocketMessageHandler.ts

@@ -1,136 +0,0 @@
-/**
- * WebSocket 消息处理器
- * 只负责处理 WebSocket 消息，不管理状态
- */
-
-import { sseService, WSChatMessage, WSGroupChatMessage, WSReadMessage, WSGroupReadMessage, WSRecallMessage, WSGroupRecallMessage, WSGroupTypingMessage, WSGroupNoticeMessage, GroupNoticeType } from '../../services/sseService';
-import type { Message, GroupNotice } from '../../core/entities/Message';
-
-export type WebSocketEventType =
-  | 'chat_message'
-  | 'group_message'
-  | 'read_receipt'
-  | 'group_read_receipt'
-  | 'message_recalled'
-  | 'group_message_recalled'
-  | 'typing'
-  | 'group_notice';
-
-export interface WebSocketEvent {
-  type: WebSocketEventType;
-  payload: any;
-  raw: any;
-}
-
-export type WebSocketEventHandler = (event: WebSocketEvent) => void;
-
-export class WebSocketMessageHandler {
-  private unsubscribe: (() => void) | null = null;
-  private handlers: Set<WebSocketEventHandler> = new Set();
-
-  connect(): void {
-    if (this.unsubscribe) return;
-
-    this.unsubscribe = sseService.subscribe(this.handleSSEEvent.bind(this));
-  }
-
-  disconnect(): void {
-    if (this.unsubscribe) {
-      this.unsubscribe();
-      this.unsubscribe = null;
-    }
-    this.handlers.clear();
-  }
-
-  subscribe(handler: WebSocketEventHandler): () => void {
-    this.handlers.add(handler);
-    return () => this.handlers.delete(handler);
-  }
-
-  private handleSSEEvent(event: any): void {
-    const { type, data } = event;
-
-    switch (type) {
-      case 'chat':
-        this.emit('chat_message', this.parseChatMessage(data), data);
-        break;
-      case 'group_message':
-        this.emit('group_message', this.parseGroupMessage(data), data);
-        break;
-      case 'read':
-        this.emit('read_receipt', data, data);
-        break;
-      case 'group_read':
-        this.emit('group_read_receipt', data, data);
-        break;
-      case 'recall':
-        this.emit('message_recalled', data, data);
-        break;
-      case 'group_recall':
-        this.emit('group_message_recalled', data, data);
-        break;
-      case 'typing':
-        this.emit('typing', data, data);
-        break;
-      case 'group_notice':
-        this.emit('group_notice', this.parseGroupNotice(data), data);
-        break;
-      default:
-        console.log('[WebSocketMessageHandler] Unknown event type:', type);
-    }
-  }
-
-  private emit(type: WebSocketEventType, payload: any, raw: any): void {
-    const event: WebSocketEvent = { type, payload, raw };
-    this.handlers.forEach(handler => {
-      try {
-        handler(event);
-      } catch (error) {
-        console.error('[WebSocketMessageHandler] Handler error:', error);
-      }
-    });
-  }
-
-  private parseChatMessage(data: WSChatMessage): Message {
-    return {
-      id: data.id || '',
-      conversationId: data.conversationId || data.conversation_id || '',
-      senderId: data.senderId || data.sender_id || '',
-      seq: data.seq || 0,
-      segments: data.segments || [],
-      createdAt: data.createdAt || data.created_at || new Date().toISOString(),
-      status: 'normal',
-      sender: data.sender,
-    };
-  }
-
-  private parseGroupMessage(data: WSGroupChatMessage): Message {
-    return {
-      id: data.id || '',
-      conversationId: data.groupId || data.group_id || '',
-      senderId: data.senderId || data.sender_id || '',
-      seq: data.seq || 0,
-      segments: data.segments || [],
-      createdAt: data.createdAt || data.created_at || new Date().toISOString(),
-      status: 'normal',
-      sender: data.sender,
-    };
-  }
-
-  private parseGroupNotice(data: WSGroupNoticeMessage): GroupNotice {
-    return {
-      type: data.noticeType || data.notice_type || 'member_join',
-      groupId: data.groupId || data.group_id || '',
-      data: data.data || {},
-      timestamp: data.timestamp || Date.now(),
-      messageId: data.messageId || data.message_id,
-      seq: data.seq,
-    };
-  }
-
-  isConnected(): boolean {
-    return sseService.isConnected();
-  }
-}
-
-export const webSocketMessageHandler = new WebSocketMessageHandler();

src/stores/message/index.ts

@@ -12,8 +12,8 @@ export type { MessageState, MessageEvent, MessageSubscriber, MessageEventType }
 // 导出同步服务
 export { messageSyncService, MessageSyncService } from './MessageSyncService';
 
-// 导出WebSocket处理器
-export { webSocketMessageHandler, WebSocketMessageHandler } from './WebSocketMessageHandler';
+// 导出SSE处理器
+export { sseMessageHandler, SSEMessageHandler } from './SSEMessageHandler';
 
 // 导出已读管理器
 export { readReceiptManager, ReadReceiptManager } from './ReadReceiptManager';

src/stores/messageManager.ts

@@ -8,7 +8,7 @@
  * 
  * 架构特点：
  * - 管理conversations和messages状态
- * - 统一处理WebSocket消息
+ * - 统一处理SSE消息
  * - 统一处理本地数据库读写
  * - 提供订阅机制供React组件使用
  */
@@ -83,7 +83,7 @@ interface MessageManagerState {
   systemUnreadCount: number;
 
   // 连接状态
-  isWebSocketConnected: boolean;
+  isSSEConnected: boolean;
 
   // 当前活动会话ID（用户正在查看的会话）
   currentConversationId: string | null;
@@ -131,7 +131,7 @@ interface ReadStateRecord {
 
 class MessageManager {
   private state: MessageManagerState;
-  private wsUnsubscribe: (() => void) | null = null;
+  private sseUnsubscribe: (() => void) | null = null;
   private currentUserId: string | null = null;
   private authUnsubscribe: (() => void) | null = null;
   private lastReconnectSyncAt: number = 0;
@@ -158,7 +158,7 @@ class MessageManager {
       messagesMap: new Map(),
       totalUnreadCount: 0,
       systemUnreadCount: 0,
-      isWebSocketConnected: false,
+      isSSEConnected: false,
       currentConversationId: null,
       isLoadingConversations: false,
       loadingMessagesSet: new Set(),
@@ -281,8 +281,8 @@ class MessageManager {
           return;
         }
 
-        // 2. 初始化WebSocket监听
-        this.initWebSocketListeners();
+        // 2. 初始化SSE监听
+        this.initSSEListeners();
 
         // 3. 加载会话列表
         await this.fetchConversations();
@@ -320,9 +320,9 @@ class MessageManager {
   }
 
   destroy(): void {
-    if (this.wsUnsubscribe) {
-      this.wsUnsubscribe();
-      this.wsUnsubscribe = null;
+    if (this.sseUnsubscribe) {
+      this.sseUnsubscribe();
+      this.sseUnsubscribe = null;
     }
     this.state.subscribers.clear();
     this.state.isInitialized = false;
@@ -330,11 +330,11 @@ class MessageManager {
     this.activatingConversationTasks.clear();
   }
 
-  // ==================== WebSocket 处理 ====================
+  // ==================== SSE 处理 ====================
 
-  private initWebSocketListeners(): void {
-    if (this.wsUnsubscribe) {
-      this.wsUnsubscribe();
+  private initSSEListeners(): void {
+    if (this.sseUnsubscribe) {
+      this.sseUnsubscribe();
     }
 
 
@@ -380,7 +380,7 @@ class MessageManager {
 
     // 监听连接状态
     sseService.onConnect(() => {
-      this.state.isWebSocketConnected = true;
+      this.state.isSSEConnected = true;
       this.notifySubscribers({
         type: 'connection_changed',
         payload: { connected: true },
@@ -403,7 +403,7 @@ class MessageManager {
     });
 
     sseService.onDisconnect(() => {
-      this.state.isWebSocketConnected = false;
+      this.state.isSSEConnected = false;
       this.notifySubscribers({
         type: 'connection_changed',
         payload: { connected: false },
@@ -585,7 +585,7 @@ class MessageManager {
   }
 
   /**
-   * 处理新消息（WebSocket推送）
+   * 处理新消息（SSE推送）
    * 这是核心方法，必须立即处理并同步到所有订阅者
    */
   private async handleNewMessage(message: (WSChatMessage | WSGroupChatMessage) & { _isAck?: boolean }): Promise<void> {
@@ -2014,10 +2014,10 @@ class MessageManager {
   }
 
   /**
-   * 获取WebSocket连接状态
+   * 获取SSE连接状态
    */
   isConnected(): boolean {
-    return this.state.isWebSocketConnected;
+    return this.state.isSSEConnected;
   }
 
   /**
@@ -2122,7 +2122,7 @@ class MessageManager {
 
     subscriber({
       type: 'connection_changed',
-      payload: { connected: this.state.isWebSocketConnected },
+      payload: { connected: this.state.isSSEConnected },
       timestamp: Date.now(),
     });