存储与文件

// src/storage/async.ts —— API 全家桶速览
import AsyncStorage from '@react-native-async-storage/async-storage'

// 写 / 读 / 删，全部返回 Promise
await AsyncStorage.setItem('onboarded', 'true')
const onboarded = await AsyncStorage.getItem('onboarded') // 值是 string，类型自己序列化
await AsyncStorage.removeItem('onboarded')

// 全量 key 列表（慎用，见下文"大小限制心态"）
const keys = await AsyncStorage.getAllKeys()

// 批量读写：一次消息往返处理 N 个 key，比循环单条快得多
const pairs = await AsyncStorage.multiGet(['theme', 'fontSize', 'locale'])
// pairs: [['theme', 'dark'], ['fontSize', null], ...] —— 缺失的 key 值为 null
await AsyncStorage.multiSet([
  ['theme', 'dark'],
  ['fontSize', '16'],
])
await AsyncStorage.multiRemove(['legacy.key1', 'legacy.key2'])

# Expo 项目
npx expo install react-native-mmkv react-native-nitro-modules
npx expo prebuild

# 裸 RN
npm install react-native-mmkv react-native-nitro-modules

// src/storage/mmkv.ts
import { createMMKV } from 'react-native-mmkv'

// 工厂函数；导出单例复用，别到处 new
export const storage = createMMKV({ id: 'app-kv' })

storage.set('user.name', 'Alex') // 字符串
storage.set('user.age', 21) // 数字
storage.set('beta.toggled', true) // 布尔

const name = storage.getString('user.name') // 'Alex'，缺失返回 undefined
const age = storage.getNumber('user.age')
const flag = storage.getBoolean('beta.toggled')

storage.contains('user.name') // true
storage.getAllKeys() // 全量 key，同样比 AsyncStorage 便宜得多，但别养成依赖
storage.remove('user.name') // 返回是否真的删掉了
storage.clearAll()

// 对象没有原生支持：自己 JSON 化（和 AsyncStorage 时代同样的纪律）
storage.set('user', JSON.stringify({ username: 'Alex', age: 21 }))
const user = JSON.parse(storage.getString('user') ?? 'null')

// 二进制（token、图片缩略图）走 ArrayBuffer
storage.set('avatar', buffer) // ArrayBuffer
const buf = storage.getBuffer('avatar')

// 创建时指定（推荐，从第一天就加密，避免明文存量再迁移）
const secure = createMMKV({
  id: 'secure-kv',
  encryptionKey: '<运行时注入的密钥>',
  encryptionType: 'AES-256', // 默认 AES-128，可显式升
})

// 对已有实例加/解密（全量改写文件）
storage.encrypt('hunter2') // AES-128
storage.encrypt('hunter2again', 'AES-256')
storage.decrypt() // 去掉加密

// 实例级管理
import { existsMMKV, deleteMMKV } from 'react-native-mmkv'
existsMMKV('secure-kv') // 实例是否存在
deleteMMKV('secure-kv') // 删除整个实例

// src/storage/migrate.ts
import AsyncStorage from '@react-native-async-storage/async-storage'
import { createMMKV } from 'react-native-mmkv'

const kv = createMMKV({ id: 'app-kv' })

export async function migrateFromAsyncStorage(): Promise<void> {
  if (kv.contains('migrated.v1')) return // 幂等守卫

  const keys = await AsyncStorage.getAllKeys()
  const pairs = await AsyncStorage.multiGet(keys)
  for (const [key, value] of pairs) {
    kv.set(key, value) // 逐条灌入；值全是字符串，正好同构
  }
  kv.set('migrated.v1', true)
  await AsyncStorage.clear() // 确认线上稳定一个版本后再清，回滚窗口留着
}

// src/storage/zustand-adapter.ts
import type { StateStorage } from 'zustand/middleware'
import { storage } from './mmkv'

export const mmkvStorage: StateStorage = {
  setItem: (name, value) => storage.set(name, value),
  getItem: (name) => storage.getString(name) ?? null, // zustand 约定缺失返回 null
  removeItem: (name) => storage.remove(name),
}

const size = storage.byteSize // 当前实例字节数
if (size >= 64 * 1024 * 1024) {
  storage.trim() // 清理已删 key 的闲置空间、释放内存缓存
}

// src/store/useSettingsStore.ts
import { create } from 'zustand'
import { createJSONStorage, persist, type StateStorage } from 'zustand/middleware'
import { createMMKV } from 'react-native-mmkv'

const mmkv = createMMKV({ id: 'settings' })

const zustandStorage: StateStorage = {
  setItem: (name, value) => mmkv.set(name, value),
  getItem: (name) => mmkv.getString(name) ?? null,
  removeItem: (name) => mmkv.remove(name),
}

interface SettingsState {
  theme: 'light' | 'dark' | 'system'
  fontSize: number
  setTheme: (theme: SettingsState['theme']) => void
  setFontSize: (size: number) => void
}

export const useSettingsStore = create<SettingsState>()(
  persist(
    (set) => ({
      theme: 'system',
      fontSize: 14,
      setTheme: (theme) => set({ theme }),
      setFontSize: (fontSize) => set({ fontSize }),
    }),
    {
      name: 'settings', // MMKV 里的 key 名
      storage: createJSONStorage(() => zustandStorage), // JSON 序列化 + 异步包装都在这层
      // 只落盘纯数据：函数成员不落盘，actions 留在运行时定义
      partialize: (state) => ({ theme: state.theme, fontSize: state.fontSize }),
    },
  ),
)

