refactor: restructure core architecture and responsive system

This commit implements a major architectural refactor to improve modularity, type safety, and maintainability across the codebase.

Key changes include:
- **Responsive System Refactor**: Migrated from a monolithic `useResponsive` hook to a set of specialized, granular hooks (`useBreakpoint`, `useOrientation`, `usePlatform`, etc.) located in `src/presentation/hooks/responsive`. This reduces unnecessary re-renders and improves developer experience.
- **Core Service Restructuring**: Introduced a new directory structure for services, including dedicated folders for `datasources`, `mappers`, and domain-specific types (`message`, `post`).
- **Data Layer Improvements**:
    - Centralized JSON parsing logic in `src/database/core/jsonUtils.ts`.
    - Cleaned up repository implementations by removing redundant local utility functions.
    - Refactored `MessageMapper` to use the new centralized JSON utility.
- **Type System Cleanup**:
    - Decomposed the large `src/types/dto.ts` into a modular `src/types/dto/` directory.
    - Simplified `src/types/index.ts` and introduced backward-compatible aliases for core entities.
- **Utility Consolidation**:
    - Created a centralized `src/utils/formatTime.ts` to replace fragmented date formatting logic across various screens and components.
    - Removed deprecated responsive utility files in favor of the new hook-based system.
- **Service Logic Refinement**: Refactored `ApiClient` and `WebSocketService` to use a centralized `showVerificationModal` service, removing duplicated state management for verification prompts.

src/services/core/datasources/CacheDataSource.ts

