Push-Benachrichtigungen – iOS

Push Notifications             → enabled
Background Modes               → Voice over IP (checked)
                               → Background processing (checked)

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>aps-environment</key>
    <string>development</string>
    <key>com.apple.developer.pushkit.unrestricted-voip</key>
    <true/>
</dict>
</plist>

import PushKit
import CallKit
import VonageClientSDKVoice
import AVFoundation

let config = VGClientInitConfig(loggingLevel: .info)

#if targetEnvironment(simulator)
config.enableWebsocketInvites = true
#endif

let client = VGVoiceClient(config)
client.delegate = self

AVAudioSession.sharedInstance().requestRecordPermission { granted in
    print("Microphone permission: \(granted)")
}

extension AppDelegate: PKPushRegistryDelegate {

    // Called when a new VoIP token is issued or rotated
    func pushRegistry(_ registry: PKPushRegistry,
                      didUpdate pushCredentials: PKPushCredentials,
                      for type: PKPushType) {
        guard type == .voIP else { return }
        CallManager.shared.voipTokenDidUpdate(pushCredentials.token)
    }

    // Called when the token is invalidated (e.g. app reinstall)
    func pushRegistry(_ registry: PKPushRegistry,
                      didInvalidatePushTokenFor type: PKPushType) {
        CallManager.shared.unregisterDeviceToken()
    }

    // Called when an inbound VoIP push is received
    func pushRegistry(_ registry: PKPushRegistry,
                      didReceiveIncomingPushWith payload: PKPushPayload,
                      for type: PKPushType,
                      completion: @escaping () -> Void) {
        guard type == .voIP else { completion(); return }
        CallManager.shared.handleIncomingPush(payload: payload, completion: completion)
    }
}

func restoreSessionIfNeeded() {
    guard activeSessionId == nil else {
        print("Session already active")
        return
    }

    if let jwt = UserDefaults.standard.string(forKey: "vonage_jwt") {
        // Fast path — use stored JWT directly
        createSession(jwt: jwt)
    } else if let refreshToken = storedRefreshToken {
        // Slow path — exchange refresh token for a new JWT first
        refreshJWT(refreshToken) { [weak self] newJWT in
            self?.createSession(jwt: newJWT)
        }
    } else {
        print("No credentials available for session restoration")
    }
}

private var pendingPushCompletion: (() -> Void)?

func handleIncomingPush(payload: PKPushPayload, completion: @escaping () -> Void) {

    // 1. Validate: only handle Vonage incoming-call pushes
    let pushType = VGVoiceClient.vonagePushType(payload.dictionaryPayload)
    guard pushType == .incomingCall else {
        // Must still report to CallKit — failing to do so breaks future push delivery.
        let fakeUUID = UUID()
        callProvider.reportNewIncomingCall(with: fakeUUID, update: CXCallUpdate()) { _ in
            self.callProvider.reportCall(with: fakeUUID, endedAt: .now, reason: .failed)
            completion()
        }
        return
    }

    // 2. Store completion — will be called after reportNewIncomingCall
    pendingPushCompletion = completion

    // 3a. Restore session concurrently — non-blocking
    restoreSessionIfNeeded()

    // 3b. Process the push immediately — triggers didReceiveInviteForCall
    client.processCallInvitePushData(payload.dictionaryPayload)
}

class CallManager: NSObject {

    static let shared = CallManager()

    private let callProvider: CXProvider
    private let callController = CXCallController()

    private override init() {
        let config = CXProviderConfiguration()
        config.supportsVideo            = false
        config.maximumCallGroups        = 1
        config.maximumCallsPerCallGroup = 1
        config.supportedHandleTypes     = [.generic]
        config.supportsDTMF             = true
        config.supportsHolding          = true

        callProvider = CXProvider(configuration: config)
        super.init()
        callProvider.setDelegate(self, queue: nil)
    }
}

extension CallManager: CXProviderDelegate {

    // Called when CallKit resets (e.g. during system errors or when the
    // provider is invalidated). Clean up all active call state.
    func providerDidReset(_ provider: CXProvider) {
        activeCall = nil
    }

    // User tapped Answer
    func provider(_ provider: CXProvider, perform action: CXAnswerCallAction) {
        guard let callId = activeCallId else { action.fail(); return }

        client.answer(callId) { error in
            if error == nil {
                action.fulfill()
            } else {
                action.fail()
            }
        }
    }

