graph TD
    A[App Server] -->|HTTP/2 + JWT| B(APNs VoIP Gateway)
    B -->|Priority=10| C[iOS Device]
    C -->|didReceiveIncomingPush| D[App Extension / Main App]
    D -->|reportNewIncomingCall| E[CallKit CXProvider]
    E -->|UI 展示| F[系统来电界面]
    F -->|用户接听| G[CXProviderDelegate performAnswerCallAction]
    G -->|激活 Audio Session| H[RTC Engine Join Channel]

{
  "aps": {
    "alert": { "title": "视频会议邀请", "body": "张三 邀请您加入会议" },
    "badge": 1,
    "sound": "call.caf",
    "content-available": 1,
    "category": "VOIP_INCOMING"
  },
  "call_id": "c_7f8a9b2c",
  "room_id": "r_123456",
  "caller": "张三",
  "media_type": "video"
}

# 伪代码：服务端推送重试策略
async def push_voip_with_retry(device_token, payload, max_retry=3):
    for attempt in range(max_retry):
        resp = await apns_client.send(
            device_token, payload,
            priority=10,
            collapse_id=f"call_{payload['call_id']}",
            expiration=int(time.time()) + 30  # 30 s 过期，避免陈旧推送唤醒
        )
        if resp.status == 200:
            return True
        await asyncio.sleep(min(2 ** attempt, 8) + random.uniform(0, 0.5))
    # 最终失败：落库离线消息，待 App 前台拉取补齐
    await offline_msg_store.save(device_token, payload)
    return False

// VoIPPushHandler.swift
final class VoIPPushHandler: NSObject, PKPushRegistryDelegate {
    private let callManager = CallManager.shared
    private let rtcEngine = RTCEngine.shared   // 单例，提前初始化核心模块

    func pushRegistry(_ registry: PKPushRegistry,
                      didReceiveIncomingPushWith payload: PKPushPayload,
                      for type: PKPushType,
                      completion: @escaping () -> Void) {
        // 1. 立即上报 CallKit，避免系统判定超时
        let uuid = UUID(uuidString: payload.dictionaryPayload["call_id"] as! String)!
        let update = CXCallUpdate()
        update.remoteHandle = CXHandle(type: .generic, value: payload.dictionaryPayload["caller"] as! String)
        update.hasVideo = (payload.dictionaryPayload["media_type"] as! String) == "video"
        update.supportsDTMF = false
        update.supportsHolding = true
        update.supportsGrouping = false
        update.supportsUngrouping = false

        callManager.provider.reportNewIncomingCall(with: uuid, update: update) { error in
            if error == nil {
                // 2. 仅在上报成功后做耗时操作：预拉取 ICE、预建立 DTLS
                self.rtcEngine.preconnect(roomId: payload.dictionaryPayload["room_id"] as! String)
            }
            completion() // 必须调用，告知系统处理完毕
        }
    }

    func pushRegistry(_ registry: PKPushRegistry,
                      didInvalidatePushTokenFor type: PKPushType) {
        // Token 失效：上报服务端更新
        TokenService.shared.registerVoIPToken(nil)
    }
}

let config = CXProviderConfiguration(localizedName: "智能会议")
config.supportsVideo = true
config.maximumCallsPerCallGroup = 1
config.maximumCallGroups = 1
config.supportedHandleTypes = [.generic]
config.iconTemplateImageData = UIImage(named: "CallKitIcon")?.pngData()
// 关键：禁用不必要的系统交互，减少状态机跳转
config.includesCallsInRecents = false
config.ringtoneSound = "ringtone.caf"

func provider(_ provider: CXProvider,
              perform action: CXAnswerCallAction) {
    // 1. 立即激活音频会话（异步，不阻塞主线程）
    try? AVAudioSession.sharedInstance().setActive(true, options: .notifyOthersOnDeactivation)

    // 2. 并行启动 RTC 加入房间
    let roomId = CallManager.shared.currentCall?.roomId ?? ""
    RTCEngine.shared.joinRoom(roomId: roomId) { [weak action] result in
        switch result {
        case .success:
            action?.fulfill() // 必须在 2 s 内调用
        case .failure(let err):
            // 3. 失败兜底：挂断并上报统计
            self.endCall(uuid: action!.callUUID, reason: .failed)
            action?.fail()
            MetricsReporter.report(event: "call_answer_failed", error: err)
        }
    }
}

// MeetingPreloader.swift
final class MeetingPreloader {
    static let shared = MeetingPreloader()
    private var preloadedTokens: [String: PreloadToken] = [:]

