CallKit : qu'est-ce que c'est, le framework VoIP et l'intégration avec le téléphone système

Qu'est-ce que CallKit et à quoi sert-il ?

CallKit est un framework Apple présenté dans iOS 10 qui fournit une interface de programmation pour intégrer les applications VoIP avec l'application Téléphone système. Avant CallKit, chaque application VoIP affichait les appels entrants dans sa propre interface utilisateur — l'utilisateur voyait une notification de l'application mais ne pouvait pas répondre de manière systémique. CallKit unifie cette expérience : un appel VoIP entrant apparaît comme un appel téléphonique normal avec les mêmes contrôles.

L'objectif principal de CallKit est d'éliminer la fragmentation de l'expérience utilisateur. Lorsqu'une application utilise CallKit, l'appel apparaît sur l'écran de verrouillage, dans l'historique des appels et dans la liste des appels récents de l'application Téléphone système. L'utilisateur peut répondre, rejeter ou envoyer un appel à la messagerie vocale avec des gestes familiers — sans réfléchir à quelle application traite l'appel.

Selon la session Apple WWDC 2023 « What’s new in CallKit », plus de 85% des utilisateurs préfèrent les applications avec intégration CallKit à celles qui utilisent leur propre interface utilisateur pour les appels. La raison est l'uniformité et la prévisibilité des contrôles système qui ne nécessitent aucun apprentissage.

Comment CallKit change l'expérience utilisateur VoIP

Sans CallKit, un appel VoIP entrant est délivré via une notification push standard. L'utilisateur voit une bannière, tape dessus, attend l'ouverture de l'application et seulement ensuite voit l'écran d'appel. CallKit avec PushKit réduit ce chemin à zéro : l'appel apparaît instantanément, même si l'application ne s'exécute pas, et l'interface système est prête à répondre en millisecondes.

• L'appel apparaît sur l'écran de verrouillage et est toujours visible au-dessus des autres applications
• Les actions standard sont prises en charge : répondre, rejeter, rappeler, répondre par message
• Intégration CarPlay — les appels apparaissent sur l'écran de la voiture
• Enregistrement automatique dans Récents et dans l'historique des appels système

Architecture de CallKit : CXProvider et CXCallController

L'architecture de CallKit est construite autour de deux classes clés — CXProvider et CXCallController, qui implémentent le modèle fournisseur-client. Le fournisseur gère l'appel côté système, tandis que le client initie des actions au nom de l'utilisateur ou de l'application. Cette séparation garantit que l'interface système reste toujours cohérente, même si l'application est temporairement indisponible.

CXProvider — fournisseur d'appels

CXProvider est l'objet central qui enregistre l'application dans CallKit en tant que fournisseur d'appels. Il est configuré via CXProviderConfiguration, où sont spécifiés l'icône de l'application, les types d'appels pris en charge (audio, vidéo) et le nombre maximum de groupes simultanés. Le fournisseur reçoit les demandes d'actions du système et les transmet à l'application via CXProviderDelegate.

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 — gestion des appels

CXCallController est l'objet client par lequel l'application demande des actions sur les appels : démarrer, terminer, mettre en attente, basculer. Les demandes sont envoyées à CallKit via CXTransaction, qui contient un tableau d'objets CXAction. CallKit valide chaque action et l'exécute si elle est autorisée dans l'état actuel.

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

CXProviderDelegate — gestion des événements

Le délégué du fournisseur reçoit tous les événements de CallKit. La méthode critique est providerDidBegin, qui signale qu'un appel a commencé. Dans provider:performAnswerCallAction, l'application doit démarrer une session audio : activer AVAudioSession et commencer la transmission des médias. Si l'application n'active pas la session audio dans un temps limité, CallKit terminera l'appel.

• providerDidBegin — appel démarré, préparer l'audio
• provider:performAnswerCallAction — utilisateur a répondu, activation AVAudioSession requise
• provider:performEndCallAction — appel terminé, arrêter les médias
• provider:performSetMutedCallAction — basculer le microphone

Intégration de PushKit avec CallKit pour les appels entrants

PushKit est un composant obligatoire pour la livraison des appels VoIP entrants à CallKit. Les notifications push standard (APNs) ont une latence imprévisible et ne garantissent pas la livraison si l'application est en arrière-plan. PushKit utilise une connexion TCP persistante avec les serveurs Apple pour une livraison instantanée des notifications VoIP, ce qui est critique pour les appels en temps réel.

Flux de travail : le serveur envoie une notification VoIP via PushKit → l'application la reçoit dans pushRegistry:didReceiveIncomingPushWithPayload → l'application affiche immédiatement l'appel entrant via CXProvider → CallKit montre l'écran d'appel système. Tout se produit en fractions de seconde, et l'utilisateur voit l'appel au même moment qu'il arrive sur le serveur.

À partir d'iOS 13, Apple a introduit une restriction : les notifications VoIP doivent être utilisées uniquement pour indiquer les appels entrants. L'utilisation de PushKit pour le chargement de données en arrière-plan ou la mise à jour de contenu est interdite — ces applications peuvent être rejetées lors de la modération. Ce changement a rendu l'écosystème VoIP plus prévisible, car toutes les notifications PushKit sont maintenant garanties d'être liées à des appels.

Exemple de traitement d'une notification PushKit entrante

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 : blocage et identification des numéros

Call Directory Extension est une extension d'application qui permet à l'application de fournir au système des listes de numéros pour l'identification (affichage du nom de l'appelant) et le blocage. L'extension fonctionne indépendamment de l'application principale : le système charge les données de l'extension lors de l'activation, et toutes les opérations ultérieures sont effectuées sans la participation de l'application, économisant des ressources et améliorant la sécurité.

L'extension utilise CXCallDirectoryManager pour gérer les données. L'application via le processus principal ajoute des numéros à la base de données de l'extension, puis appelle reloadExtension pour mettre à jour le cache système. Apple recommande de ne pas mettre à jour les données plus d'une fois par heure pour éviter une charge inutile sur le système.

Exemple d'implémentation de 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()
    }
}

Exemple d'intégration de CallKit en Swift

L'intégration complète de CallKit nécessite la configuration de trois composants : configuration du fournisseur, gestion des appels entrants via PushKit et gestion de la session audio. Ci-dessous un exemple fonctionnel minimal qui traite un appel VoIP entrant, l'affiche via CallKit et active l'audio.

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()
    }
}

Limitations et fonctionnalités de CallKit sur différentes plateformes

CallKit est disponible sur iOS, macOS et iPadOS, mais le comportement du framework diffère selon les plateformes. Sur iOS, CallKit fonctionne complètement : écran d'appel système, écran de verrouillage, intégration CarPlay. Sur iPadOS, l'appel est affiché comme une bannière système plutôt qu'une interface plein écran. Sur macOS, CallKit est disponible depuis macOS 10.14 Mojave, mais uniquement pour les applications Mac compilées avec Catalyst ou utilisant AppKit directement.

La limitation principale — CallKit n'est pas pris en charge sur watchOS. Les développeurs Apple Watch ne peuvent pas afficher les appels VoIP via l'interface système sur la montre. Au lieu de cela, l'application watchOS reçoit une notification d'appel via WCSession et doit implémenter son propre écran d'appel. De plus, CallKit ne fonctionne pas sur le simulateur — les tests des fonctionnalités VoIP ne sont possibles que sur un périphérique physique.

Comparaison de CallKit sur iOS, iPadOS et macOS