    // User tapped End (covers both Reject while ringing and Hang up during call)
    func provider(_ provider: CXProvider, perform action: CXEndCallAction) {
        guard let callId = activeCallId else { action.fail(); return }

        let complete: (Error?) -> Void = { error in
            error == nil ? action.fulfill() : action.fail()
        }

        if isCallRinging {
            client.reject(callId, callback: complete)
        } else {
            client.hangup(callId, callback: complete)
        }
    }

    // Mute toggle
    func provider(_ provider: CXProvider, perform action: CXSetMutedCallAction) {
        guard let callId = activeCallId else { action.fail(); return }

        if action.isMuted {
            client.mute(callId) { _ in action.fulfill() }
        } else {
            client.unmute(callId) { _ in action.fulfill() }
        }
    }

    // Hold toggle
    func provider(_ provider: CXProvider, perform action: CXSetHeldCallAction) {
        guard let callId = activeCallId else { action.fail(); return }

        if action.isOnHold {
            client.enableEarmuff(callId) { _ in action.fulfill() }
        } else {
            client.disableEarmuff(callId) { _ in action.fulfill() }
        }
    }

    // DTMF
    func provider(_ provider: CXProvider, perform action: CXPlayDTMFCallAction) {
        guard let callId = activeCallId else { action.fail(); return }
        client.sendDTMF(callId, withDigits: action.digits) { _ in action.fulfill() }
    }
}

extension CallManager: VGVoiceClientDelegate {

    func voiceClient(_ client: VGVoiceClient,
                     didReceiveInviteForCall callId: VGCallId,
                     from caller: String,
                     with type: VGVoiceChannelType) {

        guard let callUUID = UUID(uuidString: callId) else { return }

        activeCallId   = callId
        activeCallUUID = callUUID
        isCallRinging  = true

        // Report to CallKit, then call the PushKit completion in the callback
        reportIncomingCall(callUUID: callUUID, caller: caller, type: type,
                           pushCompletion: pendingPushCompletion ?? {})
        pendingPushCompletion = nil
    }

    // Remote party hung up or the call timed out
    func voiceClient(_ client: VGVoiceClient,
                     didReceiveHangupForCall callId: VGCallId,
                     withQuality callQuality: VGRTCQuality,
                     reason: VGHangupReason) {

        guard let uuid = activeCallUUID else { return }

        let cxReason: CXCallEndedReason = switch reason {
            case .remoteReject:           .declinedElsewhere
            case .remoteHangup, .localHangup: .remoteEnded
            case .remoteNoAnswerTimeout:  .unanswered
            default:                      .failed
        }

        callProvider.reportCall(with: uuid, endedAt: .now, reason: cxReason)
        cleanUpCallState()
    }

    // Caller cancelled the invite before it was answered
    func voiceClient(_ client: VGVoiceClient,
                     didReceiveInviteCancelForCall callId: VGCallId,
                     with reason: VGVoiceInviteCancelReason) {

        guard let uuid = activeCallUUID else { return }

        let cxReason: CXCallEndedReason = switch reason {
            case .answeredElsewhere: .answeredElsewhere
            case .rejectedElsewhere: .declinedElsewhere
            case .remoteCancel:      .remoteEnded
            case .remoteTimeout:     .unanswered
            default:                 .failed
        }

        callProvider.reportCall(with: uuid, endedAt: .now, reason: cxReason)
        cleanUpCallState()
    }

    private func cleanUpCallState() {
        activeCallId   = nil
        activeCallUUID = nil
        isCallRinging  = false
    }
}

// 1. Initiate the call via the SDK
func startCall(to callee: String) {
    let callContext = ["callee": callee]

    client.serverCall(callContext) { [weak self] error, callId in
        guard let callId,
              let callUUID = UUID(uuidString: callId) else { return }

        self?.activeCallId   = callId
        self?.activeCallUUID = callUUID

        // 2. Notify CallKit so the in-call UI appears
        let handle = CXHandle(type: .generic, value: callee)
        let action = CXStartCallAction(call: callUUID, handle: handle)
        let transaction = CXTransaction(action: action)

        self?.callController.request(transaction) { [weak self] error in
            guard error == nil else { return }
            self?.callProvider.reportOutgoingCall(with: callUUID, startedConnectingAt: .now)
        }
    }
}

