feat: 优化架构

src/services/core/api.ts

@@ -0,0 +1,460 @@
+/**
+ * API 客户端
+ * 使用 fetch API 进行 HTTP 请求
+ * 支持请求/响应拦截器
+ * 支持主动刷新 token（快过期时自动刷新）
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import Constants from 'expo-constants';
+import { Platform } from 'react-native';
+
+import { eventBus } from '@/core/events/EventBus';
+
+// 生产地址 https://bbs.littlelan.cn
+const getBaseUrl = () => {
+  const configuredBaseUrl = Constants.expoConfig?.extra?.apiBaseUrl;
+  if (typeof configuredBaseUrl === 'string' && configuredBaseUrl.trim().length > 0) {
+    return configuredBaseUrl;
+  }
+  return 'https://bbs.littlelan.cn/api/v1';
+};
+
+const BASE_URL = getBaseUrl();
+const WS_URL = `${BASE_URL.replace(/^https?:\/\//, 'wss://').replace(/\/api\/v1$/, '/api/v1')}/realtime/ws`;
+
+// Token 存储键
+const TOKEN_KEY = 'auth_token';
+const REFRESH_TOKEN_KEY = 'refresh_token';
+
+// Token 提前刷新阈值（秒）：提前 5 分钟刷新
+const TOKEN_REFRESH_THRESHOLD_SECONDS = 5 * 60;
+
+// API 响应格式
+export interface ApiResponse<T> {
+  code: number;
+  message: string;
+  data: T;
+}
+
+// 分页响应格式
+export interface PaginatedData<T> {
+  list: T[];
+  total: number;
+  page: number;
+  page_size: number;
+  total_pages: number;
+}
+
+// 错误类型
+export class ApiError extends Error {
+  code: number;
+  message: string;
+  errorCode?: string;
+
+  constructor(code: number, message: string, errorCode?: string) {
+    super(message);
+    this.code = code;
+    this.message = message;
+    this.errorCode = errorCode;
+    this.name = 'ApiError';
+  }
+}
+
+// JWT Payload 结构
+interface JwtPayload {
+  user_id: string;
+  username: string;
+  exp?: number;
+  iat?: number;
+  iss?: string;
+}
+
+// API 客户端类
+class ApiClient {
+  private baseUrl: string;
+  private verificationModalShown = false;
+  private refreshLock: Promise<boolean> | null = null;
+  private isAuthFailed = false;  // 全局认证失败标志，防止无限重试
+
+  constructor(baseUrl: string) {
+    this.baseUrl = baseUrl;
+  }
+
+  private handleVerificationRequired() {
+    if (this.verificationModalShown) return;
+    this.verificationModalShown = true;
+    eventBus.emit({ type: 'SHOW_VERIFICATION_MODAL' });
+    setTimeout(() => {
+      this.verificationModalShown = false;
+    }, 3000);
+  }
+
+  private navigateToLogin() {
+    this.isAuthFailed = true;  // 设置全局失败标志
+    eventBus.emit({ type: 'NAVIGATE', payload: { path: '/(auth)/login' } });
+    eventBus.emit({ type: 'AUTH_LOGOUT' });
+  }
+
+  // 重置认证状态（登录成功后调用）
+  resetAuthState() {
+    this.isAuthFailed = false;
+    this.refreshLock = null;
+  }
+
+  private parseJwt(token: string): JwtPayload | null {
+    try {
+      const parts = token.split('.');
+      if (parts.length !== 3) {
+        return null;
+      }
+      // React Native/Expo 环境使用 atob
+      const payload = JSON.parse(atob(parts[1]));
+      return payload as JwtPayload;
+    } catch {
+      return null;
+    }
+  }
+
+  // 检查 token 是否快过期（返回 true 表示需要刷新）
+  private isTokenExpiringSoon(token: string): boolean {
+    const payload = this.parseJwt(token);
+    if (!payload || !payload.exp) {
+      return false;
+    }
+    const now = Math.floor(Date.now() / 1000);
+    const remaining = payload.exp - now;
+    // 剩余时间小于阈值时需要刷新
+    return remaining < TOKEN_REFRESH_THRESHOLD_SECONDS && remaining > 0;
+  }
+
+  // 获取 token
+  async getToken(): Promise<string | null> {
+    try {
+      return await AsyncStorage.getItem(TOKEN_KEY);
+    } catch (error) {
+      console.error('获取token失败:', error);
+      return null;
+    }
+  }
+
+  // 保存 token
+  async setToken(token: string): Promise<void> {
+    try {
+      await AsyncStorage.setItem(TOKEN_KEY, token);
+    } catch (error) {
+      console.error('保存token失败:', error);
+    }
+  }
+
+  // 获取刷新 token
+  async getRefreshToken(): Promise<string | null> {
+    try {
+      return await AsyncStorage.getItem(REFRESH_TOKEN_KEY);
+    } catch (error) {
+      console.error('获取刷新token失败:', error);
+      return null;
+    }
+  }
+
+  // 保存刷新 token
+  async setRefreshToken(token: string): Promise<void> {
+    try {
+      await AsyncStorage.setItem(REFRESH_TOKEN_KEY, token);
+    } catch (error) {
+      console.error('保存刷新token失败:', error);
+    }
+  }
+
+  // 清除 token
+  async clearToken(): Promise<void> {
+    try {
+      await AsyncStorage.multiRemove([TOKEN_KEY, REFRESH_TOKEN_KEY]);
+    } catch (error) {
+      console.error('清除token失败:', error);
+    }
+  }
+
+  // 不需要认证的路径前缀
+  private static PUBLIC_PATHS = ['/auth/login', '/auth/register', '/auth/password/', '/auth/check-username', '/auth/qrcode', '/auth/refresh'];
+
+  // 统一请求方法
+  private async request<T>(
+    method: string,
+    path: string,
+    params?: Record<string, any>,
+    body?: any,
+    _retryCount = 0,
+  ): Promise<ApiResponse<T>> {
+    // 认证已失败，仅放行公开路径（登录、注册等）
+    if (this.isAuthFailed && !ApiClient.PUBLIC_PATHS.some(p => path.startsWith(p))) {
+      throw new ApiError(401, '登录已过期，请重新登录');
+    }
+
+    const url = new URL(`${this.baseUrl}${path}`);
+    
+    // 添加查询参数
+    if (params) {
+      Object.keys(params).forEach(key => {
+        if (params[key] !== undefined && params[key] !== null) {
+          url.searchParams.append(key, String(params[key]));
+        }
+      });
+    }
+
+    // 构建请求头
+    const headers: HeadersInit = {
+      'Content-Type': 'application/json',
+    };
+
+    // 添加认证 token（主动刷新快过期的 token）
+    const token = await this.getToken();
+    if (token) {
+      // 检查 token 是否快过期，如果是则主动刷新
+      if (this.isTokenExpiringSoon(token)) {
+        const refreshed = await this.refreshToken();
+        if (!refreshed) {
+          await this.clearToken();
+          this.navigateToLogin();
+          throw new ApiError(401, '登录已过期，请重新登录');
+        }
+        const newToken = await this.getToken();
+        if (newToken) {
+          headers['Authorization'] = `Bearer ${newToken}`;
+        }
+      } else {
+        headers['Authorization'] = `Bearer ${token}`;
+      }
+    }
+
+    // 构建请求配置
+    const config: RequestInit = {
+      method,
+      headers,
+    };
+
+    // 添加请求体
+    if (body && method !== 'GET') {
+      config.body = JSON.stringify(body);
+    }
+
+    try {
+      const response = await fetch(url.toString(), config);
+      
+      // 处理 401 未授权
+      if (response.status === 401) {
+        if (_retryCount >= 1) {
+          await this.clearToken();
+          this.navigateToLogin();
+          throw new ApiError(401, '登录已过期，请重新登录');
+        }
+        const refreshed = await this.refreshToken();
+        if (!refreshed) {
+          await this.clearToken();
+          this.navigateToLogin();
+          throw new ApiError(401, '登录已过期，请重新登录');
+        }
+        
+        return this.request(method, path, params, body, _retryCount + 1);
+      }
+
+      // 解析响应（兼容非 JSON 返回，避免 SyntaxError 被误判为网络错误）
+      const contentType = response.headers.get('content-type') || '';
+      let parsedBody: any = null;
+      let rawText = '';
+
+      if (contentType.includes('application/json')) {
+        parsedBody = await response.json();
+      } else {
+        rawText = await response.text();
+        if (rawText) {
+          try {
+            parsedBody = JSON.parse(rawText);
+          } catch {
+            parsedBody = null;
+          }
+        }
+      }
+
+      // 优先处理标准 API 结构
+      if (parsedBody && typeof parsedBody === 'object' && 'code' in parsedBody) {
+        const data = parsedBody as ApiResponse<T>;
+        if (data.code !== 0) {
+          if (parsedBody.error_code === 'VERIFICATION_REQUIRED') {
+            this.handleVerificationRequired();
+          }
+          throw new ApiError(data.code, data.message || '请求失败', parsedBody.error_code);
+        }
+        return data;
+      }
+
+      // 非标准结构：先按 HTTP 状态处理失败
+      if (!response.ok) {
+        const fallbackMessage = rawText || response.statusText || `请求失败(${response.status})`;
+        throw new ApiError(response.status, fallbackMessage);
+      }
+
+      // 非标准结构但 HTTP 成功：兜底为成功响应（兼容部分纯文本成功接口）
+      return {
+        code: 0,
+        message: 'success',
+        data: (parsedBody as T) ?? (undefined as T),
+      };
+    } catch (error) {
+      // 如果是 ApiError，直接抛出
+      if (error instanceof ApiError) {
+        throw error;
+      }
+      
+      // 网络错误
+      console.error('API请求失败:', error);
+      throw new ApiError(500, '网络请求失败，请检查网络连接');
+    }
+  }
+
+  // 刷新 token（带锁，防止并发刷新）
+  private async refreshToken(): Promise<boolean> {
+    // 如果已有刷新操作正在进行，等待其完成
+    if (this.refreshLock) {
+      return this.refreshLock;
+    }
+
+    // 创建刷新锁
+    this.refreshLock = this.doRefreshToken();
+
+    try {
+      const result = await this.refreshLock;
+      return result;
+    } finally {
+      // 释放刷新锁
+      this.refreshLock = null;
+    }
+  }
+
+  // 实际执行刷新 token
+  private async doRefreshToken(): Promise<boolean> {
+    try {
+      const refreshToken = await this.getRefreshToken();
+      if (!refreshToken) {
+        return false;
+      }
+
+      const response = await fetch(`${this.baseUrl}/auth/refresh`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          refresh_token: refreshToken,
+        }),
+      });
+
+      if (!response.ok) {
+        return false;
+      }
+
+      const data = await response.json();
+      if (data.code === 0 && data.data?.token) {
+        await this.setToken(data.data.token);
+        // 后端返回refresh_token (snake_case)，兼容两种命名
+        if (data.data.refresh_token || data.data.refreshToken) {
+          await this.setRefreshToken(data.data.refresh_token || data.data.refreshToken);
+        }
+        return true;
+      }
+
+      return false;
+    } catch (error) {
+      console.error('刷新token失败:', error);
+      return false;
+    }
+  }
+
+  // GET 请求
+  async get<T>(path: string, params?: Record<string, any>): Promise<ApiResponse<T>> {
+    return this.request<T>('GET', path, params);
+  }
+
+  // POST 请求
+  async post<T>(path: string, body?: any): Promise<ApiResponse<T>> {
+    return this.request<T>('POST', path, undefined, body);
+  }
+
+  // PUT 请求
+  async put<T>(path: string, body?: any): Promise<ApiResponse<T>> {
+    return this.request<T>('PUT', path, undefined, body);
+  }
+
+  // DELETE 请求
+  async delete<T>(path: string, body?: any): Promise<ApiResponse<T>> {
+    return this.request<T>('DELETE', path, undefined, body);
+  }
+
+  // 上传文件
+  async upload<T>(
+    path: string,
+    file: { uri: string; name: string; type: string },
+    additionalData?: Record<string, string>
+  ): Promise<ApiResponse<T>> {
+    const formData = new FormData();
+    
+    // 添加文件（使用 image 字段名）
+    // Web 端需要 append Blob/File；原生端可以直接传 { uri, name, type }。
+    if (Platform.OS === 'web') {
+      const fileResponse = await fetch(file.uri);
+      const blob = await fileResponse.blob();
+      const uploadFile = new File([blob], file.name, { type: file.type || blob.type || 'application/octet-stream' });
+      formData.append('image', uploadFile);
+    } else {
+      formData.append('image', {
+        uri: file.uri,
+        name: file.name,
+        type: file.type,
+      } as any);
+    }
+
+    // 添加额外数据
+    if (additionalData) {
+      Object.keys(additionalData).forEach(key => {
+        formData.append(key, additionalData[key]);
+      });
+    }
+
+    // 获取 token 并检查是否需要刷新
+    const token = await this.getToken();
+    const headers: HeadersInit = {};
+    if (token) {
+      // 检查 token 是否快过期
+      if (this.isTokenExpiringSoon(token)) {
+        const refreshed = await this.refreshToken();
+        if (refreshed) {
+          const newToken = await this.getToken();
+          if (newToken) {
+            headers['Authorization'] = `Bearer ${newToken}`;
+          }
+        }
+      } else {
+        headers['Authorization'] = `Bearer ${token}`;
+      }
+    }
+
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: 'POST',
+      headers,
+      body: formData,
+    });
+
+    const data: ApiResponse<T> = await response.json();
+    
+    if (data.code !== 0) {
+      throw new ApiError(data.code, data.message);
+    }
+
+    return data;
+  }
+}
+
+// 导出 API 客户端实例
+export const api = new ApiClient(BASE_URL);
+
+export { WS_URL, TOKEN_KEY, REFRESH_TOKEN_KEY };

src/services/core/errorHandler.ts

@@ -0,0 +1,196 @@
+/**
+ * 统一错误处理服务
+ * 
+ * 提供标准化的错误处理流程：
+ * 1. 错误分类（网络错误、认证错误、业务错误等）
+ * 2. 日志记录
+ * 3. 用户提示
+ * 4. 错误上报
+ * 
+ * 替代散落在代码中的 console.error + 手动 Alert 模式
+ */
+
+import { showPrompt } from '../ui/promptService';
+
+export enum AppErrorCode {
+  NETWORK_ERROR = 'NETWORK_ERROR',
+  AUTH_ERROR = 'AUTH_ERROR',
+  FORBIDDEN = 'FORBIDDEN',
+  NOT_FOUND = 'NOT_FOUND',
+  VALIDATION_ERROR = 'VALIDATION_ERROR',
+  SERVER_ERROR = 'SERVER_ERROR',
+  TIMEOUT = 'TIMEOUT',
+  UNKNOWN = 'UNKNOWN',
+}
+
+export interface AppError {
+  code: AppErrorCode;
+  message: string;
+  originalError?: unknown;
+  context?: string;
+  silent?: boolean;
+}
+
+const ERROR_MESSAGES: Record<AppErrorCode, string> = {
+  [AppErrorCode.NETWORK_ERROR]: '网络连接失败，请检查网络设置',
+  [AppErrorCode.AUTH_ERROR]: '登录已过期，请重新登录',
+  [AppErrorCode.FORBIDDEN]: '没有权限执行此操作',
+  [AppErrorCode.NOT_FOUND]: '请求的资源不存在',
+  [AppErrorCode.VALIDATION_ERROR]: '输入数据有误，请检查后重试',
+  [AppErrorCode.SERVER_ERROR]: '服务器错误，请稍后重试',
+  [AppErrorCode.TIMEOUT]: '请求超时，请稍后重试',
+  [AppErrorCode.UNKNOWN]: '操作失败，请稍后重试',
+};
+
+function classifyError(error: unknown): AppErrorCode {
+  if (!error) return AppErrorCode.UNKNOWN;
+
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    
+    if (message.includes('network') || message.includes('fetch') || message.includes('econnrefused')) {
+      return AppErrorCode.NETWORK_ERROR;
+    }
+    if (message.includes('timeout') || message.includes('timed out')) {
+      return AppErrorCode.TIMEOUT;
+    }
+    if (message.includes('unauthorized') || message.includes('401') || message.includes('token')) {
+      return AppErrorCode.AUTH_ERROR;
+    }
+    if (message.includes('forbidden') || message.includes('403')) {
+      return AppErrorCode.FORBIDDEN;
+    }
+    if (message.includes('not found') || message.includes('404')) {
+      return AppErrorCode.NOT_FOUND;
+    }
+    if (message.includes('validation') || message.includes('400') || message.includes('422')) {
+      return AppErrorCode.VALIDATION_ERROR;
+    }
+    if (message.includes('500') || message.includes('502') || message.includes('503')) {
+      return AppErrorCode.SERVER_ERROR;
+    }
+  }
+
+  if (typeof error === 'object' && error !== null) {
+    const err = error as Record<string, unknown>;
+    const status = err.status || err.statusCode || err.code;
+    
+    if (status === 401) return AppErrorCode.AUTH_ERROR;
+    if (status === 403) return AppErrorCode.FORBIDDEN;
+    if (status === 404) return AppErrorCode.NOT_FOUND;
+    if (status === 400 || status === 422) return AppErrorCode.VALIDATION_ERROR;
+    if (typeof status === 'number' && status >= 500) return AppErrorCode.SERVER_ERROR;
+  }
+
+  return AppErrorCode.UNKNOWN;
+}
+
+export function createAppError(
+  error: unknown,
+  context?: string,
+  options?: { silent?: boolean; userMessage?: string }
+): AppError {
+  const code = classifyError(error);
+  return {
+    code,
+    message: options?.userMessage || ERROR_MESSAGES[code],
+    originalError: error,
+    context,
+    silent: options?.silent,
+  };
+}
+
+export interface ErrorHandlerOptions {
+  context?: string;
+  userMessage?: string;
+  silent?: boolean;
+  showErrorPrompt?: boolean;
+  logToConsole?: boolean;
+}
+
+/**
+ * 统一错误处理函数
+ * 
+ * 替代散落的 console.error + Alert 模式
+ * 
+ * @example
+ * // 之前
+ * } catch (error) {
+ *   console.error('加载帖子详情失败:', error);
+ * }
+ * 
+ * // 之后
+ * } catch (error) {
+ *   handleError(error, { context: '加载帖子详情' });
+ * }
+ */
+export function handleError(error: unknown, options: ErrorHandlerOptions = {}): AppError {
+  const {
+    context,
+    userMessage,
+    silent = false,
+    showErrorPrompt = false,
+    logToConsole = true,
+  } = options;
+
+  const appError = createAppError(error, context, { silent, userMessage });
+
+  if (logToConsole) {
+    const prefix = context ? `[${context}]` : '';
+    console.error(`${prefix} ${appError.message}`, error);
+  }
+
+  if (showErrorPrompt && !silent) {
+    showPrompt({
+      type: 'error',
+      title: context || '错误',
+      message: appError.message,
+      duration: 3000,
+    });
+  }
+
+  return appError;
+}
+
+/**
+ * 创建带上下文的错误处理器
+ * 
+ * @example
+ * const postErrorHandler = createErrorHandler('帖子');
+ * 
+ * } catch (error) {
+ *   postErrorHandler(error, { showErrorPrompt: true });
+ * }
+ */
+export function createErrorHandler(defaultContext: string) {
+  return (error: unknown, options: Omit<ErrorHandlerOptions, 'context'> = {}) => {
+    return handleError(error, { ...options, context: defaultContext });
+  };
+}
+
+/**
+ * 安全执行异步操作
+ * 
+ * @example
+ * const result = await safeAsync(
+ *   () => postService.getPost(id),
+ *   { context: '加载帖子' }
+ * );
+ * if (result.error) {
+ *   // 处理错误
+ * } else {
+ *   // 使用 result.data
+ * }
+ */
+export async function safeAsync<T>(
+  fn: () => Promise<T>,
+  options: ErrorHandlerOptions = {}
+): Promise<{ data: T | null; error: AppError | null }> {
+  try {
+    const data = await fn();
+    return { data, error: null };
+  } catch (error) {
+    const appError = handleError(error, options);
+    return { data: null, error: appError };
+  }
+}

