refactor: 架构重构 - 解耦过度耦合模块

主要改动:
1. 创建乐观更新工具函数 (optimisticUpdate.ts)
   - 消除 userStore.ts 中的重复代码

2. 拆分 useResponsive.ts (485行 -> 12个专注模块)
   - useBreakpoint: 断点检测
   - useOrientation: 方向检测
   - usePlatform: 平台检测
   - useScreenSize: 屏幕尺寸
   - useResponsiveValue: 响应式值
   - useResponsiveStyle: 响应式样式
   - useMediaQuery: 媒体查询
   - useColumnCount: 列数计算
   - useResponsiveSpacing: 响应式间距

3. 整理数据层 (Repository 层)
   - ApiDataSource: API数据源
   - LocalDataSource: 本地数据源
   - CacheDataSource: 缓存数据源
   - MessageRepository: 消息仓库

4. 重构 messageManager.ts (2194行 -> 4个模块)
   - MessageStateManager: 状态管理
   - WebSocketMessageHandler: WebSocket处理
   - MessageSyncService: 消息同步
   - ReadReceiptManager: 已读管理

5. 导航解耦 (MainNavigator.tsx: 1118行 -> 100行)
   - 创建 NavigationService 解耦层
   - 拆分多个 Navigator 组件

架构改进:
- 单一职责原则: 每个模块职责明确
- 依赖倒置: 通过接口解耦
- 代码复用: 工具函数可被多处使用
- 可测试性: 各模块可独立测试

src/stores/message/MessageSyncService.ts

@@ -0,0 +1,162 @@
+/**
+ * 消息同步服务
+ * 负责从服务器同步消息和会话
+ */
+
+import { messageService } from '../../services/messageService';
+import { messageRepository } from '../../data/repositories/MessageRepository';
+import type { Message, Conversation } from '../../core/entities/Message';
+import type { ConversationResponse, MessageResponse } from '../../types/dto';
+
+export interface SyncOptions {
+  force?: boolean;
+  lastSeq?: number;
+}
+
+export interface SyncResult {
+  conversations: Conversation[];
+  messages: Message[];
+  hasMore: boolean;
+}
+
+export class MessageSyncService {
+  private syncingConversations: boolean = false;
+  private syncingMessages: Map<string, boolean> = new Map();
+
+  async syncConversations(): Promise<Conversation[]> {
+    if (this.syncingConversations) {
+      console.log('[MessageSyncService] Already syncing conversations');
+      return [];
+    }
+
+    this.syncingConversations = true;
+
+    try {
+      const response = await messageService.getConversations();
+      const conversations = this.mapConversations(response);
+      return conversations;
+    } catch (error) {
+      console.error('[MessageSyncService] Failed to sync conversations:', error);
+      throw error;
+    } finally {
+      this.syncingConversations = false;
+    }
+  }
+
+  async syncMessages(
+    conversationId: string,
+    options: SyncOptions = {}
+  ): Promise<SyncResult> {
+    const key = conversationId;
+    
+    if (this.syncingMessages.get(key)) {
+      console.log('[MessageSyncService] Already syncing messages for:', conversationId);
+      return { conversations: [], messages: [], hasMore: false };
+    }
+
+    this.syncingMessages.set(key, true);
+
+    try {
+      const lastSeq = options.lastSeq ?? await messageRepository.getMaxSeq(conversationId);
+      
+      const response = await messageService.getMessages(conversationId, {
+        after_seq: lastSeq,
+        limit: 50,
+      });
+
+      const messages = this.mapMessages(response.messages || []);
+      
+      if (messages.length > 0) {
+        await messageRepository.saveMessages(messages, true);
+      }
+
+      return {
+        conversations: [],
+        messages,
+        hasMore: response.has_more || false,
+      };
+    } catch (error) {
+      console.error('[MessageSyncService] Failed to sync messages:', error);
+      throw error;
+    } finally {
+      this.syncingMessages.delete(key);
+    }
+  }
+
+  async loadHistoryMessages(
+    conversationId: string,
+    beforeSeq: number,
+    limit: number = 20
+  ): Promise<Message[]> {
+    try {
+      const response = await messageService.getMessages(conversationId, {
+        before_seq: beforeSeq,
+        limit,
+      });
+
+      const messages = this.mapMessages(response.messages || []);
+      
+      if (messages.length > 0) {
+        await messageRepository.saveMessages(messages, true);
+      }
+
+      return messages;
+    } catch (error) {
+      console.error('[MessageSyncService] Failed to load history:', error);
+      throw error;
+    }
+  }
+
+  async loadLocalMessages(
+    conversationId: string,
+    limit: number = 50
+  ): Promise<Message[]> {
+    return messageRepository.getMessagesByConversation(conversationId, limit);
+  }
+
+  async loadHistoryFromLocal(
+    conversationId: string,
+    beforeSeq: number,
+    limit: number = 20
+  ): Promise<Message[]> {
+    return messageRepository.getMessagesBeforeSeq(conversationId, beforeSeq, limit);
+  }
+
+  private mapConversations(response: ConversationResponse[]): Conversation[] {
+    return response.map(conv => ({
+      id: conv.id,
+      type: conv.type || 'private',
+      isPinned: conv.isPinned || false,
+      lastSeq: conv.lastSeq || conv.last_seq || 0,
+      lastMessageAt: conv.lastMessageAt || conv.last_message_at || new Date().toISOString(),
+      unreadCount: conv.unreadCount || conv.unread_count || 0,
+      participants: conv.participants || [],
+      group: conv.group,
+      createdAt: conv.createdAt || conv.created_at || new Date().toISOString(),
+      updatedAt: conv.updatedAt || conv.updated_at || new Date().toISOString(),
+    }));
+  }
+
+  private mapMessages(response: MessageResponse[]): Message[] {
+    return response.map(msg => ({
+      id: msg.id,
+      conversationId: msg.conversationId || msg.conversation_id || '',
+      senderId: msg.senderId || msg.sender_id || '',
+      seq: msg.seq || 0,
+      segments: msg.segments || [],
+      createdAt: msg.createdAt || msg.created_at || new Date().toISOString(),
+      status: msg.status || 'normal',
+      sender: msg.sender,
+    }));
+  }
+
+  isSyncingConversations(): boolean {
+    return this.syncingConversations;
+  }
+
+  isSyncingMessages(conversationId: string): boolean {
+    return this.syncingMessages.get(conversationId) || false;
+  }
+}
+
+export const messageSyncService = new MessageSyncService();