CallKit: mi ez, VoIP-keretrendszer és integráció a rendszertelefonnal

Mi az a CallKit és mire való?

CallKit — Apple keretrendszer, amelyet iOS 10-ben vezettek be, és programozási felületet biztosít a VoIP alkalmazások integrálásához a rendszertelefon alkalmazással. A CallKit megjelenése előtt minden VoIP alkalmazás a saját UI-jában jelenítette meg a bejövő hívást — a felhasználó értesítést látott az alkalmazástól, de nem tudott rendszerszinten válaszolni. A CallKit egységesíti ezt az élményt: a bejövő VoIP-hívás ugyanazokkal a vezérlőelemekkel jelenik meg, mint egy szokásos telefonhívás.

A CallKit fő célja a felhasználói élmény fragmentálódásának megszüntetése. Amikor az alkalmazás CallKit-et használ, a hívás megjelenik a zárolási képernyőn, a hívás előzményekben és a rendszer Telefon alkalmazás legutóbbi hívásai között. A felhasználó ismerős mozdulatokkal válaszolhat, elutasíthatja vagy hangpostára küldheti a hívást — anélkül, hogy gondolkodnia kellene, melyik alkalmazás dolgozza fel a hívást.

Az Apple WWDC 2023 Session „What’s new in CallKit“ szerint a felhasználók több mint 85%-a részesíti előnyben a CallKit-integrációval rendelkező alkalmazásokat azokkal szemben, amelyek saját UI-t használnak a hívásokhoz. Ennek oka — a rendszerszintű vezérlőelemek egységessége és kiszámíthatósága, amelyek nem igényelnek tanulást.

Hogyan változtatja meg a CallKit a VoIP-felhasználói élményt

CallKit nélkül a bejövő VoIP-hívás szabványos push-értesítésen keresztül érkezik. A felhasználó egy banner-t lát, rákattint, megvárja az alkalmazás megnyitását, és csak azután látja a hívás képernyőt. CallKit a PushKit-tel együtt nullára csökkenti ezt az utat: a hívás azonnal megjelenik, még akkor is, ha az alkalmazás nincs elindítva, és a rendszerfelület ezredmásodpercek alatt készen áll a válaszadásra.

• A hívás megjelenik a zárolási képernyőn és mindig látható más alkalmazások felett
• Támogatott szabványos műveletek: elfogadás, elutasítás, emlékeztető, válasz üzenettel
• Integráció a CarPlay-jel — a hívások megjelennek az autó képernyőjén
• Automatikus rögzítés a Recents-ben és a rendszer hívás előzményeiben

CallKit architektúra: CXProvider és CXCallController

A CallKit architektúra két kulcsosztály köré épül — CXProvider és CXCallController, amelyek a provider-client mintát valósítják meg. A provider a hívást a rendszer oldaláról kezeli, a client a felhasználó vagy alkalmazás nevében kezdeményez műveleteket. Ez a szétválasztás garantálja, hogy a rendszerfelület mindig konzisztens marad, még akkor is, ha az alkalmazás ideiglenesen nem elérhető.

CXProvider — hívásprovider

CXProvider — a központi objektum, amely regisztrálja az alkalmazást a CallKit-ben hívásproviderként. A CXProviderConfiguration segítségével konfigurálható, ahol megadható az alkalmazás ikonja, a támogatott hívástípusok (audio, video) és az egyidejű csoportok maximális száma. A provider műveleti kéréseket kap a rendszertől, és továbbítja azokat az alkalmazásnak a CXProviderDelegate-en keresztül.

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 — hívások kezelése

CXCallController — a kliens objektum, amelyen keresztül az alkalmazás műveleteket kér a hívásokon: indítás, befejezés, tartás, váltás. A kérések CXTransaction-n keresztül kerülnek elküldésre a CallKit-nek, amely CXAction objektumok tömbjét tartalmazza. A CallKit érvényesíti az egyes műveleteket, és végrehajtja azokat, ha az aktuális állapotban engedélyezettek.

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

CXProviderDelegate — események feldolgozása

A provider delegáltja megkapja az összes eseményt a CallKit-től. A kritikus metódus a providerDidBegin, amely jelzi, hogy a hívás elindult. A provider:performAnswerCallAction metódusban az alkalmazásnak el kell indítania egy audio munkamenetet: aktiválnia kell az AVAudioSession-t és el kell kezdenie a média átvitelét. Ha az alkalmazás nem aktiválja az audio munkamenetet korlátozott időn belül, a CallKit befejezi a hívást.

