┌─────────────────────────────────────────────────────────────┐
│                      应用层 (App Process)                     │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐           │
│  │  会话状态机  │  │  媒体引擎   │  │  信令客户端  │           │
│  │ (Session FSM)│  │ (WebRTC/    │  │ (WebSocket/ │           │
│  │             │  │  自研引擎)  │  │  QUIC/HTTP3)│           │
│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘           │
│         │                │                │                   │
│         └────────────────┼────────────────┘                   │
│                          ▼                                   │
│  ┌─────────────────────────────────────────────┐             │
│  │         状态持久化层 (MMKV / SQLite /        │             │
│  │         SharedPreferences / DataStore)       │             │
│  └─────────────────────────────────────────────┘             │
└─────────────────────────────────────────────────────────────┘
                          ▲
                          │ 系统级唤醒通道
┌─────────────────────────────────────────────────────────────┐
│                      系统层 (OS Daemons)                      │
│  iOS: PushKit (VoIP Push) → CallKit → App Delegate           │
│  Android: FCM/厂商推送 → 高优先级消息 → Foreground Service   │
│         / AlarmManager (Exact) / WorkManager (加急)           │
└─────────────────────────────────────────────────────────────┘

// 1. 注册 VoIP Push
let registry = PKPushRegistry(queue: .main)
registry.delegate = self
registry.desiredPushTypes = [.voIP]

// 2. 收到 VoIP Push → 向 CallKit 报告来电
func pushRegistry(_ registry: PKPushRegistry,
                  didReceiveIncomingPushWith payload: PKPushPayload,
                  for type: PKPushType,
                  completion: @escaping () -> Void) {
    let update = CXCallUpdate()
    update.remoteHandle = CXHandle(type: .generic, value: payload.dictionaryPayload["roomId"] as? String ?? "")
    update.hasVideo = true
    provider.reportNewIncomingCall(with: UUID(), update: update) { error in
        completion() // 必须调用，否则系统判定滥用
    }
}

// 3. 用户点击接听 → 系统拉起 App → 恢复会话
func provider(_ provider: CXProvider,
              perform action: CXAnswerCallAction) {
    restoreSession(callUUID: action.callUUID) { success in
        success ? action.fulfill() : action.fail()
    }
}

// Android 14+ 启动前台服务的标准范式
val serviceIntent = Intent(this, MeetingForegroundService::class.java).apply {
    putExtra("roomId", roomId)
    putExtra("sessionSnapshot", snapshot.toByteArray())
}
val foregroundServiceInfo = ForegroundServiceInfo.Builder()
    .setType(ForegroundServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA or
             ForegroundServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE or
             ForegroundServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK)
    .setNotification(buildNotification())
    .build()

ContextCompat.startForegroundService(this, serviceIntent)
// Service 内 onStartCommand 中:
startForeground(NOTIFICATION_ID, notification, foregroundServiceInfo)

// Kotlin Data Class 示例 (配合 MMKV/ProtoBuf 序列化)
@Serializable
data class SessionSnapshot(
    // 会话标识
    val roomId: String,
    val userId: String,
    val sessionId: String,           // 本地会话唯一 ID，用于去重
    
    // 信令层
    val signalingServer: String,     // WebSocket/QUIC 地址
    val signalingToken: String,      // 短期 Token（含过期时间）
    val lastSignalingSeq: Long,      // 最后确认的信令序列号
    
    // WebRTC / 媒体协商层
    val localSdp: String?,           // type=offer/answer
    val remoteSdp: String?,
    val iceCandidates: List<IceCandidateSnapshot>,
    val dtlsFingerprint: String,     // SHA-256 指纹，用于 DTLS 复用
    val srtpKeyParams: SrtpKeySnapshot, // 加密套件、主密钥、盐
    
    // 媒体引擎层
    val videoCodec: VideoCodecConfig,    // H.264/VP8/VP9/AV1 + profile-level-id
    val audioCodec: AudioCodecConfig,    // Opus 参数
    val encoderSettings: EncoderSnapshot, // 码率、分辨率、帧率、关键帧间隔
    val jitterBufferMs: Int,             // 当前抖动缓冲区估算值
    
    // 网络/QoS 层
    val lastKnownBandwidthKbps: Int,
    val networkType: NetworkType,        // WIFI/4G/5G/ETHERNET
    val iceRole: IceRole,                // CONTROLLING/CONTROLLED
    
    // 时间戳
    val snapshotTs: Long,                // 快照生成时间
    val mediaTsOffset: Long              // 媒体时钟偏移（用于恢复同步）
)