src/services/core/index.ts

@@ -0,0 +1,39 @@
+export { api, WS_URL, TOKEN_KEY, REFRESH_TOKEN_KEY } from './api';
+export { ApiError } from './api';
+export type { ApiResponse, PaginatedData } from './api';
+
+export { wsService } from './wsService';
+export type {
+  WSMessage,
+  WSMessageType,
+  WSChatMessage,
+  WSReadMessage,
+  WSTypingMessage,
+  WSRecallMessage,
+  WSNotificationMessage,
+  WSAnnouncementMessage,
+  WSGroupChatMessage,
+  WSGroupTypingMessage,
+  GroupNoticeType,
+  WSGroupNoticeMessage,
+  WSGroupMentionMessage,
+  WSGroupReadMessage,
+  WSGroupRecallMessage,
+  WSCallIncomingMessage,
+  WSCallAcceptedMessage,
+  WSCallRejectedMessage,
+  WSCallBusyMessage,
+  WSCallEndedMessage,
+  WSCallSDPMessage,
+  WSCallICEMessage,
+  WSCallPeerMutedMessage,
+  WSCallInvitedMessage,
+  WSCallAnsweredElsewhereMessage,
+  WSErrorMessage,
+  WSServerMessage,
+  ICEServerConfig,
+} from './wsService';
+
+export { handleError, createErrorHandler, safeAsync, createAppError } from './errorHandler';
+export type { AppError, ErrorHandlerOptions } from './errorHandler';
+export { AppErrorCode } from './errorHandler';