// 1. 启用 Background Modes → Voice over IP / Audio, AirPlay, and Picture in Picture
// 2. 配置 PushKit 证书（VoIP 类型）并上传至 APNs
// 3. 实现 CXProviderDelegate 处理系统来电动作
class CallManager: NSObject, CXProviderDelegate {
    let provider = CXProvider(configuration: {
        let cfg = CXProviderConfiguration(localizedName: "智能会议")
        cfg.supportsVideo = true
        cfg.maximumCallsPerCallGroup = 1
        cfg.supportedHandleTypes = [.generic]
        return cfg
    }())
    
    override init() {
        super.init()
        provider.setDelegate(self, queue: nil)
    }
    
    // 关键：报告来电 → 系统唤醒 App 进入后台音频会话
    func reportIncomingCall(uuid: UUID, handle: String, hasVideo: Bool) {
        let update = CXCallUpdate()
        update.remoteHandle = CXHandle(type: .generic, value: handle)
        update.hasVideo = hasVideo
        provider.reportNewIncomingCall(with: uuid, update: update) { error in
            // 处理错误：用户拒绝、DoNotDisturb 等
        }
    }
}

// AndroidManifest.xml
<service
    android:name=".rtc.CallForegroundService"
    android:foregroundServiceType="camera|microphone|mediaPlayback"
    android:exported="false" />

// 运行时申请权限（API 34+）
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
    val perms = arrayOf(
        Manifest.permission.FOREGROUND_SERVICE_CAMERA,
        Manifest.permission.FOREGROUND_SERVICE_MICROPHONE,
        Manifest.permission.POST_NOTIFICATIONS
    )
    requestPermissions(perms, REQ_FG_PERMS)
}

// 启动前台服务
val notification = buildOngoingCallNotification()
ContextCompat.startForegroundService(context, Intent(context, CallForegroundService::class.java)
    .putExtra("notification", notification)
    .putExtra("notificationId", ONGOING_CALL_NOTIF_ID))

// 仅在无通话时注册，最小间隔 15 分钟
val heartbeatWork = PeriodicWorkRequestBuilder<HeartbeatWorker>(15, TimeUnit.MINUTES)
    .setConstraints(Constraints.Builder()
        .setRequiredNetworkType(NetworkType.CONNECTED)
        .build())
    .addTag("rtc_heartbeat")
    .build()

WorkManager.getInstance(context).enqueueUniquePeriodicWork(
    "rtc_heartbeat", ExistingPeriodicWorkPolicy.KEEP, heartbeatWork
)

val alarmMgr = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
val intent = Intent(context, AutoJoinReceiver::class.class).apply {
    action = ACTION_AUTO_JOIN
    putExtra("meetingId", meetingId)
}
val pendingIntent = PendingIntent.getBroadcast(context, 0, intent, 
    PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT)

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
    if (alarmMgr.canScheduleExactAlarms()) {
        alarmMgr.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent)
    } else {
        // 引导用户开启“闹钟与提醒”特殊权限
        startActivity(Intent(Settings.ACTION_REQUEST_SCHEDULE_EXACT_ALARM))
    }
}

// 伪代码：C++ 跨平台抽象
class BackgroundLifecycleManager {
public:
    enum class State { Foreground, BackgroundActive, BackgroundSuspended, Terminated };
    
    virtual void onCallStarted(bool hasVideo) = 0;      // 进入通话态
    virtual void onCallEnded() = 0;                     // 退出通话态
    virtual void onAppBackground() = 0;                 // App 切后台
    virtual void onAppForeground() = 0;                 // App 切前台
    virtual State getCurrentState() const = 0;
    
    // 平台无关的策略配置
    struct Policy {
        bool enableAudioOnlyBackground = true;   // 纯音频后台保活
        bool enableVideoBackground = false;      // 视频后台需审核/前台服务
        int  heartbeatIntervalSec = 30;          // 信令心跳
    };
    virtual void setPolicy(const Policy&) = 0;
};