用户点击通知/图标启动 App
        │
        ▼
Application.onCreate() / AppDelegate didFinishLaunching
        │
        ├─► 读取 SessionSnapshot (MMKV/DataStore)
        │       │
        │       ├─ 无快照 / 快照过期(> 5min) → 正常登录流程
        │       └─ 有效快照 → 进入恢复流程
        │
        ▼
启动 Foreground Service (Android) / 激活 Audio Session (iOS)
        │
        ├─► 信令重连 (WebSocket/QUIC) ──► 发送 Rejoin 信令 (携带 sessionId, lastSeq)
        │       │
        │       ├─ 服务端校验通过 → 返回最新远端 SDP + ICE 候选 + 成员列表
        │       └─ 服务端拒绝 (会议结束/踢出) → 清理快照 → 回首页
        │
        ▼
本地重建 RTCPeerConnection
        │
        ├─ setConfiguration(iceServers, iceTransportPolicy, bundlePolicy)
        ├─ setLocalDescription(savedLocalSdp)   // 复用原 SDP
        ├─ setRemoteDescription(latestRemoteSdp) // 服务端下发的最新
        ├─ addIceCandidate(savedLocalCandidates)
        ├─ addIceCandidate(newRemoteCandidates)
        │
        ▼
ICE Restart / Nomination 完成
        │
        ├─ DTLS 复用 (同一指纹) → 0-RTT 密钥恢复
        ├─ SRTP 解密恢复 → 媒体包正常解码
        │
        ▼
媒体引擎恢复
        ├─ 重新申请 Camera/Mic 权限 (前台服务类型已声明)
        ├─ 编码器按 EncoderSnapshot 恢复参数
        ├─ 抖动缓冲区预填 jitterBufferMs
        └─ 首帧渲染 → 用户感知“秒进会”

// 客户端 -> 网关/信令服务
message RejoinRequest {
  string room_id = 1;
  string session_id = 2;           // 客户端生成的本地会话 ID（UUID v7，含时间戳）
  int64 last_signaling_seq = 3;    // 客户端最后确认的信令序列号
  ClientSnapshot snapshot = 4;     // 关键媒体参数摘要（用于服务端快速校验兼容性）
  RejoinReason reason = 5;         // 枚举：COLD_START / PROCESS_KILLED / NETWORK_SWITCH / MIGRATION
  map<string, string> client_context = 6; // 扩展字段：SDK版本、OS版本、网络类型、设备指纹哈希
}

// 服务端 -> 客户端
message RejoinResponse {
  RejoinStatus status = 1;         // SUCCESS / SESSION_EXPIRED / CONFLICT / PARAM_MISMATCH / SERVER_MIGRATE
  string new_signaling_url = 2;    // 如需迁移网关
  int64 server_signaling_seq = 3;  // 服务端当前最新序列号
  SessionStateDelta state_delta = 4; // 增量状态：成员变更、锁定状态、录制状态、布局变更
  MediaNegotiationResult media = 5;  // 远端 SDP + ICE 候选 + DTLS 指纹 + SFrame/E2EE 密钥轮转信息
  ServerTiming timing = 6;         // 服务端处理耗时分布，用于客户端测速上报
}

