Flutter 语音房礼物下载方案（完整版）

scss 体验AI代码助手 代码解读复制代码┌──────────────────────────────────────────────────────────────┐
│                        礼物业务层                              │
│              (礼物列表展示、播放渲染、用户触发)                    │
├──────────────────────────────────────────────────────────────┤
│                       下载调度引擎                              │
│  ┌────────────┐  ┌────────────┐  ┌──────────────────────┐   │
│  │  网络探测器  │  │  优先级队列  │  │  并发度/分片策略控制   │   │
│  └────────────┘  └────────────┘  └──────────────────────┘   │
├──────────────────────────────────────────────────────────────┤
│                       分片下载层                                │
│  ┌────────────┐  ┌────────────┐  ┌──────────────────────┐   │
│  │  分片管理器  │  │  断点续传    │  │ 分片合并(Isolate)+校验│   │
│  └────────────┘  └────────────┘  └──────────────────────┘   │
├──────────────────────────────────────────────────────────────┤
│                     网络优化层（第十章）                         │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌───────────────┐  │
│  │ HTTPDNS  │ │ HTTP/2   │ │ 连接预热  │ │ TLS Session   │  │
│  │ + 预解析  │ │ 多路复用  │ │ TCP预连接 │ │ 复用 + 1.3    │  │
│  └──────────┘ └──────────┘ └──────────┘ └───────────────┘  │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌───────────────┐  │
│  │ 弱网自适应│ │ Dio 专用  │ │ 流式传输  │ │ 自适应超时     │  │
│  │ + 降级   │ │ 实例+拦截 │ │ Stream   │ │ + 速率检测    │  │
│  └──────────┘ └──────────┘ └──────────┘ └───────────────┘  │
├──────────────────────────────────────────────────────────────┤
│                        传输层                                  │
│  ┌──────────────────────┐  ┌─────────────────────────────┐  │
│  │ HTTP Range 请求管理    │  │ CDN 签名 URL 管理 + 刷新     │  │
│  └──────────────────────┘  └─────────────────────────────┘  │
├──────────────────────────────────────────────────────────────┤
│                        存储层                                  │
│  ┌────────────┐  ┌─────────────┐  ┌────────────────────┐    │
│  │ 完成文件缓存 │  │ 元数据 SQLite │  │  临时分片文件       │    │
│  └────────────┘  └─────────────┘  └────────────────────┘    │
└──────────────────────────────────────────────────────────────┘

markdown 体验AI代码助手 代码解读复制代码用户触发送礼 / 预加载触发
        ↓
检查本地缓存是否已有文件 ── 命中 → 直接使用
        ↓ 未命中
检查是否有未完成的分片 ── 有 → 断点续传流程
        ↓ 无
探测网络质量 → 决定并发参数
        ↓
进入优先级队列 → 调度引擎分配连接
        ↓
HEAD 请求获取文件信息(大小/ETag/是否支持Range)
        ↓
计算分片方案 → 多分片并行下载
        ↓
所有分片完成 → 合并 → 校验 MD5 → 存入缓存目录
        ↓
通知业务层 → 播放/渲染礼物

css 体验AI代码助手 代码解读复制代码第一层：文件级并发 —— 同时下载几个文件
   ├── 文件 A (mp4, 10MB)
   │     └── 第二层：分片并发 —— 这个文件分几片同时下
   │           ├── chunk 0  [0, 2MB)   │           ├── chunk 1  [2MB, 4MB)   │           ├── chunk 2  [4MB, 6MB)   │           ├── chunk 3  [6MB, 8MB)   │           └── chunk 4  [8MB, 10MB)   ├── 文件 B (webp, 1MB)   │     ├── chunk 0  [0, 512KB)   │     └── chunk 1  [512KB, 1MB)   └── 文件 C (mp4, 8MB) → 等待调度...

ini 体验AI代码助手 代码解读复制代码chunkSize = clamp(估算带宽 × 目标单片下载时间, 256KB, 4MB)

目标单片下载时间 = 3-5 秒（平衡响应性和效率）

举例：
- 带宽 4MB/s → 4MB/s × 4s = 16MB → clamp → 4MB
- 带宽 1MB/s → 1MB/s × 4s = 4MB → clamp → 4MB
- 带宽 200KB/s → 200KB/s × 4s = 800KB → clamp → 800KB → 取 512KB 对齐