    func preloadUpcomingMeetings() {
        CalendarService.fetchNextMeetings(limit: 3) { meetings in
            meetings.forEach { meeting in
                // 向信令服务器申请预授权 Token，有效期 10 min
                SignalingClient.shared.requestPreauthToken(roomId: meeting.roomId) { token in
                    self.preloadedTokens[meeting.roomId] = PreloadToken(token: token, expireAt: Date().addingTimeInterval(600))
                }
            }
        }
    }

    func consumeToken(roomId: String) -> String? {
        guard let item = preloadedTokens[roomId], item.expireAt > Date() else { return nil }
        preloadedTokens.removeValue(forKey: roomId)
        return item.token
    }
}

final class MemoryPressureMonitor {
    static let shared = MemoryPressureMonitor()
    private let source = DispatchSource.makeMemoryPressureSource(eventMask: [.warning, .critical], queue: .global())
    private var currentLevel: MemoryLevel = .safe

    func start() {
        source.setEventHandler { [weak self] in
            guard let self = self else { return }
            let level = self.evaluateLevel()
            guard level != self.currentLevel else { return }
            self.currentLevel = level
            self.executePolicy(for: level)
        }
        source.resume()
    }

    private func evaluateLevel() -> MemoryLevel {
        var info = mach_task_basic_info()
        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size)/4
        let kerr = withUnsafeMutablePointer(to: &info) {
            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
                task_info(mach_task_self_, task_flavor_t(MACH_TASK_BASIC_INFO), $0, &count)
            }
        }
        let usedMB = kerr == KERN_SUCCESS ? Int(info.resident_size) / 1024 / 1024 : 0
        switch usedMB {
        case ..<120: return .safe
        case 120..<180: return .warning
        case 180..<250: return .critical
        default: return .fatal
        }
    }

    private func executePolicy(for level: MemoryLevel) {
        switch level {
        case .warning: ResourceReclaimer.reclaim(.level1)
        case .critical: ResourceReclaimer.reclaim(.level2); RTCEngine.shared.adaptBitrateForMemoryPressure()
        case .fatal: SelfEmergencyExit.trigger()
        default: break
        }
    }
}

// NetworkQualityEstimator.swift
final class NetworkQualityEstimator {
    // 滑动窗口统计最近 5 秒 RTT、丢包、带宽
    private var rttSamples: CircularBuffer<Double> = .init(capacity: 50)
    private var lossSamples: CircularBuffer<Double> = .init(capacity: 50)

    func update(rtt: Double, loss: Double) {
        rttSamples.append(rtt); lossSamples.append(loss)
        // 动态调整 CallKit answer timeout：弱网放宽至 3.5 s，强网收紧至 1.5 s
        let avgRtt = rttSamples.mean; let avgLoss = lossSamples.mean
        let dynamicTimeout = clamp(1.5 + avgRtt * 2 + avgLoss * 5, min: 1.5, max: 3.5)
        CallKitTimeoutManager.shared.updateAnswerTimeout(dynamicTimeout)
    }
}

// 利用 CXProviderConfiguration 的 timeout 值无法运行时修改的限制，
// 采用“本地倒计时 + fulfill/fail”拦截方案：
final class CallKitTimeoutManager {
    static let shared = CallKitTimeoutManager()
    private var answerTimer: Timer?
    private var currentTimeout: TimeInterval = 2.0

    func updateAnswerTimeout(_ newValue: TimeInterval) {
        currentTimeout = newValue
        // 重置正在进行的呼叫计时器
        guard let uuid = CallManager.shared.currentCallUUID else { return }
        resetTimer(for: uuid)
    }

    private func resetTimer(for uuid: UUID) {
        answerTimer?.invalidate()
        answerTimer = Timer.scheduledTimer(withTimeInterval: currentTimeout, repeats: false) { [weak self] _ in
            // 超时未 fulfill -> 主动 fail，触发系统“未接来电”UI，避免僵尸呼叫
            self?.forceFailCall(uuid: uuid, reason: .timeout)
        }
    }
}

stateDiagram-v2
    [*] --> Disconnected: 网络断开
    Disconnected --> Trying0RTT: 离线 < 30s && 有效PSK
    Disconnected --> TryingResume: 离线 < 5min && 有效ResumeToken
    Disconnected --> FullReconnect: 其他
    Trying0RTT --> Connected: 0-RTT 成功
    Trying0RTT --> TryingResume: 0-RTT 拒绝
    TryingResume --> Connected: Resume 成功
    TryingResume --> FullReconnect: Resume 失败
    FullReconnect --> Connected: 标准握手成功
    Connected --> [*]: 会话结束

// APNs Payload (加密版)
{
  "aps": { "content-available": 1, "category": "VOIP_INCOMING" },
  "enc": "AES256-GCM",
  "ct": "Base64(Ciphertext)",      // 密文：{caller_name, room_name, room_id}
  "nonce": "Base64(Nonce)",
  "tag": "Base64(AuthTag)"
}