// 媒体协商结果（支持增量）
message MediaNegotiationResult {
  string remote_sdp = 1;           // 完整 SDP（首次）或 SDP Diff（后续）
  repeated IceCandidate ice_candidates = 2;
  DtlsFingerprint dtls_fingerprint = 3; // SHA-256
  repeated SframeKeyRotation sframe_keys = 4; // E2EE 密钥轮转历史（最新在前）
  BandwidthEstimationHint bwe_hint = 5;       // 服务端侧带宽预估建议
}

// 1. 进程存活期：编码器预热池
class EncoderWarmupPool(private val maxSize: Int = 2) {
    private val pool = MutableList<MediaCodec>()
    
    fun acquire(config: MediaFormat): MediaCodec? {
        return pool.find { it.codecName == selectCodec(config) }.also { 
            if (it != null) pool.remove(it) 
        } ?: createAndConfigure(config)
    }
    
    fun release(codec: MediaCodec) {
        if (pool.size < maxSize) {
            codec.flush() // 保持实例活性，仅清空队列
            pool.add(codec)
        } else {
            codec.release()
        }
    }
}

// 2. 进程重启恢复：共享内存 + Asynchronous 回调
//    使用 MediaCodec.Callback.onOutputBufferAvailable 直接写入 SharedMemory (Ashmem/MemoryFile)
//    解码端/发送端通过 FileDescriptor 读取，避免 byte[] 拷贝
val sharedMem = MemoryFile("video_es_${sessionId}", MAX_FRAME_SIZE * 4)
codec.setOutputSurface(null) // 关闭 Surface 模式
codec.setCallback(object : MediaCodec.Callback() {
    override fun onOutputBufferAvailable(codec: MediaCodec, index: Int, info: BufferInfo) {
        sharedMem.outputStream.write(codec.getOutputBuffer(index)!!, info.offset, info.size)
        // 通过 EventFD / SocketPair 通知发送线程取走
        notifySender(sharedMem.fd, info.presentationTimeUs, info.flags)
        codec.releaseOutputBuffer(index, false)
    }
})

// 恢复后前 3-5 秒的特殊拥塞控制策略
class RecoveryProtectionController(
    private val config: RecoveryConfig
) {
    enum class Phase { PROTECT(0), PROBE(1), STABLE(2) }
    private var phase = Phase.PROTECT
    private var protectStartMs = 0L

    fun onMediaFlowRestored() {
        phase = Phase.PROTECT
        protectStartMs = SystemClock.elapsedRealtime()
        // 1. 码率锁定：锁定在恢复前 80% * 最后已知带宽，禁止探测
        encoderController.lockBitrate(lastKnownBwKbps * 0.8f)
        // 2. 强制关键帧：每 1s 发送 1 个 IDR (正常 3-5s)，加速对端同步
        encoderController.forceKeyFrameIntervalMs(1000)
        // 3. FEC 开启/提升冗余度：FEC 率 15% -> 30%
        fecController.setRedundancyRatio(0.3f)
        // 4. Pacing 降速：发包间隔 * 1.5，留足缓冲
        pacer.setPacingFactor(1.5f)
    }

    fun onRtcpFeedback(report: RtcpReport): Boolean {
        return when (phase) {
            Phase.PROTECT -> {
                if (SystemClock.elapsedRealtime() - protectStartMs > config.protectDurationMs) {
                    phase = Phase.PROBE
                    encoderController.unlockBitrate() // 允许 GCC 探测
                    fecController.setRedundancyRatio(0.15f)
                    pacer.setPacingFactor(1.0f)
                }
                true // 继续保护
            }
            Phase.PROBE -> {
                if (report.fractionLost < 0.02 && report.rttMs < 100) {
                    phase = Phase.STABLE
                    encoderController.forceKeyFrameIntervalMs(3000) // 恢复正常
                }
                true
            }
            Phase.STABLE -> false // 交还正常控制器
        }
    }
}

