In diesem Dokument wird beschrieben, wie Sie mit dem Headless Mobile SDK für iOS beginnen.
Mit dem Headless Mobile SDK for iOS können Sie CCAI Platform-basierten Support direkt in Ihre eigene integrierte iOS-Umgebung einfügen, ohne eine vorgefertigte CCAI Platform-Benutzeroberfläche zu verwenden.
Anstatt ein Widget mit CCAI Platform-Branding zu präsentieren,
Integrieren Sie das CCAI iOS SDK in Ihre App.
Erstellen Sie Ihre eigenen Bildschirme, Navigation und visuelles Design.
Mit dem SDK können Sie:
Chat- und Sprachchatsitzungen starten und verwalten
Bieten Sie E‑Mail-, geplante Anruf- und Weiterleitungsoptionen an.
Unterstützung von Smart Actions, Anhängen und Abläufen nach der Sitzung (Umfrage zur Kundenzufriedenheit, Umfragen, virtueller Kundenservicemitarbeiter).
Die CCAI Platform übernimmt die Contact Center-Logik (Weiterleitung, Warteschlangen, Kanäle, Konfiguration, Berichterstellung). Sie sind für die gesamte App verantwortlich (Benutzeroberfläche, Abläufe und Branding).
Wenn Sie lieber eine vorkonfigurierte, konfigurierbare Benutzeroberfläche verwenden möchten, anstatt eine eigene zu erstellen, verwenden Sie das Standard Mobile SDK.
Voraussetzungen
Das sind die Anforderungen für die Einbindung des Headless Mobile SDK für iOS.
Plattformanforderungen für iOS
Mindestversion von iOS: iOS 16.6 oder höher
Sprache: Swift
IDE: Die aktuelle stabile Xcode-Version, die von Ihrer App unterstützt wird
Architekturen: Standard-iOS-Architekturen, die von Ihrer aktuellen Xcode-Toolchain unterstützt werden.
App-Berechtigungen
Da Ihre integrierte App die Benutzeroberfläche für Smart Actions (Fotos aufnehmen, Videos aufzeichnen oder Identität bestätigen) verarbeitet, müssen Sie die obligatorischen Datenschutzberechtigungen von Apple deklarieren.
Fügen Sie Ihrem Info.plist die folgenden Schlüssel mit einer Beschreibung hinzu, wie Ihre App die Daten verwendet:
NSCameraUsageDescription: Erforderlich, damit Nutzer Fotos/Videos aufnehmen und senden können oder für vom Kundenservicemitarbeiter angeforderte Smart Actions.NSMicrophoneUsageDescription: Erforderlich für sofortige Sprachanrufe und für die Aufnahme von Videos mit Ton.NSPhotoLibraryUsageDescription: Erforderlich, damit Nutzer vorhandene Fotos oder Videos aus ihrer Galerie hochladen können.NSFaceIDUsageDescription: Erforderlich, wenn Sie Smart Actions mit biometrischer Bestätigung unterstützen.
Anforderungen an CCAI Platform-Instanzen
Sie benötigen Zugriff auf die Entwicklereinstellungen Ihrer CCAI Platform-Instanz, um die folgenden Details abzurufen:
Unternehmensschlüssel
Geheimcode des Unternehmens
Host-URL: Der Hostname für die CCAI-Plattform (z. B.
your_subdomain.ccaiplatform.com)
Diese Werte werden für Folgendes verwendet:
Unternehmensschlüssel + Host-URL: In Ihrer iOS-App zum Initialisieren des SDK.
Geheimer Unternehmenscode: In Ihrem Backend zum Signieren von JSON Web Tokens (JWTs), die zur Authentifizierung von Nutzern verwendet werden.
Push-Benachrichtigungen
Für Anrufe und bestimmte Smart Actions benötigen Sie:
Konfiguration des Apple Push Notification Service (APNs) für Standard-Push-Benachrichtigungen.
Ein VoIP-Dienstzertifikat zur Unterstützung eingehender Anrufe und bestimmter anrufbezogener Benachrichtigungen.
Sie werden Folgendes tun:
Konfigurieren Sie APNs- und VoIP-Anmeldedaten im Apple Entwicklerportal.
Laden Sie die konvertierten Zertifikate im Administratorportal der CCAI-Plattform unter Einstellungen > Entwicklereinstellungen > Mobile App hoch.
Registrieren Sie Ihre App für Remote-Benachrichtigungen und VoIP-Pushes.
Leiten Sie die entsprechenden Geräte-Tokens an das SDK weiter.
Aktivieren Sie unter Ziel > Signierung & Funktionen Folgendes:
Push-Benachrichtigungen
Die Funktion Hintergrundmodi ist mit den folgenden aktivierten Elementen verfügbar:
Voice-over IP: Erforderlich für VoIP-Push-Benachrichtigungen (eingehende Anrufe, Smart Actions über PSTN).
Audio, AirPlay und Bild-im-Bild: erforderlich, damit die Audioausgabe von Sprachanrufen fortgesetzt wird, wenn die App im Hintergrund ausgeführt wird.
Remote-Benachrichtigungen: Für die Standard-APNs-Push-Zustellung erforderlich.
So fügt sich das Headless iOS SDK in Ihre App ein
Das Headless Mobile SDK für iOS besteht aus drei Ebenen:
CCAI Platform und SDK
Das SDK interagiert sicher mit der CCAI Platform und bietet Folgendes:
Authentifizierung mit JSON Web Tokens (JWT).
Metadaten für das Routing von Warteschlangen und Kanälen (Chat, Sprache, geplanter Anruf, E-Mail, externe Weiterleitungslinks).
Verwaltung des Sitzungsstatus in Echtzeit.
Die sichere Transportpipeline für Smart Actions, Dateianhänge und Bildschirmfreigabe.
Ablenkungslogik und Hierarchiebewertung nach der Sitzung.
Ihre iOS-App (UI und Logik werden von Ihnen verwaltet)
Sie haben die volle Kontrolle über die Darstellung und Navigation:
Einstiegspunkte: Zum Beispiel ein Tab Hilfe oder eine Schaltfläche Kontakt.
Menüs: Wie Sie Warteschlangen präsentieren (z. B. Abrechnung, Technischer Support).
UI während der Sitzung: Ihre benutzerdefinierten Chatblasen, Anrufbildschirme und Steuerelemente.
Funktionsweise Ihrer App: Ruft SDK-APIs auf, um Sitzungen zu starten und zu beenden, wartet auf SDK-Ereignisse und steuert die Navigation des Ansichtscontrollers.
Konfiguration des CCAI Platform-Administratorportals
Ihre CCAI Platform-Administratoren konfigurieren die Regeln für die Interaktion (Betriebszeiten, verfügbare Channels, Wartezeitschwellen und Umfragen). Das SDK liest diese Konfiguration und stellt sie Ihrer App als Rohdaten und Ereignisse zur Verfügung. Sie entscheiden, wie diese Konfiguration auf dem Bildschirm dargestellt wird.
Unternehmensanmeldedaten abrufen
Bevor Sie das SDK einbinden, müssen Sie die Anmeldedaten aus Ihrer CCAI Platform-Instanz abrufen:
Melden Sie sich mit einem Administratorkonto im Administratorportal der CCAI Platform an.
Gehen Sie zu Einstellungen > Entwicklereinstellungen.
Kopieren Sie unter Unternehmensschlüssel und geheimer Code Folgendes:
Unternehmensschlüssel
Geheimcode des Unternehmens
Host-URL notieren:Der Hostname für die CCAI-Plattform (z. B.
your_subdomain.ccaiplatform.com).
Sie benötigen:
In Ihrer iOS-App: Unternehmensschlüssel + Host-URL.
Auf Ihrem Backend-Server: Geheimer Unternehmenscode zum Signieren von JWTs für:
Endnutzerauthentifizierung
Optionale benutzerdefinierte Daten oder der Kontext, die von der CCAI Platform verwendet werden.
SDK in Ihre iOS-App einbinden
Das Headless SDK basiert auf einer modularen Architektur. Sie installieren das Core-Modul CCAIKit zusammen mit den spezifischen Funktionsmodulen, die Ihre App benötigt, z. B. CCAIChat oder CCAIScreenShare.
Führen Sie die folgenden Schritte aus, um das iOS SDK in Ihre App einzubinden.
Option A: Swift Package Manager (empfohlen)
Fügen Sie der Datei
Package.swiftFolgendes hinzu:dependencies: [ .package(url: "https://github.com/UJET/ccai-ios-sdk.git", from: "3.3.1") ], targets: [ .target( name: "YourTargetName", dependencies: [ .product(name: "CCAIKit", package: "CCAIKit") ] ) ]Importieren Sie
CCAIKitin IhreAppDelegate-Datei:import CCAIKitWenn Ihr Projekt SwiftUI ist, deklarieren Sie
@UIApplicationDelegateAdaptorin IhrerApp-Struktur:@main struct YourAppName: App { @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate // ... }
Monitorloses SDK initialisieren
Initialisieren Sie das SDK beim Start der App. Aufgrund der modularen Architektur des SDK müssen Sie zuerst das CCAI-Kernsystem initialisieren und dann die spezifischen Dienstmodule (z. B. Chat oder Bildschirmfreigabe) registrieren.
Einfache Initialisierung
Das SDK verwendet eine InitOptions-Struktur, in der die gesamte erforderliche Konfiguration zusammengefasst ist:
import CCAIKit
import CCAIChat // If using Chat
import CCAIScreenShare // If using Screen Share
class AppDelegate: NSObject, UIApplicationDelegate, CCAIDelegate {
func application(
_ application: UIApplication,
didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
// 1. Configure initialization options
let options = InitOptions(
key: "YOUR_COMPANY_KEY",
urlHost: "your_subdomain.ccaiplatform.com",
delegate: self,
languageCode: "en", // ISO 639 code (defaults to "en")
cacheAuthToken: true // Whether to cache the auth token (defaults to true)
)
// 2. Initialize the core SDK
do {
try CCAI.shared.initialize(options: options)
} catch {
print("Failed to initialize CCAI: \(error.localizedDescription)")
return true
}
// 3. Initialize feature modules
// Chat minimal (no options required)
CCAI.shared.initializeChat()
// Chat with optional configuration
// let chatOptions = ChatOptions(
// delegate: webFormDelegate, // Implement to intercept and render custom web forms within your own UI
// downloadTranscriptVisibility: .hideInPostChat, // Hide the post-chat download affordance
// greeting: "Hello! How can I help you?"
// )
// CCAI.shared.initializeChat(chatOptions)
// Screen Share (optional)
// let screenShareOptions = ScreenShareOptions(
// key: "YOUR_SCREEN_SHARE_KEY",
// domain: "your_domain.com"
// )
// CCAI.shared.initializeScreenShare(screenShareOptions)
return true
}
// ... CCAIDelegate methods (Authentication) go here ...
}
InitOptions-Konfigurationsreferenz
public struct InitOptions {
/// The company key used for authentication
public let key: String
/// The host URL for CCAI platform (for example, "my-unique-instance.uc1.ccaiplatform.com")
public let urlHost: String
/// The preferred language code for localization (defaults to "en")
public var languageCode: String
/// The delegate that receives SDK events and callbacks
public weak var delegate: CCAIDelegate?
/// Whether to cache the authentication token (defaults to true)
public let cacheAuthToken: Bool
}
Verfügbare SDK-Dienste
Nach der Initialisierung können Sie über das CCAI.shared-Singleton auf verschiedene Dienste zugreifen:
let authService = CCAI.shared.authService
let companyService = CCAI.shared.companyService
let queueMenuService = CCAI.shared.queueMenuService
let optionsService = CCAI.shared.optionsService
let languageService = CCAI.shared.languageService
let pushNotificationService = CCAI.shared.pushNotificationService
let endUserService = CCAI.shared.endUserService
let chatService = CCAI.shared.chatService // Only available after initializeChat()
let screenShareService = CCAI.shared.screenShareService // Only available after initializeScreenShare()
let rateService = CCAI.shared.rateService // For CSAT ratings and survey submission
let smartActionService = CCAI.shared.smartActionService // Dedicated service for smart action lifecycle
Unternehmenskonfiguration abrufen
Rufen Sie nach der Initialisierung die Konfiguration auf Unternehmensebene mit companyService ab. Dies ist nützlich, um Sprachauswahlen zu füllen, den Namen des Unternehmens anzuzeigen oder Supportkontaktdaten zu lesen, bevor der Nutzer in eine Warteschlange gelangt.
do {
let company = try await CCAI.shared.companyService?.get()
print("Company: \(company?.displayName ?? "Unknown")")
} catch {
print("Failed to get company info: \(error)")
}
Endnutzer authentifizieren
Das Headless Mobile SDK verwendet JSON Web Tokens (JWT) zur Authentifizierung von Nutzern und zur sicheren Übertragung von Kontextinformationen an das CRM des Kundenservicemitarbeiters.
Funktionsweise
Das SDK verwendet einen optimierten asynchronen Authentifizierungsvorgang in zwei Schritten:
Das SDK stellt fest, dass der Nutzer authentifiziert werden muss.
Dabei wird die Methode
CCAIDelegate–ccaiShouldAuthenticate()– aufgerufen, die eine asynchrone Funktion ist.Ihre App signiert ein JWT remote auf Ihrem Backend-Server mit dem geheimen Code Ihres Unternehmens.
Ihre App übergibt das signierte JWT dann an
CCAI.shared.authService?.authenticate(jwt), um es gegen ein Autorisierungstoken einzutauschen.Das Authentifizierungstoken wird an das SDK zurückgegeben, um die Verbindung herzustellen.
CCAIDelegate für die Authentifizierung implementieren
Ihre App muss das CCAIDelegate-Protokoll implementieren. Das SDK ruft die einzelne asynchrone Delegatmethode auf, wenn eine Authentifizierung erforderlich ist.
CCAIDelegate-Protokoll
public protocol CCAIDelegate: AnyObject {
/// Authenticates the end user and returns an auth token
func ccaiShouldAuthenticate() async -> String?
}
Implementierungsbeispiel (Swift)
class AppDelegate: CCAIDelegate {
func ccaiShouldAuthenticate() async -> String? {
// 1. Sign JWT remotely on your backend server
guard let jwt = await signJWTRemotely() else { return nil }
// 2. Authenticate JWT using authService to get an auth token
return try? await CCAI.shared.authService?.authenticate(jwt)
}
}
Vollständiges Beispiel mit JWT-Signierung zur Referenz und zum Testen
class AuthController: CCAIDelegate {
func ccaiShouldAuthenticate() async -> String? {
var jwt = JWT(claims: claims)
// First, sign JWT with company secret (do this on your backend in production)
guard let secret = self.companySecret,
let key = secret.data(using: .utf8) else { return nil }
let signer = JWTSigner.hs384(key: key)
guard let encodedJWT = try? jwt.sign(using: signer) else { return nil }
// Then authenticate JWT using authService to get an auth token
return try? await CCAI.shared.authService?.authenticate(encodedJWT)
}
}
Benutzerdefinierte Daten an das CRM übergeben
Wenn Sie Kontextdaten an den Agenten übergeben möchten, z. B. das aktuelle Gerätebetriebssystem des Nutzers, seinen Standort oder seine Kontostufe, muss Ihr Backend vor dem Signieren ein custom_data-Objekt in die JWT-Nutzlast einfügen.
Jeder benutzerdefinierte Datensatz muss als JSON-Objekt formatiert sein, das ein label (was der Agent sieht), ein value und ein type enthält.
Unterstützte Datentypen
string: Standardtext (z. B. „iPhone 14 Pro“).number: Ganzzahlen oder Gleitkommazahlen (z. B. 1234 oder 99, 99).date: Ein 13-stelliger UTC-Unix-Zeitstempel mit Millisekunden (z. B. 1537399655992).url: Standardmäßiges HTTP-/HTTPS-URL-Format.boolean: Standardmäßiger „true“- oder „false“-Wert.
Reservierte CRM-Schlüssel
Die CCAI-Plattform unterstützt bestimmte reservierte Schlüssel, die integrierte Verhaltensweisen auf der Plattform auslösen, z. B. das Kennzeichnen eines Nutzers als VIP oder das Warnen eines Kundenservicemitarbeiters vor einem böswilligen Akteur. Diese müssen als boolesche Typen formatiert sein und werden nur akzeptiert, wenn die Nutzlast mit der sicheren JWT-Methode signiert ist.
reserved_verified_customer: Gibt an, ob ein Kunde von Ihren internen Systemen authentifiziert wurde.reserved_bad_actor: Kennzeichnet den Nutzer für den Kundenservicemitarbeiter als potenziellen Spammer oder betrügerisches Konto.reserved_repeat_customer: Gibt an, ob dieser Kunde in letzter Zeit häufig den Support kontaktiert hat.
Beispielnutzlast mit reservierten Schlüsseln
{
"iat": 1537399656,
"exp": 1537400256,
"custom_data": {
"reserved_verified_customer": {
"label": "Verified Customer",
"value": true,
"type": "boolean"
},
"reserved_bad_actor": {
"label": "Bad Actor",
"value": false,
"type": "boolean"
},
"reserved_repeat_customer": {
"label": "Repeat Customer",
"value": false,
"type": "boolean"
}
}
}
Authentifizierungstokens verwalten
Das SDK bietet auch Methoden zum manuellen Aktualisieren oder Löschen des im Cache gespeicherten Authentifizierungstokens:
// Set a new auth token
CCAI.shared.authService?.updateAuthToken("new_auth_token")
// Clear the current token (for example, on user logout)
CCAI.shared.authService?.updateAuthToken(nil)
Benutzerdefiniertes Schema für die JWT-Nutzlast
Wenn Ihr Backend die endgültige Nutzlast erstellt, die mit dem geheimen Code Ihres Unternehmens signiert werden soll, muss es sich strikt an dieses Schema halten. Beachten Sie die obligatorischen Zeitstempel iat (ausgestellt am) und exp (Ablaufdatum).
{
"iat": 1537399656,
"exp": 1537400256,
"custom_data": {
"os_version": {
"label": "OS Version",
"value": "16.4",
"type": "string"
},
"membership_tier": {
"label": "Membership Tier",
"value": "Platinum",
"type": "string"
},
"ssn_last_four": {
"label": "SSN",
"value": "1234",
"type": "string",
"invisible_to_agent": true
},
"reserved_verified_customer": {
"label": "Verified Customer",
"value": true,
"type": "boolean"
}
}
}
Push-Benachrichtigungen aktivieren
Das SDK verwendet Push-Benachrichtigungen für Folgendes:
Eingehende Anrufe
Bestimmte intelligente Aktionen und anrufrelevante Ereignisse.
Status beibehalten, wenn die App im Hintergrund ausgeführt wird
Zertifikate konfigurieren
Für die CCAI Platform sind zwei verschiedene Arten von Apple-Push-Zertifikaten erforderlich, die im Administratorportal der CCAI Platform gespeichert werden müssen:
Ein APNs-SSL-Zertifikat (Apple Push Notification Service) – wird für standardmäßige Remote-Push-Benachrichtigungen verwendet.
Ein VoIP-Dienstezertifikat, das für Benachrichtigungen über eingehende Anrufe und bestimmte anrufbezogene Smart Actions verwendet wird.
Beide Zertifikate werden im Apple Developer-Portal erstellt, in das PEM-Format konvertiert und dann in das Administratorportal der CCAI Platform hochgeladen.
APNs-SSL-Zertifikat erstellen
Folgen Sie dieser Anleitung, die auf der offiziellen Apple-Anleitung Establishing a Certificate-Based Connection to APNs basiert, um ein APNs-SSL-Zertifikat zu erstellen.
Melden Sie sich unter developer.apple.com an und rufen Sie Certificates, Identifiers & Profiles auf.
Klicken Sie auf das Pluszeichen, um ein neues Zertifikat zu erstellen.
Wählen Sie unter „Services“ die Option Apple Push Notification Service SSL (Sandbox & Production) aus.
Wählen Sie die App-ID aus, die mit dem Paket-Identifikator Ihrer Anwendung übereinstimmt, und klicken Sie dann auf Weiter.
Laden Sie eine Anfrage zur Zertifikatssignierung (Certificate Signing Request, CSR) hoch, die über die Schlüsselbundverwaltung auf Ihrem Mac generiert wurde:
Öffnen Sie Schlüsselbundverwaltung > Zertifikatsassistent > Zertifikat von einer Zertifizierungsstelle anfordern….
Geben Sie Ihre E‑Mail-Adresse ein, lassen Sie das Feld „CA Email Address“ (E‑Mail-Adresse der Zertifizierungsstelle) leer, wählen Sie Saved to disk (Auf Festplatte gespeichert) aus und klicken Sie auf Continue (Weiter).
Wählen Sie Weiter und dann Herunterladen aus, um die generierte
.cer-Datei herunterzuladen.Doppelklicken Sie auf die Datei
.cer, um sie in Ihrem Schlüsselbund zu installieren.Suchen Sie in der Schlüsselbundverwaltung das installierte Zertifikat, klicken Sie mit der rechten Maustaste darauf und wählen Sie Exportieren… aus, um es als
.p12-Datei zu speichern. Sie werden aufgefordert, ein Exportpasswort festzulegen.Konvertieren Sie die Datei
.p12mitopensslin das PEM-Format:# Extract the certificate openssl pkcs12 -in apns_certificate.p12 -out apns_cert.pem -clcerts -nokeys # Extract the private key openssl pkcs12 -in apns_certificate.p12 -out apns_key.pem -nocerts -nodes # (Optional) Combine into a single PEM file cat apns_cert.pem apns_key.pem > apns_combined.pem
Zertifikat für VoIP-Dienste erstellen
Mit VoIP-Dienstzertifikaten kann Ihre App über das PushKit-Framework von Apple Push-Benachrichtigungen mit hoher Priorität empfangen. Dadurch kann Ihre App aus einem beendeten Zustand reaktiviert werden, um eingehende Anrufe zu verarbeiten. Die aktuellen offiziellen Schritte finden Sie in der Apple Developer-Dokumentation unter Create VoIP services certificates.
Melden Sie sich unter developer.apple.com an und rufen Sie Certificates, Identifiers & Profiles auf.
Klicken Sie auf das Pluszeichen, um ein neues Zertifikat zu erstellen.
Wählen Sie unter „Dienste“ die Option VoIP Services Certificate (VoIP-Dienstezertifikat) aus.
Wählen Sie die App-ID aus, die mit dem Paket-Identifikator Ihrer Anwendung übereinstimmt, und klicken Sie dann auf Weiter.
Laden Sie dieselbe CSR hoch, die Sie für Ihr APNs-SSL-Zertifikat generiert haben, oder erstellen Sie eine neue.
Wählen Sie Weiter und dann Herunterladen aus, um die generierte
.cer-Datei herunterzuladen.Doppelklicken Sie auf die Datei
.cer, um sie in Ihrem Schlüsselbund zu installieren.Suchen Sie in der Schlüsselbundverwaltung nach dem installierten Zertifikat für VoIP-Dienste, klicken Sie mit der rechten Maustaste darauf und wählen Sie Exportieren… aus, um es als
.p12-Datei zu speichern.Konvertieren Sie die Datei
.p12mitopensslin das PEM-Format:# Extract the certificate openssl pkcs12 -in voip_certificate.p12 -out voip_cert.pem -clcerts -nokeys # Extract the private key openssl pkcs12 -in voip_certificate.p12 -out voip_key.pem -nocerts -nodes # (Optional) Combine into a single PEM file cat voip_cert.pem voip_key.pem > voip_combined.pem
Zertifikate in das Administratorportal der CCAI Platform hochladen
Melden Sie sich im Administratorportal der CCAI Platform an.
Rufen Sie Einstellungen > Entwicklereinstellungen > Mobile App auf.
Laden Sie das APNs-PEM-Zertifikat hoch.
Laden Sie das VoIP-PEM-Zertifikat hoch.
Berechtigungen für Push-Benachrichtigungen anfordern
Das SDK bietet eine praktische Methode zum Anfordern der Autorisierung für Push-Benachrichtigungen (nur iOS):
let options: UNAuthorizationOptions = [.alert, .sound]
try await CCAI.shared.pushNotificationService?.registerForPushNotifications(
options: options
) { granted in
if granted {
print("Push notifications granted")
} else {
print("Push notifications denied")
}
}
Für Remote-Benachrichtigungen registrieren
Implementieren Sie die Push-Benachrichtigungs-Delegates in Ihrer AppDelegate. Das SDK bietet pushNotificationService zum Weiterleiten von Tokens:
import CCAIKit
class AppDelegate: NSObject, UIApplicationDelegate {
func application(
_ application: UIApplication,
didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
) {
CCAI.shared.pushNotificationService?.updatePushToken(
data: deviceToken,
type: .apns
)
}
func application(
_ application: UIApplication,
didFailToRegisterForRemoteNotificationsWithError error: Error
) {
CCAI.shared.pushNotificationService?.updatePushToken(
data: nil,
type: .apns
)
}
}
Achte darauf, dass du auch Capabilities > Push notifications und Background modes für Remote-Benachrichtigungen auf dem Tab Target > Signing & capabilities in Xcode aktivierst.
Eingehende Push-Benachrichtigungen verarbeiten
Wenn Sie eine Push-Benachrichtigung erhalten, leiten Sie sie zur Verarbeitung an das SDK weiter:
func application(
_ application: UIApplication,
didReceiveRemoteNotification userInfo: [AnyHashable: Any],
fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void
) {
// Let the SDK determine if this push relates to an incoming call,
// session update, or another internal event
CCAI.shared.pushNotificationService?.handlePushNotification(userInfo)
completionHandler(.newData)
}
Das SDK ermittelt, ob sich der Push auf einen eingehenden Anruf, eine Sitzungsaktualisierung oder ein anderes internes Ereignis bezieht, und verarbeitet ihn entsprechend.
Für VoIP-Push-Benachrichtigungen registrieren
Für eingehende Anrufe und bestimmte PSTN-basierte Smart Actions ist im SDK zusätzlich zum Standard-APNs-Token ein VoIP-Push-Token erforderlich. VoIP-Push-Benachrichtigungen werden mit hoher Priorität zugestellt und können Ihre App aus einem beendeten Zustand reaktivieren.
PushKit importieren und PKPushRegistry im didFinishLaunchingWithOptions Ihres AppDelegate erstellen
import PushKit
class AppDelegate: NSObject, UIApplicationDelegate, PKPushRegistryDelegate {
func application(
_ application: UIApplication,
didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
// ... SDK initialization ...
// Register for VoIP push notifications
let voipRegistry = PKPushRegistry(queue: DispatchQueue.main)
voipRegistry.delegate = self
voipRegistry.desiredPushTypes = [.voIP]
return true
}
}
PKPushRegistryDelegate-Methoden implementieren, um VoIP-Tokens und ‑Nutzlasten an das SDK weiterzuleiten
// MARK: - PKPushRegistryDelegate
func pushRegistry(
_ registry: PKPushRegistry,
didUpdate credentials: PKPushCredentials,
for type: PKPushType
) {
// Forward the VoIP token to the SDK
CCAI.shared.pushNotificationService?.updatePushToken(
data: credentials.token,
type: .voip
)
}
func pushRegistry(
_ registry: PKPushRegistry,
didInvalidatePushTokenFor type: PKPushType
) {
// Clear the VoIP token
CCAI.shared.pushNotificationService?.updatePushToken(
data: nil,
type: .voip
)
}
func pushRegistry(
_ registry: PKPushRegistry,
didReceiveIncomingPushWith payload: PKPushPayload,
for type: PKPushType,
completion: @escaping () -> Void
) {
guard type == .voIP else {
completion()
return
}
// Forward the VoIP payload to the SDK using the `handleVoIPPush`
// extension on `CCAI` (defined in the `CCAICall` module). The SDK
// takes ownership of the call lifecycle; invoke PushKit's completion
// handler in the trailing closure after the SDK has accepted the
// payload.
CCAI.shared.handleVoIPPush(payload: payload.dictionaryPayload) { completion() }
}