CallKit: Was es ist, das VoIP-Framework und die Integration mit dem Systemtelefon

Was ist CallKit und wofür wird es benötigt?

CallKit ist ein Apple-Framework, das mit iOS 10 eingeführt wurde und eine Programmierschnittstelle zur Integration von VoIP-Anwendungen in die Systemtelefon-App bietet. Vor CallKit zeigte jede VoIP-App eingehende Anrufe in ihrer eigenen Benutzeroberfläche an — der Benutzer sah eine Benachrichtigung von der App, konnte aber nicht auf systemische Weise antworten. CallKit vereinheitlicht diese Erfahrung: Ein eingehender VoIP-Anruf erscheint als normaler Telefonanruf mit denselben Steuerelementen.

Das Hauptziel von CallKit ist es, die Fragmentierung der Benutzererfahrung zu beseitigen. Wenn eine App CallKit verwendet, erscheint der Anruf auf dem Sperrbildschirm, im Anrufverlauf und in der Liste der letzten Anrufe der Systemtelefon-App. Der Benutzer kann mit vertrauten Gesten antworten, ablehnen oder an die Voicemail senden — ohne darüber nachzudenken, welche App den Anruf bearbeitet.

Laut der Apple WWDC 2023 Session „What’s new in CallKit“ bevorzugen über 85% der Benutzer Apps mit CallKit-Integration gegenüber solchen, die eine eigene Benutzeroberfläche für Anrufe verwenden. Der Grund ist die Einheitlichkeit und Vorhersagbarkeit der Systemsteuerungen, die kein Lernen erfordern.

Wie CallKit die VoIP-Benutzererfahrung verändert

Ohne CallKit wird ein eingehender VoIP-Anruf über eine Standard-Push-Benachrichtigung zugestellt. Der Benutzer sieht ein Banner, tippt darauf, wartet auf das Öffnen der App und sieht erst dann den Anrufbildschirm. CallKit zusammen mit PushKit reduziert diesen Weg auf Null: Der Anruf erscheint sofort, selbst wenn die App nicht ausgeführt wird, und die Systemschnittstelle ist in Millisekunden bereit für eine Antwort.

• Der Anruf erscheint auf dem Sperrbildschirm und ist immer über anderen Apps sichtbar
• Standardaktionen werden unterstützt: annehmen, ablehnen, erinnern, mit Nachricht antworten
• CarPlay-Integration — Anrufe erscheinen auf dem Fahrzeugbildschirm
• Automatische Aufzeichnung in Letzte Anrufe und im Systemanrufverlauf

CallKit-Architektur: CXProvider und CXCallController

Die CallKit-Architektur baut auf zwei Schlüsselklassen auf — CXProvider und CXCallController, die das Provider-Client-Muster implementieren. Der Provider verwaltet den Anruf auf der Systemseite, während der Client Aktionen im Namen des Benutzers oder der App initiiert. Diese Trennung stellt sicher, dass die Systemschnittstelle immer konsistent bleibt, selbst wenn die App vorübergehend nicht verfügbar ist.

CXProvider — Anrufanbieter

CXProvider ist das zentrale Objekt, das die App bei CallKit als Anrufanbieter registriert. Es wird über CXProviderConfiguration konfiguriert, wo das App-Symbol, unterstützte Anruftypen (Audio, Video) und die maximale Anzahl gleichzeitiger Gruppen angegeben werden. Der Provider empfängt Aktionsanfragen vom System und leitet sie über CXProviderDelegate an die App weiter.

let configuration = CXProviderConfiguration(localizedName: "My VoIP App")
configuration.supportedHandleTypes = [.phoneNumber, .generic]
configuration.maximumCallsPerCallGroup = 1

let provider = CXProvider(configuration: configuration)
provider.setDelegate(self, queue: .main)

CXCallController — Anrufverwaltung

CXCallController ist das Client-Objekt, über das die App Aktionen bei Anrufen anfordert: starten, beenden, halten, umschalten. Anfragen werden über CXTransaction an CallKit gesendet, das ein Array von CXAction-Objekten enthält. CallKit validiert jede Aktion und führt sie aus, wenn sie im aktuellen Zustand zulässig ist.

let controller = CXCallController()
let startCallAction = CXStartCallAction(
    callUUID: UUID(),
    handle: CXHandle(type: .phoneNumber, value: "+15551234567")
)
startCallAction.isVideo = true
controller.request(CXTransaction(action: startCallAction))

CXProviderDelegate — Ereignisbehandlung

Der Provider-Delegat empfängt alle Ereignisse von CallKit. Die kritische Methode ist providerDidBegin, die signalisiert, dass ein Anruf begonnen hat. In provider:performAnswerCallAction muss die App eine Audiositzung starten: AVAudioSession aktivieren und die Medienübertragung beginnen. Wenn die App die Audiositzung nicht innerhalb einer begrenzten Zeit aktiviert, beendet CallKit den Anruf.

• providerDidBegin — Anruf gestartet, Audio vorbereiten
• provider:performAnswerCallAction — Benutzer hat geantwortet, AVAudioSession-Aktivierung erforderlich
• provider:performEndCallAction — Anruf beendet, Medien stoppen
• provider:performSetMutedCallAction — Mikrofon umschalten

PushKit-Integration mit CallKit für eingehende Anrufe

PushKit ist eine obligatorische Komponente für die Zustellung eingehender VoIP-Anrufe an CallKit. Gewöhnliche Push-Benachrichtigungen (APNs) haben eine unvorhersehbare Latenz und garantieren keine Zustellung, wenn die App im Hintergrund läuft. PushKit verwendet eine permanente TCP-Verbindung zu Apple-Servern für die sofortige Zustellung von VoIP-Benachrichtigungen, was für Echtzeitanrufe entscheidend ist.

