┌─────────────────────────────────────────────────────────────┐
│                    业务层：Meeting Session Manager           │
│  状态机：IDLE → JOINING → RUNNING → BACKGROUND → RESTORING  │
└─────────────────────────────────────────────────────────────┘
                              │
        ┌─────────────────────┼─────────────────────┐
        ▼                     ▼                     ▼
┌───────────────┐    ┌───────────────┐    ┌───────────────┐
│ 保活策略层     │    │ 状态持久化层   │    │ 网络/信令层    │
│ - iOS VoIP    │    │ - 本地 DB     │    │ - 长连接心跳  │
│ - Android FGS │    │ - 内存快照    │    │ - 断线重连    │
│ - 推送兜底    │    │ - 关键参数    │    │ - 弱网探测    │
└───────────────┘    └───────────────┘    └───────────────┘
        │                     │                     │
        └─────────────────────┼─────────────────────┘
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                  媒体引擎适配层                              │
│  WebRTC / 自研引擎：Track 生命周期、编解码器状态、网络质量   │
└─────────────────────────────────────────────────────────────┘

// 1. 注册 VoIP Push（iOS 13+ 必须使用 PushKit）
let voipRegistry = PKPushRegistry(queue: .main)
voipRegistry.delegate = self
voipRegistry.desiredPushTypes = [.voIP]

// 2. 收到推送 → 报告给 CallKit → 系统给 30 s 后台运行时间
func pushRegistry(_ registry: PKPushRegistry,
                  didReceiveIncomingPushWith payload: PKPushPayload,
                  for type: PKPushType,
                  completion: @escaping () -> Void) {
    let uuid = UUID()
    let update = CXCallUpdate()
    update.remoteHandle = CXHandle(type: .generic, value: "Meeting")
    update.hasVideo = true
    provider.reportNewIncomingCall(with: uuid, update: update) { error in
        // 关键：必须在 completion 前激活音频会话，否则系统会挂起
        self.activateAudioSession()
        completion()
    }
}

var bgTaskId: UIBackgroundTaskIdentifier = .invalid

func applicationDidEnterBackground(_ application: UIApplication) {
    // 1. 申请额外执行时间（约 30 s）
    bgTaskId = application.beginBackgroundTask(expirationHandler: {
        self.cleanupMediaEngine()   // 释放编解码器、Renderer
        application.endBackgroundTask(self.bgTaskId)
        self.bgTaskId = .invalid
    })

    // 2. 仅保留音频 Track + 信令 WebSocket
    mediaEngine.pauseVideoTracks()
    mediaEngine.setAudioTrackEnabled(true)   // 保持麦克风采集
    signaling.keepAliveHeartbeat(interval: 15) // 15 s 心跳

    // 3. 内存压力监听 → 主动释放非关键缓存
    NotificationCenter.default.addObserver(self,
        selector: #selector(handleMemoryWarning),
        name: UIApplication.didReceiveMemoryWarningNotification,
        object: nil)
}

// Android 14 (API 34) 必须声明 FOREGROUND_SERVICE_MEDIA_PLAYBACK
class MeetingForegroundService : Service() {
    private val notificationId = 0xMEET
    private val channelId = "meeting_ongoing"

    override fun onCreate() {
        super.onCreate()
        createNotificationChannel()
        startForeground(notificationId, buildNotification())
    }

    private fun buildNotification(): Notification {
        return NotificationCompat.Builder(this, channelId)
            .setSmallIcon(R.ic_meeting_notification)
            .setContentTitle("会议进行中")
            .setContentText("点击返回会议")
            .setOngoing(true)
            .setCategory(NotificationCompat.CATEGORY_CALL)
            .setPriority(NotificationCompat.PRIORITY_LOW) // 不抢占锁屏
            .setContentIntent(pendingIntent)
            .build()
    }
}

// 1. 精确闹钟（API 31+ 需 SCHEDULE_EXACT_ALARM 权限）
val alarmManager = getSystemService(Context.ALARM_SERVICE) as AlarmManager
val intent = Intent(this, HeartbeatReceiver::class.java)
val pendingIntent = PendingIntent.getBroadcast(this, 0, intent, FLAG_IMMUTABLE)
alarmManager.setExactAndAllowWhileIdle(
    AlarmManager.ELAPSED_REALTIME_WAKEUP,
    SystemClock.elapsedRealtime() + 15_000, // 15 s 心跳
    pendingIntent
)