// 伪代码：编码器策略决策引擎
class EncoderPolicyEngine {
public:
    struct Telemetry {
        float cpuUsagePercent;        // 进程 CPU 占用
        float gpuUsagePercent;        // GPU 占用（可通过 GPU Counter 采集）
        int   batteryLevel;           // 电量 %
        bool  isThermalThrottling;    // 热节流标志
        bool  isBackground;           // App 状态
        int   encoderErrorCount;      // 最近 10s 硬编错误数
    };

    enum class CodecImpl { HARDWARE, SOFTWARE, HYBRID }; // HYBRID: 关键帧硬编，P帧软编

    CodecImpl decide(const Telemetry& t) {
        if (t.isBackground) {
            // 后台优先软编规避驱动 Crash，或开启 Hybrid 模式
            if (t.encoderErrorCount > 3) return CodecImpl::SOFTWARE;
            return CodecImpl::HYBRID; 
        }
        // 前台：高分辨率/高帧率强制硬编
        if (t.cpuUsagePercent > 80 || t.isThermalThrottling) return CodecImpl::HARDWARE;
        return CodecImpl::HARDWARE;
    }
};

val format = MediaFormat.createVideoFormat("video/avc", width, height).apply {
    setInteger(MediaFormat.KEY_BIT_RATE, bitrate)
    setInteger(MediaFormat.KEY_FRAME_RATE, fps)
    setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1)
    setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaFormat.COLOR_FormatSurface) // 关键
    setInteger(MediaFormat.KEY_PRIORITY, MediaCodecInfo.EncoderCapabilities.PRIORITY_REALTIME)
}
val codec = MediaCodec.createEncoderByType("video/avc")
codec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
val inputSurface = codec.createInputSurface() // 直接给 Camera2 / SurfaceTexture 用
codec.start()

// 伪代码：基于 quiche / msquic 的连接迁移逻辑
fn on_network_change(new_path: SocketAddr, conn: &mut Connection) {
    // 1. 客户端主动探测新路径
    let probe_pkt = conn.send_path_challenge(new_path, &mut buf)?;
    socket.send_to(&buf[..probe_pkt], new_path)?;

    // 2. 服务端收到 PATH_CHALLENGE 回复 PATH_RESPONSE
    // 3. 客户端收到 RESPONSE 后，更新 conn 的默认路径
    conn.migrate(new_path, true)?; // true = abandon old path
    
    // 4. 关键：媒体流复用同一 QUIC 连接的不同 Stream，无需重新 ICE
    //    仅需在应用层发送 "path_updated" 信令通知对端更新候选对
}

# 客户端嵌入模型特征工程（TensorFlow Lite / Core ML / MNN）
features = [
    rtt_ms, rtt_var,                    # 延迟抖动
    bandwidth_kbps_ewma,                # 带宽指数加权移动平均
    loss_rate_ewma,                     # 丢包率
    signal_strength_rsrp,               # 蜂窝信号强度
    wifi_rssi, wifi_link_speed,         # WiFi 指标
    is_background,                      # App 状态
    battery_temp, cpu_freq              # 硬件约束
]
# 输出：未来 5s 预测带宽、丢包率、建议码率、是否触发迁移
prediction = model.predict(features)

# .gitlab-ci.yml 片段
stages:
  - unit
  - integration
  - chaos_nightly

chaos_nightly:
  stage: chaos_nightly
  trigger:
    schedule: "0 2 * * *" # 每天凌晨 2 点
  variables:
    SCENARIO: "background_24h_weaknet_migration"
  script:
    - python run_chaos.py --scenario $SCENARIO --devices $DEVICE_FARM_POOL
    - python analyze_report.py --threshold "call_success_rate>0.995,oom_rate<0.001"
  artifacts:
    reports:
      junit: chaos_report.xml
  only:
    - schedules

TraceID = UUID(v4) 生成于 App 发起/接听邀请时
Span 结构：
  - app_startup (client)
  - signaling_connect (client -> gateway)
  - ice_gathering (client)
  - dtls_handshake (client <-> peer/sfu)
  - media_negotiation (sdp o/a)
  - first_frame_render (client)
  - background_enter (lifecycle)
  - network_change (wifi->cellular)
  - quic_migration (transport)
  - recovery_complete (client)
  - call_end (client)