// src/db/app.ts
import * as SQLite from 'expo-sqlite'

let dbPromise: Promise<SQLite.SQLiteDatabase> | null = null

export function getDb() {
  if (!dbPromise) {
    dbPromise = SQLite.openDatabaseAsync('app.db') // 懒开单例，重复调用返回同一个
  }
  return dbPromise
}

export async function initSchema(): Promise<void> {
  const db = await getDb()
  // execAsync 用于一次性跑多条建表语句；注意它不转义参数，别把用户输入拼进去
  await db.execAsync(`
    PRAGMA journal_mode = WAL;
    CREATE TABLE IF NOT EXISTS drafts (
      id TEXT PRIMARY KEY,
      body TEXT NOT NULL,
      updated_at INTEGER NOT NULL
    );
  `)
}

// src/db/drafts.ts —— 参数化读写
export async function saveDraft(id: string, body: string): Promise<void> {
  const db = await getDb()
  await db.runAsync(
    `INSERT INTO drafts (id, body, updated_at) VALUES (?, ?, ?)
     ON CONFLICT(id) DO UPDATE SET body = excluded.body, updated_at = excluded.updated_at`,
    id,
    body,
    Date.now(),
  ) // runAsync 吃位置参数绑定，返回 { lastInsertRowId, changes }
}

export async function listDrafts(limit = 20): Promise<Draft[]> {
  const db = await getDb()
  // getAllAsync 可以带泛型；结果永远是全列平铺，投影写在 SELECT 里
  return db.getAllAsync<Draft>('SELECT id, body, updated_at FROM drafts ORDER BY updated_at DESC LIMIT ?', limit)
}

export async function getDraft(id: string): Promise<Draft | null> {
  const db = await getDb()
  return db.getFirstAsync<Draft>('SELECT id, body, updated_at FROM drafts WHERE id = ?', id) // 无结果返回 null
}

// src/fs/report.ts —— 当前一代 API 风格示意，具体方法名以文档为准
import { Directory, File, Paths } from 'expo-file-system'

export function saveReport(json: object): File {
  const dir = new Directory(Paths.document, 'reports')
  dir.create({ intermediates: true }) // 目录不存在则逐级创建
  const file = new File(dir, 'latest.json')
  file.create()
  file.write(JSON.stringify(json))
  return file
}

// src/storage/secure.ts
import * as SecureStore from 'expo-secure-store'

export async function saveToken(token: string): Promise<void> {
  await SecureStore.setItemAsync('access_token', token, {
    // 设备解锁且仅本机可用；换机不恢复——这正是安全语义要的
    keychainAccessible: SecureStore.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
  })
}

export async function readToken(): Promise<string | null> {
  return SecureStore.getItemAsync('access_token')
}

export async function dropToken(): Promise<void> {
  await SecureStore.deleteItemAsync('access_token')
}

// src/cache/tiered.ts —— 三层缓存的最小可运行骨架
interface Entry<T> {
  value: T
  expiresAt: number
}

const MEM_CAP = 50
const mem = new Map<string, Entry<unknown>>() // Map 保持插入序 = LRU 的基础

function touch<T>(key: string, entry: Entry<T>): T {
  mem.delete(key) // 命中即重插到队尾，最久未用的是队头
  mem.set(key, entry)
  return entry.value
}

async function getOrLoad<T>(key: string, fetcher: () => Promise<T>, ttlMs: number): Promise<T> {
  const now = Date.now()

  const cached = mem.get(key)
  if (cached && cached.expiresAt > now) return touch(key, cached)

  const diskRaw = storage.getString(`cache:${key}`) // MMKV 实例
  if (diskRaw) {
    const disk = JSON.parse(diskRaw) as Entry<T>
    if (disk.expiresAt > now) {
      mem.set(key, disk)
      return disk.value // 磁盘命中：回灌内存
    }
  }

  const fresh = await fetcher()
  const entry: Entry<T> = { value: fresh, expiresAt: Date.now() + ttlMs }
  storage.set(`cache:${key}`, JSON.stringify(entry))
  if (mem.size >= MEM_CAP) {
    const oldest = mem.keys().next().value
    if (oldest !== undefined) mem.delete(oldest) // 超容量先赶队头
  }
  mem.set(key, entry)
  return fresh
}

// 过期清理：冷启动后台跑一次
export function purgeExpiredCache(): void {
  const now = Date.now()
  for (const key of storage.getAllKeys()) {
    if (!key.startsWith('cache:')) continue
    const raw = storage.getString(key)
    if (!raw) continue
    const entry = JSON.parse(raw) as { expiresAt: number }
    if (entry.expiresAt <= now) storage.remove(key)
  }
  if (storage.byteSize > 8 * 1024 * 1024) storage.trim()
}

// src/storage/counters.ts
import { storage } from './mmkv' // MMKV 实例

export function incrCounter(key: string, by = 1): number {
  const next = (storage.getNumber(key) ?? 0) + by
  storage.set(key, next) // 同 key 的 set 是覆盖写，累加结果直接替换旧值
  return next
}