sequenceDiagram
    participant Phone as 手机端
    participant Server as 信令/SFU
    participant PC as 电脑端
    
    Phone->>Server: LeaveRequest(reason=MIGRATE, target_device_id="PC-123", session_snapshot=...)
    Server->>PC: MigrationInvite(session_id, snapshot, ttl=30s)
    PC->>Server: RejoinRequest(session_id, reason=MIGRATION, snapshot=...)
    Server->>PC: RejoinResponse(media=latest, state_delta=...)
    PC->>PC: 媒体引擎恢复 (复用 DTLS/ICE)
    PC-->>Server: MediaFlowActive
    Server->>Phone: MigrationConfirmed
    Phone->>Phone: 释放资源、退出会议 UI

// 1. 设备入会时发射 18-20kHz 超声波 Beacon (人耳不听见，麦克风可收)
fun startUltrasonicBeacon(deviceId: String) {
    val tone = generateUltrasonicTone(deviceId.hashCode()) // 伪随机序列
    audioPlayer.playLoop(tone, volume = 0.1f) // 极低音量
}

// 2. 收音端检测到其他设备 Beacon → 上报邻近关系
audioRecorder.setOnAudioFrameListener { frame ->
    if (detectUltrasonicBeacon(frame)) {
        val peerDeviceId = decodeBeacon(frame)
        signalingClient.send(ProximityReport(localDeviceId, peerDeviceId, rssi))
    }
}

// 3. 服务端计算拓扑 → 下发音频路由策略
//    策略示例：{ "audio_policy": "SINGLE_MIC", "master_device": "Phone-001", "mute_others": ["PC-123", "Pad-456"] }

┌─────────────────────────────────────────────────────────────────┐
│                      Chaos Orchestrator (Python/Go)              │
│  - 解析测试用例 YAML (场景、故障注入脚本、断言规则)                │
│  - 调度设备农场 (Android Farm / iOS Cloud / 模拟器矩阵)           │
│  - 并行执行、收集日志、上报指标到 InfluxDB/Grafana               │
└──────────────────────────┬──────────────────────────────────────┘
                           │
        ┌──────────────────┼──────────────────┐
        ▼                  ▼                  ▼
┌───────────────┐  ┌───────────────┐  ┌───────────────┐
│  Android Lab  │  │   iOS Lab     │  │  Server Side  │
│  - ATX/uia2   │  │  - WDA/XCUITest│  │  - Mock GW    │
│  - Magisk/Root│  │  - Private FW │  │  - Fault Inject│
│  - Perfetto   │  │  - Instruments│  │  - Chaos Mesh │
└───────────────┘  └───────────────┘  └───────────────┘

# test_case_background_kill_recovery.yaml
name: "后台 2 小时进程被杀冷启动恢复"
tags: [P0, stability, background]
precondition:
  - meeting_joined: true
  - duration_sec: 7200
  - network: "wifi_good"
steps:
  - action: "background_app"
  - wait: 7200s
  - action: "kill_process"  # 模拟 LMK 杀进程
    target: "app_process"
  - action: "launch_app_from_launcher"
  - wait: 5s
assertions:
  - metric: "meeting_restore_duration_ms"
    op: "lt"
    value: 3000
  - metric: "first_frame_decoded"
    op: "eq"
    value: true
  - metric: "audio_glitch_count_first_10s"
    op: "eq"
    value: 0
  - state: "meeting_ui_visible"
    op: "eq"
    value: true
teardown:
  - action: "leave_meeting"

// 影子会话：复用真实会议的信令/媒体参数，但不渲染、不上行、不占席位
class ShadowSession(private val realSession: RealSession) : MeetingObserver {
    private val shadowEngine = MediaEngine.createShadowMode()
    
    override fun onSignalingMessage(msg: SignalingMessage) {
        // 1. 影子引擎同步执行信令状态机
        shadowEngine.injectSignaling(msg)
        // 2. 关键节点对比
        if (msg is SdpNegotiated) {
            val diff = SdpDiff.compare(realSession.localSdp, shadowEngine.localSdp)
            if (diff.hasSemanticDiff()) {
                reportAlert("SDP_DIVERGENCE", diff)
            }
        }
    }
    
