In diesem Dokument wird beschrieben, wie Sie das Headless Mobile SDK in Ihre Android-App einbinden und anpassen. Es umfasst alles, was Ihren Support-Sitzungen strukturierte Informationen hinzufügt: Smart Actions vor der Sitzung zur Erfassung von Kontext, Smart Actions in der Sitzung, die von Kundenservicemitarbeitern ausgelöst werden (einschließlich biometrischer Bestätigung mit LocalAuthentication), Web- und benutzerdefinierte Formulare, von Verbrauchern und Kundenservicemitarbeitern initiierte Anhänge sowie die Bearbeitung von Anfragen außerhalb der Geschäftszeiten und bei Überlastung.
Smarte Aktionen und Anhänge konfigurieren
Mit Smart Actions können Kundenservicemitarbeiter und Kunden strukturierte Informationen wie Fotos, Videos, Textausschnitte und biometrische Bestätigungen (Face ID und Touch ID) austauschen.
In der Headless-Architektur fungiert das SDK ausschließlich als sichere Transportschicht. Sie informiert Sie, wenn eine Aktion erforderlich oder angefordert wird, und überträgt die Daten sicher an die Google Cloud Projektplattform. Da Sie die Benutzeroberfläche besitzen, ist Ihre App vollständig für das Rendern der Kamerabildschirme, der Fotoauswahl, der Textfelder und das Auslösen der Face ID-Aufforderungen von Apple verantwortlich.
Intelligente Aktionen vor der Sitzung
Bei Aktionen vor der Sitzung werden Kontextinformationen (z. B. eine Kontonummer oder ein Video eines defekten Produkts) erfasst, bevor der Nutzer der Warteschlange beitritt. So wird die Bearbeitungszeit für Kundenservicemitarbeiter erheblich verkürzt.
Was das SDK bietet: Die Regeln und Anforderungen für eine bestimmte Warteschlange, z. B. ob eine biometrische Bestätigung, ein Foto-Upload oder eine Texteingabe vor dem Beitreten optional oder obligatorisch ist.
Was Sie entwickeln: Die UI-Bildschirme vor der Sitzung (Kamera, Texteingabe und Aufforderungen zur Face ID), die angezeigt werden, wenn der Nutzer auf eine Warteschlange tippt und den Warteraum betritt, sowie die Logik für das Zwischenspeichern auf der Festplatte, um Medien sicher zu speichern, bis die Verbindung zur Sitzung hergestellt wird.
Implementierungsbeispiel
Mit diesem Code wird die SDK-Konfiguration geprüft, um festzustellen, ob für die ausgewählte Warteschlange Anforderungen vor der Sitzung gelten. Darin wird gezeigt, wie eine Videoanforderung behandelt wird, indem eine Dateipfadreferenz auf der Festplatte gespeichert wird, anstatt das Video im Arbeitsspeicher zu behalten.
// 1. Check requirements and collect data BEFORE joining the queue
func checkPreSessionRequirements(for menu: QueueMenu) {
guard let smartActions = menu.settings else {
startChat(for: menu)
return
}
// Example: handle a video requirement
presentVideoPicker { (localFileURL) in
// IMPORTANT: localFileURL should point to NSTemporaryDirectory()
MySessionStateManager.shared.pendingPreSessionVideo = localFileURL
self.startChat(for: menu)
}
}
// 2. Upload and clean up AFTER the session officially connects
func handleSessionConnected() {
guard let pendingVideoURL = MySessionStateManager.shared.pendingPreSessionVideo else { return }
// Upload using the standard in-session pipeline
// then clean up the temporary file
try? FileManager.default.removeItem(at: pendingVideoURL)
MySessionStateManager.shared.pendingPreSessionVideo = nil
}
Konfiguration der Smart Actions vor der Sitzung wird gelesen
Das SDK bietet die Möglichkeit, Smart Actions vor der Sitzung über zwei sich ergänzende Wege zu konfigurieren. Prüfen Sie beide, um festzustellen, ob für eine bestimmte Warteschlange und einen bestimmten Channel eine Erfassung vor der Sitzung erforderlich ist.
Pfad A – Warteschlangenebene (QueueMenu.settings[].sdk.preSessionSmartAction):
public struct QueueMenuSetting: Decodable {
public let sdk: QueueMenuSDKSetting?
// ... other fields ...
}
public struct QueueMenuSDKSetting: Decodable {
public let preSessionSmartAction: Bool?
// ... other fields ...
}
// Usage - "does any queue-level setting require a pre-session smart action?"
func queueRequiresPreSession(_ menu: QueueMenu) -> Bool {
return menu.settings?.contains { $0.sdk?.preSessionSmartAction == true } ?? false
}
Pfad B – auf Kanalebene (VoiceCallChannel.preSessionSmartAction):
// Usage - "does the voice channel specifically require pre-session capture?"
let requiresPreSessionOnVoice =
menu.channels?.voiceCall?.preSessionSmartAction == true
Mit Pfad A können Sie festlegen, ob ein Pre-Session-Gate bevor der Nutzer einen Channel auswählt angezeigt werden soll. Verwenden Sie Pfad B für channelspezifische Optimierungen nach der Auswahl eines Channels, z. B. nur Aufforderungen vor einem sofortigen Sprachanruf.
Intelligente Aktionen während der Sitzung (vom Kundenservicemitarbeiter initiiert)
Während eines aktiven Chats oder Sprachanrufs kann ein Kundenservicemitarbeiter auf seinem Dashboard eine Schaltfläche auswählen, um Daten vom Nutzer anzufordern, z. B. „Senden Sie ein Foto Ihres Ausweises“ oder „Authentifizieren Sie sich mit Face ID“.
Was das SDK bietet: Echtzeitereignisse, die Ihre App darüber informieren, dass der Agent eine bestimmte Art von Smart Action angefordert hat.
Was Sie entwickeln: Eine Benachrichtigung im Chat oder Anruf, die den Nutzer über die Anfrage informiert, das entsprechende integrierte Tool (Kamera, Fotogalerie, Textfeld oder Face ID) startet und das Ergebnis an das SDK zurückgibt.
Implementierungsbeispiel
Hier wartet Ihre App auf SDK-Ereignisse. Wenn eine Anfrage eines KI-Agents erkannt wird, wird eine Benachrichtigung angezeigt und das entsprechende iOS-Tool wird geöffnet.
// Listen for Smart Action requests from the active SDK session.
//
// `SmartActionType` exposes the following cases: `.photo`, `.video`,
// `.screenshot`, `.text`, `.verification`, `.screenShare`, `.unknown`.
// Use `.verification` (not `.biometric`) for Face ID / Touch ID flows -
// there is no `.biometric` case on the enum.
func handleSmartActionRequest(_ request: SmartActionRequest) {
switch request.type {
case .photo:
promptUserForPhoto(message: "The agent requested a photo.") { capturedImage in
// Send the image back to the agent using the SDK
self.sendAttachment(image: capturedImage)
}
case .video:
// Agent-requested video capture. Reuse the same disk-caching pattern
// recommended for pre-session media - keep the recording on disk and
// pass the file URL to the SDK rather than holding the raw `Data` in
// memory.
promptUserForVideo(message: "The agent requested a video.") { capturedVideoURL in
self.sendAttachment(videoURL: capturedVideoURL)
}
case .screenshot:
// The SDK exposes `.screenshot` as a distinct request type - the user
// captures (or selects) a single still image of the current screen.
// This is **not** the same as the following `.screenShare` case, which starts a
// live co-browse session.
promptUserForScreenshot(message: "The agent requested a screenshot.") { capturedImage in
self.sendAttachment(image: capturedImage)
}
case .verification:
// Use Face ID / Touch ID using LocalAuthentication. The SDK exposes
// this case as `.verification`; there is no `.biometric` case on
// `SmartActionType`.
performAppleBiometricAuth { success in
self.sendBiometricResult(success: success)
}
case .text:
presentTextInputPrompt(message: "The agent requested text input.") { text in
self.sendSmartActionText(text)
}
case .screenShare:
// Hand off to the full screen share flow (see Headless Mobile SDK for iOS: Voice, Screen Share, Scheduled Call, and Email).
// Don't confuse this with `.screenshot` described earlier - `.screenShare` starts a
// live co-browse session using `CCAIScreenShare`, while `.screenshot`
// captures a single still frame.
startScreenShareFlow()
case .unknown:
// Future-proof: a smart action type the SDK doesn't recognize.
// Log and continue - don't block the user.
print("CCAI: received unknown smart action type")
@unknown default:
// Defensive: handle any cases added to `SmartActionType` in future
// SDK releases.
break
}
}
Benachrichtigungen und Tracking von Smart Actions
Verwende smartActionService, um intelligente Aktionen zu bestätigen und zu aktualisieren, während der Nutzer sie durchläuft.
let router = CommunicationRouter(id: chatId, type: .chat)
// Notify the server that a smart action has been received
do {
try await CCAI.shared.smartActionService?.notifySmartActionReceived(
router: router,
smartActionId: smartActionId
)
print("Smart action notification sent successfully")
} catch {
print("Failed to notify smart action: \(error)")
}
// Update the smart action status as the user completes it
do {
try await CCAI.shared.smartActionService?.updateSmartActionStatus(
router: router,
smartActionId: smartActionId,
status: .finished
)
print("Smart action status updated successfully")
} catch {
print("Failed to update smart action status: \(error)")
}
Wenn für die Aktion eine Texteingabe erforderlich ist, erfassen Sie den Text in Ihrer Benutzeroberfläche und senden Sie ihn über den Smart-Action-Dienst, bevor Sie die Aktion als abgeschlossen markieren.
Webformulare
Funktionen des SDK: APIs zum Abrufen, Anzeigen und Validieren von Webformularen, die von Kundenservicemitarbeitern während einer Chatsitzung ausgelöst werden.
Was Sie entwickeln: Die Benutzeroberfläche zum Rendern des Webformulars und der Übermittlungsvorgang, der die Antworten des Nutzers zusammenfasst.
Implementierungsbeispiel
Mit diesem Code wird ein Webformular anhand seiner Smart-Action-ID und externen Formular-ID abgerufen. Anschließend wird die Antwort vor der Einreichung validiert.
// Fetch a web form - WebFormRequest has no `signature` parameter on iOS
let webFormRequest = WebFormRequest(
smartActionId: 123,
externalFormId: "form123"
)
do {
let webFormResponse = try await CCAI.shared.chatService?.fetchWebForm(webFormRequest)
if let response = webFormResponse {
print("Web form received: \(response)")
}
} catch {
print("Failed to fetch web form: \(error)")
}
// Validate a web form response
do {
let isValid = try await CCAI.shared.chatService?.validateWebForm(webFormResponse)
if isValid == true {
print("Web form is valid")
} else {
print("Web form validation failed")
}
} catch {
print("Failed to validate web form: \(error)")
}
Die vollständigen Definitionen der WebFormResponse-, FormPayload- und WebFormData-Strukturen finden Sie in der Headless Mobile SDK – iOS API Reference.
Benutzerdefinierte Formulare
Funktionen des SDK: APIs zum Abrufen konfigurierbarer Formulardefinitionen (mit mehreren Fragetypen) und zum Senden der Antworten des Nutzers.
Was Sie erstellen: Eine dynamische Benutzeroberfläche für Formulare, in der jeder Fragetyp (z. B. Textfelder und Drop-down-Menüs) gerendert wird, Eingaben validiert werden und Antworten für die Übermittlung erfasst werden.
Implementierungsbeispiel
Mit diesem Code werden die Fragedefinitionen eines benutzerdefinierten Formulars abgerufen und die Antworten des Nutzers werden verpackt und gesendet.
// Retrieve custom form details
do {
let form = CustomForm(
id: 123,
name: nil,
title: nil,
subtitle: nil,
smartActionId: nil,
image: nil,
header: nil,
footer: nil
)
let formDetails = try await CCAI.shared.chatService?.getCustomFormDetails(form)
if let details = formDetails {
print("Form Title: \(details.title ?? "No title")")
print("Questions: \(details.questions.count)")
}
} catch {
print("Failed to get custom form details: \(error)")
}
// Submit a custom form
let request = SubmitCustomFormRequest(
smartActionId: 123,
formResponse: [
SubmitCustomFormRequest.Answer(questionId: 1, value: "John Doe"),
SubmitCustomFormRequest.Answer(questionId: 2, value: "john@example.com")
]
)
do {
try await CCAI.shared.chatService?.submitCustomForm(request: request)
print("Form submitted successfully")
} catch {
print("Failed to submit form: \(error)")
}
Die vollständigen Enum-Definitionen für CustomFormDetailsResponse, CustomFormQuestion, CustomFormQuestionOption und CustomFormQuestionType finden Sie in der Headless Mobile SDK – iOS API Reference.
Von Verbrauchern initiierte Anhänge (Chat)
Nutzer müssen nicht warten, bis ein Kundenservicemitarbeiter sie dazu auffordert, sondern können während eines Chats proaktiv Bilder und Videos senden. Das SDK erzwingt strenge Dateigrößenbeschränkungen und versucht automatisch, die Datei vor der Übertragung zu komprimieren.
Größenbeschränkungen für Anhänge
Bilder: ≤ 2 MB
Videos: ≤ 20 MB
Funktionen des SDK: Eine sichere Upload-Pipeline, die die Netzwerkübertragung übernimmt und Dateien automatisch komprimiert, um die Grenzwerte des Google Cloud -Projekts einzuhalten.
Was Sie entwickeln: Die Büroklammer / der Button für Anhänge in der Chatoberfläche, die Foto- / Videoauswahl und die visuelle Chatblase mit dem Uploadstatus (wird geladen, gesendet oder fehlgeschlagen).
Implementierungsbeispiel
Wenn ein Nutzer ein Foto oder Video aus seinen Aufnahmen auswählt, konvertieren Sie es in Data (für Bilder) oder rufen Sie die lokale Datei-URL ab (für Videos). Übergeben Sie es dann mit derselben sendMessage-API, die für alle ausgehenden Nachrichten verwendet wird, an das SDK (siehe Abschnitt Nachrichten senden im Headless Mobile SDK for iOS: Queues, channels, and chat). Das SDK übernimmt die Komprimierung und den Upload.
import PhotosUI
// Called when the user picks an image from their photo library
func userDidSelectImage(_ image: UIImage) {
guard let imageData = image.jpegData(compressionQuality: 0.8) else { return }
// Show a loading bubble in your custom chat UI
let messageBubble = myChatUI.addLoadingImageBubble()
Task {
do {
// Wrap the raw data in an UploadableImage
let uploadableImage = UploadableImage(data: imageData, mimeType: "image/jpeg")
// Pass to the SDK - compression and upload are handled automatically
try await CCAI.shared.chatService?.sendMessage(
.images(images: [uploadableImage], smartAction: nil)
)
messageBubble.markAsSent()
} catch {
// The SDK returns an error if the file exceeds limits even after compression
messageBubble.showError("Failed to send: \(error.localizedDescription)")
}
}
}
// Called when the user picks a video from their photo library
func userDidSelectVideo(at localURL: URL) {
let messageBubble = myChatUI.addLoadingVideoBubble()
Task {
do {
let uploadableVideo = UploadableVideo(url: localURL, mimeType: "video/mp4")
try await CCAI.shared.chatService?.sendMessage(
.videos(videos: [uploadableVideo], smartAction: nil)
)
messageBubble.markAsSent()
} catch {
messageBubble.showError("Failed to send: \(error.localizedDescription)")
}
}
}
Von Kundenservicemitarbeitern initiierte Anhänge (Chat)
KI‑Agenten können Dateien an den Nutzer zurücksenden, darunter Bilder, Videos, Audioclips und Dokumente (PDFs, CSVs usw.).
Unterstützte Dateitypen
Auf der Google Cloud Projektplattform werden 19 Dateitypen in vier Kategorien akzeptiert. Ihre benutzerdefinierte Benutzeroberfläche sollte jede Kategorie angemessen verarbeiten (Bildvorschau, Videoplayer, Audioplayer, Dokumentdownload).
| Kategorie | Unterstützte Typen |
|---|---|
| Bilder | JPEG, PNG, GIF und WebP. |
| Video | MP4, MOV, AVI, WMV und WebM. |
| Audio | MP3, WAV, M4A und WEBA |
| Dokumente | PDF, DOC, XLS, PPT, CSV und TXT. |
Funktionen des SDK: Nutzlasten für eingehende Chatnachrichten (über den messagesReceived-Publisher bereitgestellt – siehe Abschnitt Reaktive Muster mit Combine im Headless Mobile SDK for iOS: Post-session and advanced topics), die Metadaten für Anhänge enthalten. Der Chatdienst bietet auch downloadMedia, um vom Agenten gesendete Medien sicher abzurufen.)
Was Sie entwickeln: Die Benutzeroberfläche zum Rendern dieser Anhänge im Chatfeed. Ihre App entscheidet, ob Bildvorschauen, Videothumbnails, Steuerelemente für die Audiowiedergabe oder Schaltflächen zum Herunterladen von Dokumenten angezeigt werden.
Implementierungsbeispiel
Abonnieren Sie eingehende Nachrichten mit messagesReceived. Wenn eine neue Nachricht Medienmetadaten enthält, rufen Sie downloadMedia auf, bevor Sie die Datei rendern oder öffnen.
downloadMedia gibt DownloadMediaResponse { data: Data, fileName: String?
} zurück – die vollständig heruntergeladenen Byte plus ein optionaler Anzeigename für die Datei. Das SDK speichert Downloads nicht im Cache. Wenn die Benutzeroberfläche zu einer älteren Blase zurückscrollt oder die Chatansicht wieder aufgerufen wird, ist Ihre App dafür verantwortlich, das decodierte Bild zu speichern oder die Bytes beizubehalten. Wenn downloadMedia noch einmal aufgerufen wird, wird ein weiterer Netzwerkabruf ausgelöst.
import Combine
private var cancellables = Set<AnyCancellable>()
CCAI.shared.chatService?.messagesReceived
.receive(on: DispatchQueue.main)
.sink { [weak self] messages in
for message in messages {
self?.renderIncomingMessage(message)
}
}
.store(in: &cancellables)
func renderIncomingMessage(_ message: ChatMessage) {
guard let media = message.media else {
myChatUI.insertTextBubble(text: message.text)
return
}
Task {
do {
// `downloadMedia` returns the raw bytes plus an optional filename.
// First arg is unlabeled.
let response = try await CCAI.shared.chatService?.downloadMedia(
media.id,
mediaType: media.type
)
guard let response else { return }
await MainActor.run {
switch media.type {
case .photo:
// Decode in-memory - no disk write needed.
if let image = UIImage(data: response.data) {
myChatUI.insertImageBubble(
image: image,
fileName: response.fileName
)
}
case .video, .audio, .document:
// Larger media usually needs an on-disk URL for AVPlayer
// or QLPreviewController. Write to the temp directory
// yourself and hand the resulting URL to your UI helper.
let url = FileManager.default
.temporaryDirectory
.appendingPathComponent(response.fileName ?? "attachment")
try? response.data.write(to: url)
myChatUI.insertAttachmentBubble(
fileURL: url,
mediaType: media.type
)
}
}
} catch {
await MainActor.run {
myChatUI.insertAttachmentErrorBubble(fileName: message.media?.name)
}
}
}
}
Die genauen Metadatentypen für Chatnachrichten und Medien finden Sie in der Headless Mobile SDK – iOS API-Referenz.
Anrufumleitung (außerhalb der Geschäftszeiten und bei Überlastung)
Die Weiterleitung ist eine wichtige Contact Center-Funktion, mit der Nutzer weitergeleitet werden, wenn Ihr Supportteam nicht verfügbar ist. Das passiert in der Regel in zwei Szenarien:
Außerhalb der Geschäftszeiten: Der Nutzer versucht, den Support außerhalb Ihrer konfigurierten Öffnungszeiten zu kontaktieren.
Überkapazität: Die Warteschlange ist geöffnet, aber die Wartezeit überschreitet den von Ihren Administratoren festgelegten maximalen Grenzwert.
In einer Headless-Architektur blockiert das SDK den Nutzer nicht automatisch und es wird auch kein Fehlerbildschirm eingeblendet. Stattdessen wird der Umleitungsstatus und die vom Administrator konfigurierten Fallback-Optionen im Hintergrund an Ihre App übergeben. Ihre App muss diesen Status prüfen, bevor sie versucht, eine Sitzung zu starten.
Umgang mit Umleitungsstatus
Was das SDK bietet: Eine deflectionFrom: [QueueMenuDeflection]? auf QueueMenu, in der die Regeln für die eingehende Umleitung aufgeführt sind, mit denen andere Warteschlangen in diese umgeleitet werden. Jedes QueueMenuDeflection enthält nur zwei Felder:
deflectionType: DeflectionType?: die Kategorie der Umleitung (z. B. „außerhalb der Geschäftszeiten“ oder „überlastet“).menuId: Int?: die ID der Quellwarteschlange, aus der Anfragen in diese Warteschlange umgeleitet werden.
QueueMenuDeflection enthält keine Hinweismeldung oder ein für Menschen lesbares Label.
Bei nutzerorientiertem Text durchlaufen Sie das settings-Array selbst oder greifen auf Ihre eigenen vom Administrator konfigurierten Strings zurück. Verwenden Sie für den Anzeigenamen der aufgelösten Quellwarteschlange die Erweiterung findMenu(byId:) für [QueueMenu], um ihn in Ihrem bereits abgerufenen Menübaum zu suchen.
Was Sie entwickeln: Die Logik zum Prüfen dieser Umleitungsstatus, bevor ein Nutzer in eine Warteschlange gestellt wird, und die benutzerdefinierte Benutzeroberfläche (z. B. eine Vollbildwarnung oder ein Banner), auf der die entsprechende Meldung und alternative Weiterleitungs-Schaltflächen angezeigt werden.
Implementierungsbeispiel
Der folgende Code fängt den Versuch eines Nutzers ab, einen Chat zu starten. Es werden die Umleitungsmetadaten des SDK für QueueMenu geprüft. Wenn eine Regel aktiv ist, wird die Nachricht für die Zeit außerhalb der Geschäftszeiten aus den Warteschlangeneinstellungen aufgelöst und ein Umleitungsbildschirm angezeigt.
// Helper - pull the first after-hours message text out of the queue's settings
func afterHoursMessageText(for menu: QueueMenu) -> String? {
return menu.settings?
.compactMap { $0.afterHours?.message?.text }
.first
}
// Called when the user taps "Start Chat" in your app
func attemptToStartChat(for menu: QueueMenu) {
// 1. Check if any deflection rules route into this queue
if let deflections = menu.deflectionFrom, !deflections.isEmpty {
let message = afterHoursMessageText(for: menu)
?? "Support is currently unavailable."
showDeflectionScreen(message: message, deflections: deflections)
} else {
// No deflection rules apply. Safe to start the chat.
Task {
await startChat(for: menu)
}
}
}
Optionen für die Umleitung des Renderings
Wenn eine Umleitungsregel aktiv ist, konfigurieren Ihre Administratoren wahrscheinlich alternative Möglichkeiten für den Nutzer, Hilfe zu erhalten. In der Regel wird auf eine andere Warteschlange verwiesen (die Sie mit menuId auflösen können) oder der Text für die Zeit außerhalb der Geschäftszeiten der aktuellen Warteschlange wird angezeigt.
Was das SDK bietet: Die Liste der QueueMenuDeflection-Einträge unter deflectionFrom, jeweils mit einem deflectionType und einem menuId.
Was Sie erstellen: Ein dynamisches Menü, das diese Einträge durchläuft, jede menuId anhand des bereits abgerufenen Menübaums auflöst, um einen Anzeigenamen zu erhalten, und die entsprechenden Schaltflächen generiert.
Implementierungsbeispiel
Dieser Code verwendet die Ablenkungseinträge und erstellt dynamisch einen Bildschirm. Der Name der Quellwarteschlange wird mit der SDK-bereitgestellten findMenu(byId:)-Erweiterung für [QueueMenu] aufgelöst. Wenn kein Warteschlangenname verfügbar ist, wird auf den Namen deflectionType zurückgegriffen.
func showDeflectionScreen(
message: String,
deflections: [QueueMenuDeflection],
cachedRootMenus: [QueueMenu]
) {
// 1. Update your UI with the resolved message (or your fallback)
deflectionTitleLabel.text = message
// 2. Loop through the incoming deflection rules and generate buttons
for deflection in deflections {
let sourceMenu = deflection.menuId.flatMap { cachedRootMenus.findMenu(byId: $0) }
let label = sourceMenu?.name
?? deflection.deflectionType.map { String(describing: $0) }
?? "Alternative option"
let button = createButton(title: label) {
self.handleDeflectionAction(deflection)
}
menuStackView.addArrangedSubview(button)
}
// 3. Present the compiled screen to the user
present(deflectionViewController, animated: true)
}
deflectionFrom ist die Liste der Umleitungsregeln, die in dieses Menü weiterleiten. Die menuId jedes Eintrags gibt eine Quellwarteschlange an, die in die aktuelle Warteschlange umgeleitet wird. Ihre App entscheidet, wie diese präsentiert werden: Bei einigen Integrationen wird die Zielwarteschlange als „Hier werden Sie stattdessen weitergeleitet“ angezeigt, bei anderen wird das Vorhandensein einer Regel als Gate verwendet, um einen generischen Bildschirm „Später noch einmal versuchen“ anzuzeigen.