端末の空き容量が尽きたとき、アプリは何を守るか

// storage/safeWrite.ts
import AsyncStorage from "@react-native-async-storage/async-storage";
import * as FileSystem from "expo-file-system";
 
export type WritePriority = "critical" | "normal" | "disposable";
 
export type WriteResult =
  | { ok: true }
  | { ok: false; reason: "no_space" | "unknown"; error: unknown };
 
function classify(error: unknown): "no_space" | "unknown" {
  const msg = String((error as Error)?.message ?? error).toLowerCase();
  // SQLITE_FULL / ENOSPC / "no space" を空き容量枯渇として束ねる
  if (
    msg.includes("sqlite_full") ||
    msg.includes("enospc") ||
    msg.includes("no space") ||
    msg.includes("disk is full") ||
    msg.includes("database or disk is full")
  ) {
    return "no_space";
  }
  return "unknown";
}
 
export async function safeSet(
  key: string,
  value: string,
  priority: WritePriority = "normal"
): Promise<WriteResult> {
  try {
    await AsyncStorage.setItem(key, value);
    return { ok: true };
  } catch (error) {
    const reason = classify(error);
    // 空き容量が原因なら、退避してよいものを削って一度だけ再試行する
    if (reason === "no_space" && priority === "critical") {
      const freed = await reclaimDisposableSpace();
      if (freed) {
        try {
          await AsyncStorage.setItem(key, value);
          return { ok: true };
        } catch (retryError) {
          return { ok: false, reason: classify(retryError), error: retryError };
        }
      }
    }
    return { ok: false, reason, error };
  }
}

// storage/diskBudget.ts
import * as FileSystem from "expo-file-system";
 
const LOW_SPACE_THRESHOLD_MB = 200; // これを下回ったら退避モード
const CRITICAL_THRESHOLD_MB = 60;   // これを下回ったら新規ダウンロードを止める
 
export async function getFreeMB(): Promise<number> {
  const bytes = await FileSystem.getFreeDiskStorageAsync();
  return Math.floor(bytes / (1024 * 1024));
}
 
export type DiskState = "healthy" | "low" | "critical";
 
export async function getDiskState(): Promise<DiskState> {
  const freeMB = await getFreeMB();
  if (freeMB <= CRITICAL_THRESHOLD_MB) return "critical";
  if (freeMB <= LOW_SPACE_THRESHOLD_MB) return "low";
  return "healthy";
}

// storage/reclaim.ts
import * as FileSystem from "expo-file-system";
 
const IMAGE_CACHE_DIR = FileSystem.cacheDirectory + "images/";
const RECLAIM_TARGET_MB = 80; // 一度の退避で作りたい空き
 
export async function reclaimDisposableSpace(): Promise<boolean> {
  const info = await FileSystem.getInfoAsync(IMAGE_CACHE_DIR);
  if (!info.exists) return false;
 
  const names = await FileSystem.readDirectoryAsync(IMAGE_CACHE_DIR);
  const entries = await Promise.all(
    names.map(async (name) => {
      const path = IMAGE_CACHE_DIR + name;
      const stat = await FileSystem.getInfoAsync(path, { size: true });
      return {
        path,
        size: stat.size ?? 0,
        mtime: (stat as any).modificationTime ?? 0,
      };
    })
  );
 
  // 古い順（LRU 近似）に並べ、目標に届くまで削る
  entries.sort((a, b) => a.mtime - b.mtime);
 
  let freedBytes = 0;
  const targetBytes = RECLAIM_TARGET_MB * 1024 * 1024;
  for (const entry of entries) {
    if (freedBytes >= targetBytes) break;
    await FileSystem.deleteAsync(entry.path, { idempotent: true });
    freedBytes += entry.size;
  }
  return freedBytes > 0;
}

// telemetry/writeFailure.ts
type FailureEvent = { key: string; reason: string; freeMB: number; at: number };
const buffer: FailureEvent[] = [];
 
export function recordWriteFailure(e: FailureEvent) {
  buffer.push(e);
  if (buffer.length > 50) buffer.shift(); // メモリも有限。上限を設ける
}
 
export async function flushWriteFailures(send: (e: FailureEvent[]) => Promise<void>) {
  if (buffer.length === 0) return;
  const batch = buffer.splice(0, buffer.length);
  try {
    await send(batch);
  } catch {
    // 送信に失敗したら戻す。ただし際限なくは溜めない
    buffer.unshift(...batch.slice(0, 50));
  }
}