ini 体验AI代码助手 代码解读复制代码W = α × 紧急度 + β × (1 / 文件大小) + γ × 热度 + δ × 已完成比例

α=0.5  β=0.15  γ=0.15  δ=0.2

bash 体验AI代码助手 代码解读复制代码# 1. 确认是否支持 Range
curl -I https://your-cdn.com/gift/001.mp4
# 响应头包含 Accept-Ranges: bytes → 支持

# 2. 实际请求一个范围
curl -H "Range: bytes=0-1023" -o /dev/null -w "%{http_code}" https://your-cdn.com/gift/001.mp4
# 返回 206 → 支持
# 返回 200 → 不支持（忽略了 Range）

markdown 体验AI代码助手 代码解读复制代码Flutter 客户端 ──Range 请求──→ CDN 节点 ──→ 源站(OSS/S3/Nginx)
     ↑                          ↑                  ↑
  你的代码                    全部支持            这里也必须支持

ini 体验AI代码助手 代码解读复制代码┌─ 1. HEAD 请求 ─────────────────────────────────────────────────┐
│  GET https://cdn.xxx.com/gift/001.mp4                          │
│  → 响应：                                                      │
│    Content-Length: 10485760  (文件大小 10MB)                     │
│    Accept-Ranges: bytes     (支持分片)                          │
│    ETag: "a1b2c3d4e5"       (文件版本标识)                      │
│    Content-Type: video/mp4                                     │
└────────────────────────────────────────────────────────────────┘
                              ↓
┌─ 2. 判断是否需要分片 ──────────────────────────────────────────┐
│  文件 < 1MB → 不分片，单连接下载                                 │
│  文件 >= 1MB 且支持 Range → 按策略分片                           │
│  不支持 Range → 退化为单连接整文件下载                            │
└────────────────────────────────────────────────────────────────┘
                              ↓
┌─ 3. 计算分片方案 ──────────────────────────────────────────────┐
│  示例：10MB 文件，网络良好，分片大小 2MB                          │
│                                                                │
│  chunk 0: Range: bytes=0-2097151        (0~2MB)                │
│  chunk 1: Range: bytes=2097152-4194303  (2~4MB)                │
│  chunk 2: Range: bytes=4194304-6291455  (4~6MB)                │
│  chunk 3: Range: bytes=6291456-8388607  (6~8MB)                │
│  chunk 4: Range: bytes=8388608-10485759 (8~10MB)               │
└────────────────────────────────────────────────────────────────┘
                              ↓
┌─ 4. 并行下载分片 ──────────────────────────────────────────────┐
│                                                                │
│  [并发槽1] chunk 0 ████████████ done ✅                         │
│  [并发槽2] chunk 1 ████████░░░░ 75%                            │
│  [并发槽3] chunk 2 ██████░░░░░░ 55%                            │
│  [等待中]  chunk 3 ░░░░░░░░░░░░ pending                        │
│  [等待中]  chunk 4 ░░░░░░░░░░░░ pending                        │
│                                                                │
│  chunk 0 完成 → 并发槽1 立即启动 chunk 3                         │
│  实时记录每个分片的下载进度到 DB                                  │
└────────────────────────────────────────────────────────────────┘
                              ↓
┌─ 5. 合并分片 ──────────────────────────────────────────────────┐
│  按 chunkIndex 顺序读取临时文件 → 流式追加写入最终文件             │
│  （不是一次性全部加载进内存）                                     │
└────────────────────────────────────────────────────────────────┘
                              ↓
┌─ 6. 完整性校验 ────────────────────────────────────────────────┐
│  计算最终文件 MD5 → 与服务端提供的 hash 比对                      │
│  通过 → 删除临时分片，标记完成                                    │
│  失败 → 清理所有文件，重新下载                                    │
└────────────────────────────────────────────────────────────────┘

ini 体验AI代码助手 代码解读复制代码App 重启 / 网络恢复
        ↓
从 SQLite 查询所有 status != done 的文件
        ↓
对每个文件执行续传检查：