// 3. CXStartCallAction — CallKit confirming the transaction
func provider(_ provider: CXProvider, perform action: CXStartCallAction) {
    action.fulfill()
}

// 4. When the remote side answers
func voiceClient(_ client: VGVoiceClient,
                 didReceiveLegStatusUpdateForCall callId: VGCallId,
                 withLegId legId: String,
                 andStatus status: VGLegStatus) {
    guard status == .answered, let uuid = activeCallUUID else { return }
    callProvider.reportOutgoingCall(with: uuid, connectedAt: .now)
}

func client(_ client: VGBaseClient,
            didReceiveSessionErrorWith reason: VGSessionErrorReason) {
    print("Session error: \(reason)")

    switch reason {
    case .tokenExpired:
        // The stored JWT is now invalid — skip it, use refresh token
        refreshAndRestoreSession()

    case .pingTimeout, .transportClosed:
        // Transient network issue — try the stored JWT first
        restoreSessionIfNeeded()

    default:
        restoreSessionIfNeeded()
    }
}

private func refreshAndRestoreSession() {
    guard let refreshToken = storedRefreshToken else {
        clearSession()
        return
    }
    refreshJWT(refreshToken) { [weak self] result in
        switch result {
        case .success(let newJWT):
            self?.createSession(jwt: newJWT)
        case .failure:
            self?.clearSession()
        }
    }
}

let config = VGClientInitConfig(loggingLevel: .info)

#if targetEnvironment(simulator)
config.enableWebsocketInvites = true   // receive invites over WebSocket — no push needed
#endif

let client = VGVoiceClient(config)

func answerCall(callId: String) {
#if targetEnvironment(simulator)
    client.answer(callId) { error in
        print("Answer: \(error?.localizedDescription ?? "OK")")
    }
#else
    guard let uuid = activeCallUUID else { return }
    let action = CXAnswerCallAction(call: uuid)
    callController.request(CXTransaction(action: action)) { _ in }
#endif
}

func pushRegistry(_ registry: PKPushRegistry,
                  didReceiveIncomingPushWith payload: PKPushPayload,
                  for type: PKPushType,
                  completion: @escaping () -> Void) {
    client.processCallInvitePushData(payload.dictionaryPayload)
    completion() // WRONG — called before reportNewIncomingCall
}

guard pushType == .incomingCall else {
    completion() // WRONG — no call reported to CallKit
    return
}

guard pushType == .incomingCall else {
    let fakeUUID = UUID()
    callProvider.reportNewIncomingCall(with: fakeUUID, update: CXCallUpdate()) { _ in
        self.callProvider.reportCall(with: fakeUUID, endedAt: .now, reason: .failed)
        completion()
    }
    return
}

restoreSessionIfNeeded { // Waits for network...
    self.client.processCallInvitePushData(payload) // Too late
}

restoreSessionIfNeeded()                          // Non-blocking
client.processCallInvitePushData(payload.dictionaryPayload) // Immediate

func handleIncomingPush(payload: PKPushPayload, completion: @escaping () -> Void) {
    fetchJWTFromServer { jwt in        // 500ms - 3s network call
        self.client.createSession(jwt) // Another network call
        self.client.processCallInvitePushData(payload.dictionaryPayload)
    }
}

client.registerVoipToken(token, isSandbox: true)  // Breaks TestFlight

#if DEBUG
let isSandbox = true
#else
let isSandbox = false
#endif
client.registerVoipToken(token, isSandbox: isSandbox)

func createSession(jwt: String) {
    client.createSession(jwt) { _, _ in
        self.registerVoipToken(self.storedToken) // Accumulates device entries
    }
}

func answerButtonTapped() {
    VGVoiceClient.enableAudio(AVAudioSession.sharedInstance()) // WRONG
    client.answer(callId) { _ in }
}

func provider(_ provider: CXProvider, didActivate audioSession: AVAudioSession) {
    VGVoiceClient.enableAudio(audioSession)
}
func provider(_ provider: CXProvider, didDeactivate audioSession: AVAudioSession) {
    VGVoiceClient.disableAudio(audioSession)
}