    override fun onNetworkStats(stats: NetworkStats) {
        // 3. 影子引擎跑 GCC 估算，对比真实发送码率
        val shadowBwe = shadowEngine.bweEstimate
        val realBwe = realSession.currentBitrateKbps
        if (abs(shadowBwe - realBwe) / realBwe > 0.2) {
            reportMetric("BWE_DRIFT_RATIO", (shadowBwe - realBwe) / realBwe)
        }
    }
}

Total: 2850 ms
├─ Process Start & Class Loading: 420 ms (14.7%)
│   ├─ App Startup (Application.onCreate): 180 ms
│   ├─ Native Lib Load (libwebrtc.so / libopus.so): 150 ms
│   └─ DI/Router/Config Init: 90 ms
├─ Snapshot Restore & Decrypt: 85 ms (3.0%)
│   ├─ MMKV Get + ProtoBuf Parse: 45 ms
│   └─ AES-GCM Decrypt (Keystore): 40 ms
├─ Foreground Service & Notification: 210 ms (7.4%)
│   ├─ Service Start + bind: 120 ms
│   └─ Notification Build + Post: 90 ms
├─ Signaling Reconnect (WebSocket/QUIC): 680 ms (23.9%)
│   ├─ DNS + TCP + TLS 1.3 0-RTT: 320 ms
│   ├─ Rejoin Req/Resp RTT: 280 ms
│   └─ ProtoBuf Encode/Decode: 80 ms
├─ Media Engine Rebuild: 1120 ms (39.3%)  ← 优化重点
│   ├─ PeerConnection Factory Create: 150 ms
│   ├─ PeerConnection Create: 180 ms
│   ├─ Set Local/Remote SDP: 220 ms
│   ├─ ICE Gathering (Host/Srflx/Relay): 350 ms  ← 并行化优化空间
│   ├─ DTLS Handshake (Resume): 90 ms
│   ├─ Encoder/Decoder Create & Configure: 130 ms
│   └─ First Frame Encode/Decode/Render: 200 ms
└─ UI Render & First Frame Show: 335 ms (11.8%)

class PowerAwareBackgroundPolicy(
    private val batteryManager: BatteryManager,
    private val thermalManager: ThermalManager // Android 11+
) {
    data class Policy(
        val audioHeartbeatIntervalSec: Int,
        val videoFps: Int,
        val videoBitrateKbps: Int,
        val enableCamera: Boolean,
        val enableFec: Boolean,
        val workManagerBackoffPolicy: BackoffPolicy
    )

    fun computePolicy(): Policy {
        val level = batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY) ?: 100
        val status = batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_STATUS) ?: BatteryManager.BATTERY_STATUS_DISCHARGING
        val thermalStatus = getThermalStatus() // NORMAL / LIGHT / MODERATE / SEVERE / CRITICAL
        val isCharging = status == BatteryManager.BATTERY_STATUS_CHARGING

        return when {
            level <= 15 || thermalStatus >= ThermalStatus.SEVERE -> Policy(
                audioHeartbeatIntervalSec = 60, videoFps = 0, videoBitrateKbps = 0,
                enableCamera = false, enableFec = false,
                workManagerBackoffPolicy = BackoffPolicy.EXPONENTIAL
            )
            level <= 30 || thermalStatus == ThermalStatus.MODERATE -> Policy(
                audioHeartbeatIntervalSec = 45, videoFps = 5, videoBitrateKbps = 200,
                enableCamera = true, enableFec = true,
                workManagerBackoffPolicy = BackoffPolicy.LINEAR
            )
            isCharging -> Policy(
                audioHeartbeatIntervalSec = 15, videoFps = 15, videoBitrateKbps = 1500,
                enableCamera = true, enableFec = true,
                workManagerBackoffPolicy = BackoffPolicy.NO_BACKOFF
            )
            else -> Policy( // 正常电量
                audioHeartbeatIntervalSec = 30, videoFps = 10, videoBitrateKbps = 800,
                enableCamera = true, enableFec = true,
                workManagerBackoffPolicy = BackoffPolicy.LINEAR
            )
        }
    }
}