┌─ 步骤 1：签名 URL 检查 ──────────────────────────────────┐
│                                                          │
│  CDN URL 通常带签名：                                      │
│  https://cdn.xxx.com/gift/001.mp4?token=abc&expire=xxx   │
│                                                          │
│  检查 expire 是否过期                                      │
│  ├── 未过期 → 继续使用                                     │
│  └── 已过期 → 调业务接口获取新的签名 URL                     │
│       （文件没变，只是签名换了，Range 请求依然有效）            │
└──────────────────────────────────────────────────────────┘
        ↓
┌─ 步骤 2：文件版本校验 ───────────────────────────────────┐
│                                                          │
│  发送 HEAD 请求，检查 ETag 是否与记录的一致                  │
│  ├── ETag 一致 → 文件没变，可以续传                        │
│  └── ETag 变了 → 文件已被更新，废弃所有分片，重新下载         │
│                                                          │
│  或者用 If-Range 头自动处理：                               │
│  请求头: If-Range: "旧ETag"                               │
│  └── 文件没变 → 服务端返回 206，续传                        │
│  └── 文件变了 → 服务端返回 200，整文件重新下载               │
└──────────────────────────────────────────────────────────┘
        ↓
┌─ 步骤 3：逐个分片恢复 ──────────────────────────────────┐
│                                                          │
│  chunk 0: status=done       → 跳过 ✅                     │
│  chunk 1: status=done       → 跳过 ✅                     │
│  chunk 2: status=downloading, downloadedBytes=800KB       │
│           → 从 rangeStart + 800KB 处继续                   │
│           → Range: bytes=4994304-6291455                  │
│  chunk 3: status=pending    → 正常下载                     │
│  chunk 4: status=failed     → 重置 retryCount，重新下载    │
└──────────────────────────────────────────────────────────┘

markdown 体验AI代码助手 代码解读复制代码时间线：
  T0: 开始下载，URL 有效期 30 分钟
  T0+15min: 下载了 50%，App 切后台
  T0+40min: 用户回到 App，URL 已过期

处理：
  1. 每次续传前检查 URL 中的 expire 参数
  2. 过期 → 调用业务接口 /api/gift/url?giftId=xxx 获取新签名 URL
  3. 用新 URL + 旧的 Range 参数继续下载
  4. 注意：新旧 URL 的路径和文件必须相同，只是签名参数不同

markdown 体验AI代码助手 代码解读复制代码风险场景：
  T0: 下载 gift_001.mp4 前 5MB
  T1: 运营更换了 gift_001.mp4 的内容（同 URL 不同内容）
  T2: 续传后面的 5MB → 前后内容不匹配 → 文件损坏

防御：
  1. 首次 HEAD 请求时记录 ETag
  2. 续传前 HEAD 请求比对 ETag
  3. ETag 变了 → 废弃所有已下载分片 → 完全重新下载
  4. 最终的 MD5 校验作为最后防线

bash 体验AI代码助手 代码解读复制代码极少出现但需要防御：
  如果 CDN 对文件启用了 gzip 压缩（响应头 Content-Encoding: gzip）
  → 压缩后的字节流无法按 Range 精确切分
  → 分片下载的数据拼接后解压失败

检测：
  HEAD 请求时检查 Content-Encoding
  如果是 gzip/br → 退化为单连接整文件下载

实际情况：
  CDN 默认不压缩 mp4/webp 等已压缩格式，只压缩 HTML/CSS/JS
  所以几乎不会遇到

markdown 体验AI代码助手 代码解读复制代码网络状态监听（Connectivity 插件）

网络断开：
  1. 暂停所有正在进行的 HTTP 请求
  2. 保留所有分片进度（已持久化在 DB 中）
  3. UI 层可展示"网络已断开，将在恢复后继续下载"

网络恢复：
  1. 等待 2 秒稳定期（避免网络抖动导致频繁重启）
  2. 重新探测网络质量 → 可能要调整并发参数
  3. 按优先级恢复下载队列
  4. 每个文件走断点续传流程（检查 URL、ETag）

网络切换（WiFi → 蜂窝）：
  1. 弹窗提示"当前使用移动数据，是否继续下载？"（可配置）
  2. 用户同意 → 降低并发参数，继续下载
  3. 用户拒绝 → 暂停所有下载，等 WiFi 恢复