@@ -0,0 +1,199 @@
+/**
+ * 缓存数据源实现
+ * 基于内存和 AsyncStorage 的混合缓存实现
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { ICacheDataSource, DataSourceError } from './interfaces';
+
+interface CacheEntry<T> {
+  value: T;
+  expiry: number | null; // null 表示永不过期
+}
+
+export class CacheDataSource implements ICacheDataSource {
+  private memoryCache: Map<string, CacheEntry<any>> = new Map();
+  private maxSize: number;
+  private defaultTtl: number; // 默认过期时间（毫秒）
+  private persistPrefix: string;
+
+  constructor(config?: {
+    maxSize?: number;
+    defaultTtl?: number; // 默认5分钟
+    persistPrefix?: string;
+  }) {
+    this.maxSize = config?.maxSize || 100;
+    this.defaultTtl = config?.defaultTtl || 5 * 60 * 1000;
+    this.persistPrefix = config?.persistPrefix || 'cache_';
+  }
+
+  /**
+   * 检查 key 是否过期
+   */
+  private isExpired(entry: CacheEntry<any>): boolean {
+    if (entry.expiry === null) return false;
+    return Date.now() > entry.expiry;
+  }
+
+  /**
+   * 清理过期缓存
+   */
+  private cleanup(): void {
+    const now = Date.now();
+    for (const [key, entry] of this.memoryCache.entries()) {
+      if (entry.expiry !== null && now > entry.expiry) {
+        this.memoryCache.delete(key);
+      }
+    }
+
+    // 如果仍然超过最大大小，删除最旧的条目
+    while (this.memoryCache.size > this.maxSize) {
+      const firstKey = this.memoryCache.keys().next().value;
+      if (firstKey !== undefined) {
+        this.memoryCache.delete(firstKey);
+      }
+    }
+  }
+
+  /**
+   * 生成持久化存储 key
+   */
+  private getPersistKey(key: string): string {
+    return `${this.persistPrefix}${key}`;
+  }
+
+  // ==================== ICacheDataSource 实现 ====================
+
+  async get<T>(key: string): Promise<T | null> {
+    try {
+      // 先检查内存缓存
+      const memoryEntry = this.memoryCache.get(key);
+      if (memoryEntry) {
+        if (!this.isExpired(memoryEntry)) {
+          return memoryEntry.value as T;
+        }
+        // 过期了，从内存中删除
+        this.memoryCache.delete(key);
+      }
+
+      // 尝试从持久化存储读取
+      const persistKey = this.getPersistKey(key);
+      const stored = await AsyncStorage.getItem(persistKey);
+      if (stored) {
+        const entry: CacheEntry<T> = JSON.parse(stored);
+        if (!this.isExpired(entry)) {
+          // 重新加载到内存缓存
+          this.memoryCache.set(key, entry);
+          this.cleanup();
+          return entry.value;
+        }
+        // 过期了，删除
+        await AsyncStorage.removeItem(persistKey);
+      }
+
+      return null;
+    } catch (error) {
+      console.warn(`[CacheDataSource] Failed to get ${key}:`, error);
+      return null;
+    }
+  }
+
+  async set<T>(key: string, value: T, ttl?: number): Promise<void> {
+    try {
+      const expiry = ttl === undefined
+        ? (this.defaultTtl > 0 ? Date.now() + this.defaultTtl : null)
+        : (ttl > 0 ? Date.now() + ttl : null);
+
+      const entry: CacheEntry<T> = { value, expiry };
+
+      // 存入内存
+      this.memoryCache.set(key, entry);
+      this.cleanup();
+
+      // 持久化存储（重要数据）
+      if (ttl === undefined || ttl > 0) {
+        const persistKey = this.getPersistKey(key);
+        await AsyncStorage.setItem(persistKey, JSON.stringify(entry));
+      }
+    } catch (error) {
+      throw new DataSourceError(
+        `Failed to set cache ${key}`,
+        'CACHE_SET_ERROR',
+        'CacheDataSource',
+        error instanceof Error ? error : undefined
+      );
+    }
+  }
+
+  async delete(key: string): Promise<void> {
+    try {
+      // 从内存删除
+      this.memoryCache.delete(key);
+
+      // 从持久化存储删除
+      const persistKey = this.getPersistKey(key);
+      await AsyncStorage.removeItem(persistKey);
+    } catch (error) {
+      throw new DataSourceError(
+        `Failed to delete cache ${key}`,
+        'CACHE_DELETE_ERROR',
+        'CacheDataSource',
+        error instanceof Error ? error : undefined
+      );
+    }
+  }
+
+  async clear(): Promise<void> {
+    try {
+      // 清空内存
+      this.memoryCache.clear();
+
+      // 清空持久化存储中的所有缓存项
+      const keys = await AsyncStorage.getAllKeys();
+      const cacheKeys = keys.filter(k => k.startsWith(this.persistPrefix));
+      if (cacheKeys.length > 0) {
+        await AsyncStorage.multiRemove(cacheKeys);
+      }
+    } catch (error) {
+      throw new DataSourceError(
+        'Failed to clear cache',
+        'CACHE_CLEAR_ERROR',
+        'CacheDataSource',
+        error instanceof Error ? error : undefined
+      );
+    }
+  }
+
+  async has(key: string): Promise<boolean> {
+    try {
+      // 检查内存
+      const memoryEntry = this.memoryCache.get(key);
+      if (memoryEntry && !this.isExpired(memoryEntry)) {
+        return true;
+      }
+
+      // 检查持久化存储
+      const persistKey = this.getPersistKey(key);
+      const stored = await AsyncStorage.getItem(persistKey);
+      if (stored) {
+        const entry: CacheEntry<any> = JSON.parse(stored);
+        return !this.isExpired(entry);
+      }
+
+      return false;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async getMultiple<T>(keys: string[]): Promise<(T | null)[]> {
+    return Promise.all(keys.map(key => this.get<T>(key)));
+  }
+
+  async setMultiple<T>(entries: { key: string; value: T; ttl?: number }[]): Promise<void> {
+    await Promise.all(entries.map(entry => this.set(entry.key, entry.value, entry.ttl)));
+  }
+}
+
+// 导出单例实例
+export const cacheDataSource = new CacheDataSource();