// 2. 高优先级 FCM/厂商推送兜底（仅作信令唤醒，不传业务负载）
//    收到推送 → startForegroundService(Intent(this, MeetingForegroundService::class.java))

// MeetingActivity.kt
override fun onResume() {
    super.onResume()
    if (MeetingSession.getInstance().state == State.BACKGROUND) {
        MeetingSession.getInstance().restoreFromBackground()
    }
}

// MeetingSession.restoreFromBackground()
fun restoreFromBackground() {
    // 1. 停止 Foreground Service 通知
    stopForegroundService()

    // 2. 重新绑定 SurfaceView / TextureView
    mediaEngine.attachRenderer(localRenderer, remoteRenderer)

    // 3. 仅当网络类型变更时才重新协商 SDP
    if (networkTypeChanged) {
        peerConnection.restartIce()
        renegotiate()
    } else {
        // 复用既有 DTLS/SRTP 密钥，直接恢复媒体流
        mediaEngine.resumeAllTracks()
    }
    state = State.RUNNING
}

{
  "sessionId": "mtg_7x9k2p",
  "serverUrl": "wss://sfu.example.com/v1",
  "localUserId": "usr_abc",
  "mediaConfig": {
    "video": { "codec": "H264", "profile": "42e01f", "bitrateKbps": 1500, "fps": 30 },
    "audio": { "codec": "OPUS", "bitrateKbps": 32, "dtx": true, "fec": true }
  },
  "iceServers": [{"urls":["stun:stun.example.com"],"username":"","credential":""}],
  "localSDP": "v=0rno=- 123456789 2 IN IP4 127.0.0.1rn...",
  "remoteSDP": "v=0rno=- 987654321 2 IN IP4 127.0.0.1rn...",
  "iceCandidates": [
    {"candidate":"candidate:1 1 UDP 2122260223 192.168.1.5 54321 typ host","sdpMid":"0","sdpMLineIndex":0}
  ],
  "dtlsFingerprint": "SHA-256 1A:2B:3C...",
  "timestamp": 1715000000000
}

// 客户端 → 服务端：恢复会话请求
message RestoreSessionReq {
  string session_id = 1;
  string client_seq_id = 2;      // 客户端单调递增，去重用
  int64 last_server_seq = 3;     // 最后收到的服务端序列号
  NetworkInfo network_info = 4;  // 当前网络类型、IP、NAT 类型
}

// 服务端 → 客户端：增量同步
message RestoreSessionResp {
  int64 server_seq = 1;
  repeated SignalingMessage missed_messages = 2; // 补发丢失信令
  MediaStateSnapshot media_state = 3;            // 远端 Track 状态、关键帧请求
}

// webrtc/api/media_stream_track.h 扩展
enum class TrackSuspendLevel {
    kSoftSuspend,   // 仅停止 OnFrame/OnData 回调，保留 Encoder/Decoder 实例
    kHardRelease    // 销毁 Encoder/Decoder、释放硬件会话、归还 Texture/Buffer
};

class MeetingVideoTrack : public VideoTrackInterface {
public:
    // 后台切入调用
    void SuspendForBackground(TrackSuspendLevel level) {
        if (level == TrackSuspendLevel::kHardRelease) {
            encoder_factory_->ReleaseEncoder(encoder_id_);   // 归还编码器池
            decoder_factory_->ReleaseDecoder(decoder_id_);   // 归还解码器池
            hw_context_->Release();                          // 释放 Metal/Vulkan/EGL Context
            frame_buffer_pool_->Purge();                     // 归还 I420/NV12 Buffer Pool
        }
        enabled_ = false;  // 切断 Source -> Track 流向
    }

    // 前台恢复调用
    void ResumeFromBackground(TrackSuspendLevel level) {
        if (level == TrackSuspendLevel::kHardRelease) {
            encoder_id_ = encoder_factory_->CreateEncoder(codec_type_);
            decoder_id_ = decoder_factory_->CreateDecoder(codec_type_);
            hw_context_->Recreate();                         // 重建 GPU Context
        }
        enabled_ = true;
        // 关键：主动请求关键帧，避免远端等待下一个自然 I 帧（~2s）
        rtp_sender_->GetParameters().encodings[0].request_key_frame = true;
    }
};