less 体验AI代码助手 代码解读复制代码app_sandbox/
└── gift_cache/
    ├── meta.db                          ← SQLite 数据库
    │   ├── table: download_tasks          文件级任务信息
    │   ├── table: chunk_records           分片级记录
    │   └── table: network_stats           网络质量历史记录
    │
    ├── completed/                       ← 已完成的文件（最终使用）
    │   ├── gift_001.mp4
    │   ├── gift_002.webp
    │   ├── gift_003.mp4
    │   └── ...
    │
    └── temp/                            ← 下载中的分片临时文件
        ├── gift_004_chunk_0.tmp
        ├── gift_004_chunk_1.tmp
        ├── gift_004_chunk_2.tmp
        └── ...

css 体验AI代码助手 代码解读复制代码第 1 层（下载前）：服务端接口返回文件的 MD5 和大小
                   ↓
第 2 层（下载中）：每个分片验证 Content-Length 匹配
                   ↓
第 3 层（下载后）：合并后整文件 MD5 校验
                   ↓
第 4 层（使用前）：播放/渲染前快速校验文件头魔数
                  mp4 → 检查 ftyp box
                  webp → 检查 RIFF 头 + WEBP 标识

css 体验AI代码助手 代码解读复制代码场景：文件 A 正在预加载（低优先级，1 个分片并发）
      ↓
用户触发了礼物 A
      ↓
处理：
  1. 不中断、不重新下载
  2. 直接提升文件 A 的优先级为最高
  3. 增加其分片并发数（从 1 → 4）
  4. 抢占其他预加载文件的连接数
  5. 已完成的分片保留，只加速未完成的部分

scss 体验AI代码助手 代码解读复制代码┌──────────────────────────────────────────────────────────────────────┐
│                        一次分片下载的耗时拆解                          │
├──────────┬──────────┬──────────┬──────────┬──────────┬──────────────┤
│ DNS 解析  │ TCP 握手  │ TLS 握手  │ 请求发送  │ 首字节等待 │ 数据传输     │
│ (TTDNS)  │ (TCP RTT) │ (TLS RTT) │          │ (TTFB)   │ (Transfer)  │
│ 50-200ms │  1 RTT    │ 1-2 RTT   │  <1ms    │ 10-50ms  │ 与大小成正比  │
└──────────┴──────────┴──────────┴──────────┴──────────┴──────────────┘

优化目标：尽量消除或缩短前面几个阶段，让时间集中在有效的数据传输上

javascript 体验AI代码助手 代码解读复制代码时机：App 启动 / 进入语音房

预解析域名列表：
  ├── cdn.xxx.com        ← 礼物资源 CDN
  ├── api.xxx.com        ← 业务接口
  └── static.xxx.com     ← 其他静态资源

结果缓存到内存 Map<String, List<String>>：
  cdn.xxx.com → [1.2.3.4, 5.6.7.8]
  
TTL 管理：
  ├── 默认缓存 5 分钟
  ├── 解析失败时使用上次缓存结果（兜底）
  └── 网络切换时清空缓存重新解析

yaml 体验AI代码助手 代码解读复制代码HTTP/1.1 下载 4 个分片：
  连接1 ──── chunk0 ────────────────────
  连接2 ──── chunk1 ────────────────────
  连接3 ──── chunk2 ────────────────────
  连接4 ──── chunk3 ────────────────────
  → 4 条 TCP 连接，4 次 TLS 握手

HTTP/2 下载 4 个分片：
  连接1 ──┬─ stream1: chunk0 ──────────
          ├─ stream2: chunk1 ──────────    同一条 TCP 连接
          ├─ stream3: chunk2 ──────────    复用 TLS 会话
          └─ stream4: chunk3 ──────────
  → 1 条 TCP 连接，1 次 TLS 握手

arduino 体验AI代码助手 代码解读复制代码首次 TLS 握手：
  Client → ServerHello   ┐
  Server → Certificate   ├ 2 RTT（TLS 1.2）或 1 RTT（TLS 1.3）
  Client → Finished      ┘

后续请求复用 Session：
  Client → SessionTicket  ┐
  Server → Finished       ┘  1 RTT（TLS 1.2）或 0 RTT（TLS 1.3）

javascript 体验AI代码助手 代码解读复制代码全局 Dio 实例规划：
├── apiDio        ← 业务接口（JSON 短连接，超时短）
├── downloadDio   ← 礼物下载（大文件长连接，超时长，不同拦截器）
└── uploadDio     ← 上传场景（如果有）