# 服务端签名校验伪代码
def verify_voip_request(payload, signature, public_key):
    # 1. 时间戳防重放（±60 s）
    if abs(payload['ts'] - time.time()) > 60: return False
    # 2. Ed25519 签名验签
    if not ed25519_verify(public_key, payload, signature): return False
    # 3. 设备级频控：同一设备 1 min > 5 次 -> 熔断 10 min
    if rate_limiter.exceed(f"device:{payload['device_id']}", 5, 60):
        return False
    # 4. 业务级频控：同一被叫 10 min > 3 次 -> 静默丢弃
    if rate_limiter.exceed(f"callee:{payload['callee_id']}", 3, 600):
        return False
    return True

message CallSignal {
  string call_id = 1;           // 全局唯一
  string room_id = 2;
  CallType type = 3;            // AUDIO / VIDEO
  CallerInfo caller = 4;
  repeated CalleeInfo callees = 5;
  // 平台无关扩展
  map<string, string> ext = 10; // 承载 iOS: apns-collapse-id / Android: fcM_collapse_key
  // 安全
  string signature = 100;
  int64 timestamp = 101;
}

// iOS 适配器
final class iOSSignalAdapter: SignalAdapter {
    func send(signal: CallSignal, to device: DeviceProfile) async throws {
        let apnsPayload = APNsPayloadBuilder.build(signal: signal, device: device)
        try await APNsClient.shared.send(apnsPayload, to: device.voipToken)
    }
}

// Android 适配器（内部路由至 FCM / 小米 / 华为 / OPPO / vivo）
final class AndroidSignalAdapter: SignalAdapter {
    func send(signal: CallSignal, to device: DeviceProfile) async throws {
        let channel = PushChannelRouter.route(device.brand) // 策略模式
        let payload = channel.buildPayload(signal: signal)
        try await channel.push(payload, token: device.pushToken)
    }
}

// 业务层零感知调用
await SignalDispatcher.shared.dispatch(signal: callSignal, targets: callees)

# .github/workflows/voip_weaknet_regression.yml
jobs:
  weaknet-regression:
    runs-on: macos-14-xlarge  # 支持真机设备农场
    strategy:
      matrix:
        network-profile: [good, poor_3g, poor_4g, wifi_30_loss, wifi_50_loss]
        ios-version: [16.6, 17.4, 18.0]
    steps:
      - uses: actions/checkout@v4
      - name: Install Test App & Instrumentation
        run: |
          xcodebuild build-for-testing -scheme VoIPTestApp -destination 'platform=iOS,id=<UDID>'
      - name: Apply Network Profile
        run: |
          python scripts/apply_network_profile.py --profile ${{ matrix.network-profile }} --device <UDID>
      - name: Run XCUITest Suite
        run: |
          xcodebuild test-without-building 
            -scheme VoIPTestApp 
            -destination 'platform=iOS,id=<UDID>' 
            -only-testing:VoIPTestApp/WeakNetCallTests 
            -resultBundlePath results.xcresult
      - name: Parse Metrics & Gate
        run: |
          python scripts/parse_metrics.py --xcresult results.xcresult --thresholds config/thresholds.yml
          # 阈值示例：p95_wakeup_latency < 1500ms, setup_success_rate > 95%
      - name: Upload Artifacts
        uses: actions/upload-artifact@v4
        with:
          name: weaknet-report-${{ matrix.network-profile }}-${{ matrix.ios-version }}
          path: results.xcresult

func testVoIPWakeupUnder30PercentLoss() {
    // 1. 预置：App 进程挂起 5 min，内存压力模拟 200 MB
    MemoryPressureSimulator.forcePressure(.critical)
    XCUIDevice.shared.press(.home)
    sleep(300)

    // 2. 触发：服务端发送 VoIP Push (Priority 10)
    let callId = SignalingClient.sendVoIPPush(to: testDevice, priority: 10)

    // 3. 断言：系统来电界面在 2 s 内弹出
    let callUI = SpringBoard.callKitIncomingCallUI
    XCTAssertTrue(callUI.waitForExistence(timeout: 2.0), "CallKit UI 未在 2s 内弹出")

    // 4. 交互：自动点击“接听”
    callUI.buttons["Accept"].tap()

    // 5. 断言：RTC 首帧渲染在 3 s 内完成
    let preview = app.otherElements["LocalVideoPreview"]
    XCTAssertTrue(preview.waitForExistence(timeout: 3.0), "首帧渲染超时")

    // 6. 上报指标
    MetricsCollector.record(wakeupLatency: callUI.appearanceTime - pushSentTime,
                            iceConnectedLatency: preview.appearanceTime - callUI.acceptTapTime)
}