Ablauf: Der Server sendet eine VoIP-Benachrichtigung über PushKit → die App empfängt sie in pushRegistry:didReceiveIncomingPushWithPayload → die App zeigt sofort den eingehenden Anruf über CXProvider an → CallKit zeigt den Systemanrufbildschirm. Alles geschieht in Sekundenbruchteilen, und der Benutzer sieht den Anruf gleichzeitig mit seinem Eintreffen auf dem Server.

Ab iOS 13 führte Apple eine Einschränkung ein: VoIP-Benachrichtigungen sollten nur zur Angabe eingehender Anrufe verwendet werden. Die Verwendung von PushKit zum Laden von Hintergrunddaten oder zur Aktualisierung von Inhalten ist verboten — solche Apps können bei der Prüfung abgelehnt werden. Diese Änderung machte das VoIP-Ökosystem vorhersagbarer, da alle PushKit-Benachrichtigungen jetzt garantiert anrufbezogen sind.

Beispiel zur Verarbeitung einer eingehenden PushKit-Benachrichtigung

func pushRegistry(
    _ registry: PKPushRegistry,
    didReceiveIncomingPushWith payload: PKPushPayload,
    for type: PKPushType
) {
    let uuid = UUID()
    let update = CXCallUpdate()
    update.remoteHandle = CXHandle(
        type: .phoneNumber,
        value: payload.dictionaryPayload["caller"]
    )
    update.hasVideo = false
    
    provider.reportNewIncomingCall(with: uuid, update: update)
}

Call Directory Extension: Blockieren und Identifizieren von Nummern

Call Directory Extension ist eine App-Erweiterung, die es der App ermöglicht, dem System Listen von Nummern zur Identifizierung (Anzeige des Anrufernamens) und Blockierung bereitzustellen. Die Erweiterung arbeitet unabhängig von der Haupt-App: Das System lädt die Daten aus der Erweiterung bei der Aktivierung, und alle weiteren Vorgänge werden ohne Beteiligung der App durchgeführt, was Ressourcen spart und die Sicherheit erhöht.

Die Erweiterung verwendet CXCallDirectoryManager zur Datenverwaltung. Die App fügt über den Hauptprozess Nummern zur Datenbank der Erweiterung hinzu und ruft dann reloadExtension auf, um den Systemcache zu aktualisieren. Apple empfiehlt, Daten nicht öfter als einmal pro Stunde zu aktualisieren, um unnötige Systemlast zu vermeiden.

Implementierungsbeispiel für Call Directory Extension

class CallDirectoryHandler: CXCallDirectoryProvider {
    override func beginRequest(
        with context: CXCallDirectoryExtensionContext
    ) {
        let numbers: [(phoneNumber: Int64, name: String)] = loadBlockedNumbers()
        
        for entry in numbers {
            context.addIdentificationEntry(
                withNextSequentialPhoneNumber: entry.phoneNumber,
                label: entry.name
            )
        }
        context.completeRequest()
    }
}

CallKit-Integrationsbeispiel in Swift

Eine vollständige CallKit-Integration erfordert die Einrichtung von drei Komponenten: Provider-Konfiguration, Behandlung eingehender Anrufe über PushKit und Audiositzungsverwaltung. Nachfolgend ein minimales Arbeitsbeispiel, das einen eingehenden VoIP-Anruf bearbeitet, ihn über CallKit anzeigt und Audio aktiviert.

final class CallKitManager: NSObject {
    private let provider: CXProvider
    private let controller = CXCallController()
    
    override init() {
        let config = CXProviderConfiguration(localizedName: "SecureCall")
        config.supportedHandleTypes = [.phoneNumber]
        config.maximumCallGroups = 1
        self.provider = CXProvider(configuration: config)
        super.init()
        provider.setDelegate(self, queue: .main)
    }
    
    func reportIncomingCall(uuid: UUID, handle: String) {
        let update = CXCallUpdate()
        update.remoteHandle = CXHandle(type: .phoneNumber, value: handle)
        provider.reportNewIncomingCall(with: uuid, update: update)
    }
}

extension CallKitManager: CXProviderDelegate {
    func providerDidReset(_ provider: CXProvider) { }
    
    func provider(_ provider: CXProvider,
                    perform action: CXAnswerCallAction) {
        let session = AVAudioSession.sharedInstance()
        try? session.setCategory(.playAndRecord)
        try? session.setActive(true)
        action.fulfill()
    }
}

Einschränkungen und Funktionen von CallKit auf verschiedenen Plattformen

CallKit ist auf iOS, macOS und iPadOS verfügbar, aber das Verhalten des Frameworks unterscheidet sich zwischen den Plattformen. Unter iOS arbeitet CallKit in vollem Umfang: Systemanrufbildschirm, Sperrbildschirm, CarPlay-Integration. Unter iPadOS wird der Anruf als Systembanner statt als Vollbildschnittstelle angezeigt. Unter macOS ist CallKit seit macOS 10.14 Mojave verfügbar, jedoch nur für Mac-Apps, die mit Catalyst erstellt wurden oder AppKit direkt verwenden.

Die wichtigste Einschränkung — CallKit wird unter watchOS nicht unterstützt. Apple Watch-Entwickler können VoIP-Anrufe nicht über die Systemschnittstelle auf der Uhr anzeigen. Stattdessen erhält die watchOS-App eine Anrufbenachrichtigung über WCSession und muss einen eigenen Anrufbildschirm implementieren. Außerdem funktioniert CallKit nicht im Simulator — das Testen von VoIP-Funktionen ist nur auf einem physischen Gerät möglich.

CallKit-Vergleich unter iOS, iPadOS und macOS