ini 体验AI代码助手 代码解读复制代码receiveTimeout = max(分片大小 / 最低可接受速率, 15秒)

示例：
  2MB 分片 / 100KB/s 最低速率 = 20s → receiveTimeout = 20s
  256KB 分片 / 100KB/s = 2.5s → receiveTimeout = 15s（取最小值）

rust 体验AI代码助手 代码解读复制代码downloadDio 拦截器链：
  ├── LogInterceptor          ← 仅 Debug 模式开启，记录请求/响应头
  ├── RetryInterceptor        ← 自动重试（指数退避）
  ├── NetworkQualityInterceptor ← 采集 TTFB、传输速率，更新网络质量模型
  ├── SignUrlInterceptor       ← 请求前检查 URL 签名是否过期，过期则刷新
  └── ProgressInterceptor      ← 采集下载进度，更新 DB

 体验AI代码助手 代码解读复制代码Flutter 主 Isolate（UI 线程）：
  ├── Widget 构建和渲染     ← 不能被阻塞，否则掉帧
  ├── 动画更新（60/120fps）  ← 16ms/8ms 内必须完成
  ├── 事件处理
  └── 异步任务调度

如果在主 Isolate 做这些事：
  ├── MD5 计算（10MB 文件 → ~100-200ms 阻塞）    ← 会掉帧！
  ├── 分片合并（多次文件读写）                      ← 会掉帧！
  ├── SQLite 大量写入                              ← 可能卡顿
  └── gzip 解压缩                                  ← 会掉帧！

scss 体验AI代码助手 代码解读复制代码方案一：compute() —— 简单一次性任务
  适合：MD5 计算、文件合并
  特点：每次创建新 Isolate，有启动开销（~50-100ms）
  
方案二：长驻 Isolate + SendPort/ReceivePort
  适合：需要频繁调用的场景
  特点：Isolate 常驻，通过消息传递任务，避免重复创建
  
方案三：IsolatePool（自定义线程池）
  适合：大量分片并行下载时的 CPU 密集操作
  特点：预创建 N 个 Isolate，任务队列分发

本方案推荐：
  ├── MD5 计算 → compute()（一次性任务，不频繁）
  ├── 分片合并 → compute()（同上）
  └── 如果同时下载 10+ 文件都在做 MD5 → IsolatePool

sql 体验AI代码助手 代码解读复制代码精简后的分片下载请求头：
  GET /gift/001.mp4 HTTP/2
  Host: cdn.xxx.com
  Range: bytes=2097152-4194303
  If-Range: "a1b2c3d4e5"
  Accept-Encoding: identity        ← 明确告诉服务端不要压缩（mp4/webp 已压缩）
  
不需要的头：
  ✗ Cookie（CDN 不需要）
  ✗ Authorization（签名在 URL 参数中）
  ✗ Accept-Language
  ✗ User-Agent（除非 CDN 做了 UA 校验）

scss 体验AI代码助手 代码解读复制代码传统方式（内存不友好）：
  网络数据 → 全部加载到内存(Uint8List) → 一次性写入磁盘
  峰值内存：= 分片大小

流式处理（推荐）：
  网络数据 → 64KB 缓冲区 → 立即写入磁盘 → 缓冲区复用
  峰值内存：≈ 64KB

实现关键：
  Dio 设置 ResponseType.stream
  → 获取 ResponseBody.stream（Stream<Uint8List>）
  → stream.listen() 逐块接收
  → 每块立即 file.writeAsBytes(chunk, mode: FileMode.append)
  → 同时更新下载进度

arduino 体验AI代码助手 代码解读复制代码弱网不只是"慢"，还包括：
  ├── 高延迟：RTT > 300ms，握手时间长
  ├── 高丢包：TCP 频繁重传，有效吞吐量远低于带宽
  ├── 抖动大：速率忽快忽慢，超时阈值难以设定
  ├── 连接不稳定：TCP 连接频繁断开
  └── DNS 解析慢：可能 > 1s

ini 体验AI代码助手 代码解读复制代码自适应超时计算：

baseTimeout = 分片大小 / 当前估算速率 × 2  （2 倍余量）
minTimeout = 15 秒
maxTimeout = 120 秒
timeout = clamp(baseTimeout, minTimeout, maxTimeout)