• providerDidBegin — a hívás elindult, az audio előkészíthető
• provider:performAnswerCallAction — a felhasználó válaszolt, az AVAudioSession aktiválása szükséges
• provider:performEndCallAction — a hívás befejeződött, a médiát le kell állítani
• provider:performSetMutedCallAction — mikrofon átkapcsolása

PushKit integráció CallKit-tel bejövő hívásokhoz

PushKit — kötelező komponens a bejövő VoIP-hívások CallKit-hez történő kézbesítéséhez. A szokásos push-értesítések (APNs) kiszámíthatatlan késleltetéssel rendelkeznek, és nem garantálják a kézbesítést, ha az alkalmazás háttérben fut. A PushKit állandó TCP-kapcsolatot használ az Apple szervereivel a VoIP-értesítések azonnali kézbesítéséhez, ami kritikus fontosságú a valós idejű hívásoknál.

Működési séma: a szerver VoIP-értesítést küld a PushKit-en keresztül → az alkalmazás fogadja azt a pushRegistry:didReceiveIncomingPushWithPayload-ben → az alkalmazás azonnal megjeleníti a bejövő hívást a CXProvider-en keresztül → a CallKit megjeleníti a rendszer hívás képernyőt. Minden a másodperc töredéke alatt történik, és a felhasználó a hívást a szerverre érkezéssel egy időben látja.

Az iOS 13-tól kezdve az Apple korlátozást vezetett be: a VoIP-értesítéseket csak a bejövő hívások jelzésére szabad használni. A PushKit használata háttéradatok betöltésére vagy tartalom frissítésére tilos — az ilyen alkalmazásokat a moderálás során elutasíthatják. Ez a változás kiszámíthatóbbá tette a VoIP ökoszisztémát, mivel az összes PushKit-értesítés mostantól garantáltan hívásokhoz kapcsolódik.

Példa bejövő PushKit-értesítés feldolgozására

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: számok blokkolása és azonosítása

Call Directory Extension — egy alkalmazásbővítmény, amely lehetővé teszi az alkalmazás számára, hogy számok listáit biztosítsa a rendszernek azonosításhoz (hívó nevének megjelenítése) és blokkoláshoz. A bővítmény a fő alkalmazástól függetlenül működik: a rendszer aktiváláskor betölti az adatokat a bővítményből, és minden további művelet az alkalmazás részvétele nélkül történik, ami erőforrásokat takarít meg és növeli a biztonságot.

A bővítmény CXCallDirectoryManager-t használ az adatok kezeléséhez. Az alkalmazás a fő folyamaton keresztül számokat ad hozzá a bővítmény adatbázisához, majd meghívja a reloadExtension-t a rendszer gyorsítótár frissítéséhez. Az Apple azt javasolja, hogy az adatokat óránként legfeljebb egyszer frissítsék a szükségtelen rendszerterhelés elkerülése érdekében.

Példa a Call Directory Extension megvalósítására

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 integráció példa Swift-ben

A teljes CallKit-integráció három komponens konfigurálását igényli: a provider konfigurációját, a bejövő hívások feldolgozását PushKit-en keresztül, és az audio munkamenet kezelését. Az alábbiakban egy minimális működő példa található, amely feldolgoz egy bejövő VoIP-hívást, megjeleníti azt CallKit-en keresztül, és aktiválja az audiót.

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

CallKit korlátozások és jellemzők különböző platformokon

A CallKit iOS, macOS és iPadOS rendszeren érhető el, de a keretrendszer viselkedése platformonként eltérő. iOS-en a CallKit teljes mértékben működik: rendszer hívás képernyő, zárolási képernyő, CarPlay integráció. iPadOS-en a hívás megjelenítése rendszer banner formájában történik, nem teljes képernyős felületen. macOS-en a CallKit macOS 10.14 Mojave-tól érhető el, de csak a Catalyst-tel épített vagy közvetlenül AppKit-et használó Mac alkalmazások számára.

A kulcsfontosságú korlátozás — a CallKit nem támogatott watchOS rendszeren. Az Apple Watch fejlesztői nem tudják megjeleníteni a VoIP-hívásokat a rendszerfelületen az órán. Ehelyett a watchOS alkalmazás értesítést kap a hívásról a WCSession-ön keresztül, és saját hívás képernyőt kell megvalósítania. A CallKit emellett nem működik szimulátoron — a VoIP funkciók tesztelése csak fizikai eszközön lehetséges.

CallKit összehasonlítás iOS, iPadOS és macOS rendszeren