class CodecPool {
    struct CodecEntry {
        std::unique_ptr<VideoEncoder> encoder;
        VideoCodecType codec_type;
        bool in_use = false;
        int64_t last_used_ts = 0;  // LRU 淘汰
    };
    std::array<std::vector<CodecEntry>, kMaxCodecTypes> pools_;
    std::mutex mu_;

public:
    VideoEncoder* Acquire(VideoCodecType type, const VideoEncoder::Settings& settings) {
        std::lock_guard lock(mu_);
        auto& vec = pools_[static_cast<int>(type)];
        for (auto& e : vec) {
            if (!e.in_use && e.encoder->GetScalabilityMode() == settings.scalability_mode) {
                e.in_use = true;
                e.last_used_ts = NowMs();
                return e.encoder.get();
            }
        }
        // 冷启动创建
        auto enc = encoder_factory_->CreateEncoder(type);
        enc->InitEncode(&settings, /*number_of_cores=*/2, /*max_payload_size=*/1200);
        vec.push_back({std::move(enc), type, true, NowMs()});
        return vec.back().encoder.get();
    }

    void Release(VideoEncoder* enc) {
        std::lock_guard lock(mu_);
        for (auto& vec : pools_) {
            for (auto& e : vec) {
                if (e.encoder.get() == enc) { e.in_use = false; return; }
            }
        }
    }

    // 后台内存压力回调：强制 Hard Release 所有空闲实例
    void Trim() { /* 遍历释放 in_use==false 的实例 */ }
};

// SFU 无状态节点，依赖 Redis Cluster + etcd
type MeetingState struct {
    SessionID       string            `json:"session_id"`
    Epoch           uint64            `json:"epoch"`            // 乐观锁版本
    Participants    map[string]Part   `json:"participants"`
    ActiveSpeaker   string            `json:"active_speaker"`
    RecordingStatus RecordingState    `json:"recording_status"`
    KeyRotation     KeyRotationInfo   `json:"key_rotation"`     // DTLS/SRTP 密钥轮换元数据
}

// 客户端恢复请求处理
func (s *SFUServer) HandleRestore(req *RestoreReq) (*RestoreResp, error) {
    // 1. 乐观锁获取最新状态
    state, err := s.store.GetWithVersion(req.SessionID, req.ClientEpoch)
    if err == ErrVersionConflict {
        // 客户端版本落后，全量同步
        return s.fullSync(req.SessionID)
    }
    // 2. 增量同步：仅返回 client_epoch 之后的信令事件
    missed := s.eventLog.FetchSince(req.SessionID, req.ClientEpoch)
    // 3. 补发关键帧请求给当前发言人
    if state.ActiveSpeaker != "" {
        s.signalClient.RequestKeyFrame(state.ActiveSpeaker, req.ClientID)
    }
    return &RestoreResp{State: state, MissedEvents: missed}, nil
}

Master Key (MK)  ──HKDF──▶  Epoch Key (EK_0)  ──HKDF──▶  SRTP Key / Salt (每 2^31 包轮换)
     │                         │
     │                    每 10 min 轮换一次 EK
     ▼
存储于 Secure Enclave / StrongBox (硬件隔离)

// iOS: Keychain + FileProtectionCompleteUnlessOpen
let keychainQuery: [String: Any] = [
    kSecClass as String: kSecClassGenericPassword,
    kSecAttrService as String: "meeting.session.key",
    kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly,
    kSecValueData as String: masterKeyData
]

// Android: EncryptedSharedPreferences + Jetpack Security
val masterKey = MasterKey.Builder(applicationContext)
    .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
    .build()
val sharedPrefs = EncryptedSharedPreferences.create(
    "meeting_session",
    masterKey,
    applicationContext,
    EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
    EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
)

// Android: FLAG_SECURE + 动态水印叠加
meetingSurfaceView.setSecure(true)  // 禁止截屏/录屏/投屏
// 动态水印：用户 ID + 时间戳 + 会议 ID，每帧 GPU Shader 叠加
val watermarkShader = """
    uniform sampler2D yTex, uTex, vTex;
    uniform vec2 watermarkPos;
    void main() {
        vec3 yuv = texture2D(yTex, vTexCoord).r + ...;
        if (distance(vTexCoord, watermarkPos) < 0.1) yuv = vec3(1.0, 0.0, 0.0);
        gl_FragColor = vec4(yuv, 1.0);
    }
"""