动态调整：
  如果连续 2 个分片都接近超时 → 下一个分片超时再延长 50%
  如果连续 3 个分片都很快完成 → 可以适当缩短超时

bash 体验AI代码助手 代码解读复制代码下载过程中持续监控速率：

速率 > 2MB/s    → 维持当前策略
速率 1-2MB/s    → 正常
速率 500KB-1MB  → 降低并发数
速率 < 500KB    → 降到最低配置（1文件×1分片×256KB）
速率 < 50KB     → 暂停下载，提示用户网络极差
                   对于用户触发的礼物 → 显示静态占位图

速率回升时自动恢复（但不立即恢复到最高配置，渐进式提升）：
  50KB → 200KB  → 恢复到"差"配置
  200KB → 500KB → 恢复到"一般"配置
  有 2 秒滞后期，避免速率抖动导致频繁切换

markdown 体验AI代码助手 代码解读复制代码进入语音房时的预热流程：

1. DNS 预解析 cdn.xxx.com → 1.2.3.4
2. TCP 预连接 1.2.3.4:443（SYN → SYN-ACK → ACK）
3. TLS 预握手（完成 TLS 握手，但不发送业务数据）
4. 保持连接在池中等待

用户触发礼物下载时：
  → 跳过 DNS + TCP + TLS → 直接发送 GET Range 请求
  → 省去 200-500ms

 体验AI代码助手 代码解读复制代码预热时机：
  ├── 进入语音房时（最佳）
  ├── 礼物列表 API 返回后（如果礼物 CDN 域名和 API 域名不同）
  └── 首个预加载任务启动时

预热方式：
  向 CDN 发一个极小的 HEAD 请求（获取某个文件信息）
  目的不是获取数据，而是建立 TCP + TLS 连接
  后续所有分片请求都能立即使用这条连接

ini 体验AI代码助手 代码解读复制代码内存消耗点：
  ├── 网络接收缓冲区：并发数 × ~64KB = 256KB（4并发）
  ├── 文件写入缓冲区：并发数 × ~64KB = 256KB
  ├── Dio Response 对象：并发数 × ~1KB
  ├── SQLite 缓存：< 100KB
  ├── 分片元数据：每文件 < 10KB
  └── 总计：< 1MB（流式处理下）

如果不用流式处理（ResponseType.bytes）：
  ├── 4 个 2MB 分片 → 8MB 内存峰值
  ├── 加上 Dart GC 的内存碎片 → 可能触发 10MB+ 的内存波动
  └── 语音房本身已有音频缓冲区和 UI 渲染开销，这很危险

scss 体验AI代码助手 代码解读复制代码错误做法：
  chunk0_bytes = File(chunk0).readAsBytesSync();  // 2MB 进内存
  chunk1_bytes = File(chunk1).readAsBytesSync();  // 又 2MB
  finalFile.writeAsBytesSync(chunk0_bytes + chunk1_bytes); // 4MB 临时拼接

正确做法（流式合并）：
  final sink = finalFile.openWrite();
  for (chunk in sortedChunks) {
    await chunk.openRead().pipe(sink);     // 流式传输，内存只占缓冲区大小
  }
  await sink.close();

内存差异：
  错误做法：10MB 文件 → 峰值 ~20MB（原始分片 + 合并后文件同时在内存）
  正确做法：10MB 文件 → 峰值 ~128KB（读写缓冲区）

markdown 体验AI代码助手 代码解读复制代码服务端：
  1. 文件上传时计算 MD5，存入数据库
  2. 礼物列表 API 返回 fileUrl + fileMd5 + fileSize
  3. API 响应本身通过 HTTPS + Token 认证保障

客户端：
  1. API 请求带 Token → 确保获取的 MD5 是真实的
  2. CDN 下载走 HTTPS → 传输不被篡改
  3. 下载完校验 MD5 → 确保文件完整
  4. 使用前校验文件头 → 确保文件格式正确

攻击者要成功篡改文件，需要同时：
  ✗ 突破 HTTPS → 替换 API 返回的 MD5
  ✗ 突破 HTTPS → 替换 CDN 传输的文件
  ✗ 或者攻破服务端 → 那已经是另一个层面的安全问题了

css 体验AI代码助手 代码解读复制代码Flutter App 切后台时的下载行为：