scenario: "background_survival_4h"
setup:
  - action: join_meeting
    params: {meeting_id: "auto_test_001", role: "host"}
  - action: enable_video
  - action: enable_audio
steps:
  - duration: 5m
    action: foreground_idle
  - action: press_home_key
  - duration: 10m
    action: background_idle
    assert:
      - process_alive: true
      - signaling_connected: true
      - audio_track_active: true
  - action: lock_screen
  - duration: 30m
    action: background_locked
  - action: unlock_screen
  - action: launch_app
  - assert:
      - restore_latency_p99: 800ms
      - remote_video_rendered: true
teardown:
  - action: leave_meeting

# 典型弱网模板（上行/下行独立控制）
tc qdisc add dev eth0 root handle 1: netem 
  loss 5% 25%           # 5% 随机丢包，25% 相关性（突发丢包）
  delay 80ms 20ms 15%   # 80ms 基础延迟 ±20ms 抖动
  duplicate 1%          # 1% 重复包
  reorder 10% 50%        # 10% 乱序，50% 相关性

# SFU 侧：为每个大型会议生成一路“全景缩略图”合流
def generate_thumbnail_stream(participants: List[Track]):
    # 选取音量 Top 4 + 当前发言人，合成 2x2 网格
    layout = compute_grid_layout(active_speakers=5)
    return compositor.compose(
        inputs=[p.video_track for p in participants[:5]],
        layout=layout,
        output_params=VideoParams(width=320, height=180, fps=5, bitrate=50_000)
    )

// 推流服务：Android 14+ 必须声明 FOREGROUND_SERVICE_MEDIA_PROJECTION
class LiveStreamingService : Service() {
    private var mediaProjection: MediaProjection? = null
    private var virtualDisplay: VirtualDisplay? = null
    private val encoder = HardwareEncoder() // 独占 MediaCodec

    override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
        mediaProjection = MediaProjectionManager.getMediaProjection(resultCode, data)
        virtualDisplay = mediaProjection?.createVirtualDisplay(
            "LiveSurface", width, height, density,
            DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC, // 允许后台采集
            encoder.surface, null, null
        )
        startForeground(NOTIFICATION_ID, buildLiveNotification())
        return START_STICKY
    }
}

meeting-sdk (根模块)
├── meeting-core (C++ 共享库: 信令/状态机/媒体引擎封装)
│   ├── webrtc (git submodule, 固定 commit m120)
│   ├── jsoncpp / openssl / libsrtp (静态链接)
│   └── CMakeLists.txt → libmeeting_core.a / .so
├── meeting-ios (ObjC++ 桥接层)
│   ├── MeetingEngine.mm (生命周期/推送/音频会话)
│   ├── MeetingRenderer.m (Metal/MetalKit 渲染)
│   └── MeetingSDK.podspec
├── meeting-android (JNI 桥接层)
│   ├── MeetingEngine.kt (Kotlin 协程封装)
│   ├── MeetingRenderer.kt (SurfaceView/TextureView/Compose)
│   └── build.gradle.kts (NDK toolchain, ABI filters)
├── meeting-flutter (Dart FFI 绑定)
├── meeting-react-native (TurboModule + Codegen)
└── meeting-unity (C# P/Invoke Wrapper)

// 远程配置下发示例 (Firebase Remote Config / 自建 Config Service)
{
  "background_strategy": {
    "ios": { "mode": "voip_hard_release", "heartbeat_interval_sec": 15 },
    "android": { "mode": "fgs_hard_release", "heartbeat_interval_sec": 20,
                 "exact_alarm_fallback": true },
    "memory_pressure_threshold_mb": 150,
    "enable_thumbnail_stream": true
  },
  "restore_optimization": {
    "skip_ice_restart_if_same_network": true,
    "prewarm_codec_on_foreground": true,
    "max_restore_latency_ms": 1000
  },
  "kill_switches": {
    "disable_background_video": false,
    "disable_fec_in_background": false,
    "force_full_reconnect": false
  }
}