iOS：
  ├── 默认：App 切后台约 30s 后暂停所有网络请求
  ├── Background Fetch：最多 30s 执行时间
  ├── Background URLSession（NSURLSession）：
  │   系统托管下载，App 被杀也能继续
  │   需要通过原生代码实现，Flutter 层做 Platform Channel 桥接
  └── 如果不做后台下载，进度保存在 DB，前台恢复时断点续传

Android：
  ├── 前台服务（Foreground Service）+ 通知栏进度条
  ├── WorkManager：适合不紧急的预加载
  └── 直接在 Service 中用 OkHttp/HttpURLConnection 下载

语音房场景的特殊性：
  语音房通常有前台服务（音频播放），App 切后台不会立即被杀
  可以继续下载，但建议降低并发数（让出资源给音频流）

arduino 体验AI代码助手 代码解读复制代码connectivity_plus 插件：
  ├── 获取当前网络类型：WiFi / Mobile / None
  ├── 监听网络变化：onConnectivityChanged
  └── 局限：只知道有没有网，不知道网络质量

进一步探测：
  ├── WiFi 有信号但无法上网 → 需要实际请求才能发现
  ├── 检测方式：向已知 CDN 发一个 HEAD 请求，超时则认为无法上网
  └── 不要用 ping（某些网络环境禁止 ICMP）

网络变化时的处理：
  WiFi → 蜂窝：
    1. 暂停下载
    2. 弹窗询问用户（可配置是否自动切换）
    3. 用户同意 → 重新探测网络质量 → 降低并发 → 继续
    
  蜂窝 → WiFi：
    1. 重新探测网络质量
    2. 提升并发参数
    3. 恢复被暂停的预加载任务
    
  有网 → 断网：
    1. 暂停所有下载
    2. 保留进度
    3. 监听网络恢复
    
  断网 → 有网：
    1. 等待 2s 稳定期
    2. 探测网络质量
    3. 断点续传流程

arduino 体验AI代码助手 代码解读复制代码Dart 是单线程事件循环模型：

Event Queue：
  ├── UI 事件
  ├── Timer 事件
  ├── IO 完成事件     ← 网络数据到达、文件写入完成
  └── Microtask 事件

网络 IO 本身不阻塞事件循环（底层由操作系统异步处理）
但以下操作会阻塞：
  ├── 同步文件读写（readAsBytesSync）      ← 避免使用
  ├── 大量数据处理（MD5、压缩）             ← 放到 Isolate
  ├── JSON 序列化大对象                    ← 放到 Isolate
  └── 复杂的集合操作                       ← 量大时注意

最佳实践：
  ├── 所有文件操作用异步版本（readAsBytes, writeAsBytes）
  ├── CPU 密集操作 → compute() / Isolate
  ├── 进度更新不要太频繁 → setState 做节流
  └── Stream.listen 的回调中不要做重操作

ini 体验AI代码助手 代码解读复制代码用户点击送礼
     │
     ▼
[业务层] 检查 completed/ 目录 ── 有文件 → 直接播放 ✅
     │ 无文件
     ▼
[业务层] 检查 DB 有无未完成任务 ── 有 → 走断点续传
     │ 无
     ▼
[业务层] 调接口获取: fileUrl(带签名) + fileSize + fileMd5
     │
     ▼
[调度引擎] 设置优先级=最高，入队
     │
     ▼
[调度引擎] 分配连接数，抢占低优先级任务
     │
     ▼
[分片层] HEAD 请求 → 获取 Content-Length + ETag + Accept-Ranges
     │
     ▼
[分片层] 计算分片方案 → 写入 DB → 启动并行下载
     │
     ├── chunk 0: GET + Range → 206 → 写入 temp 文件 → 更新 DB
     ├── chunk 1: GET + Range → 206 → 写入 temp 文件 → 更新 DB
     ├── chunk 2: GET + Range → 206 → 写入 temp 文件 → 更新 DB
     └── ...
     │ 全部完成
     ▼
[分片层] 流式合并分片 → 写入 completed/ 目录
     │
     ▼
[分片层] MD5 校验 ── 通过 → 清理 temp → 通知业务层
     │                失败 → 清理所有 → 重新下载
     ▼
[业务层] 播放礼物动画 🎁