Headless Mobile SDK für Android: Smart Actions, Anhänge und Weiterleitung

In diesem Dokument erfahren Sie, wie Sie das Headless Mobile SDK in Ihre Android-App einbinden und anpassen. Darin werden die intelligenten Aktionen, Anhänge und die Umleitung behandelt.

Smarte Aktionen und Anhänge konfigurieren

Mit Smart Actions können Kundenservicemitarbeiter und Kunden strukturierte Informationen wie Fotos, Videos, Textausschnitte und biometrische Bestätigung austauschen.

In der monitorlosen 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 CCAI Platform. Da Sie die Benutzeroberfläche besitzen, ist Ihre App vollständig für die Erstellung der Kamerabildschirme, der Fotoauswahl, der Textfelder und das Auslösen der integrierten biometrischen Aufforderungen von Android 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 biometrische Aufforderungen), die angezeigt werden, wenn der Nutzer auf eine Warteschlange tippt und den Wartebereich betritt, sowie die Logik für das Zwischenspeichern auf der Festplatte, um Medien sicher zu speichern, bis die Sitzung verbunden ist.

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 Sie eine Videoanforderung verarbeiten, indem Sie eine Uri-Dateireferenz auf der Festplatte speichern, anstatt das Video im Arbeitsspeicher zu behalten.

// 1. Check requirements and collect data BEFORE joining the queue
fun checkPreSessionRequirements(queueMenu: QueueMenu) {
    val smartActions = queueMenu.settings
    if (smartActions.isNullOrEmpty()) {
        startChat(queueMenu)
        return
    }

    // Example: handle a video requirement
    presentVideoPicker { localFileUri ->
        // IMPORTANT: localFileUri should point to context.cacheDir
        MySessionStateManager.pendingPreSessionVideo = localFileUri
        startChat(queueMenu)
    }
}

// 2. Upload and clean up AFTER the session officially connects
fun handleSessionConnected() {
    val pendingVideoUri = MySessionStateManager.pendingPreSessionVideo ?: return

    // Upload using the standard in-session pipeline
    // then clean up the temporary file
    val file = File(pendingVideoUri.path ?: return)
    file.delete()
    MySessionStateManager.pendingPreSessionVideo = null
}

Konfiguration von Smart Actions vor der Sitzung lesen

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)

// `QueueMenuSetting` and `QueueMenuSDKSetting` (simplified)
data class QueueMenuSetting(
    val sdk: QueueMenuSDKSetting?
    // ... other fields ...
)

data class QueueMenuSDKSetting(
    val preSessionSmartAction: Boolean?
    // ... other fields ...
)

// Usage - "does any queue-level setting require a pre-session smart action?"
fun queueRequiresPreSession(menu: QueueMenu): Boolean {
    return menu.settings?.any { it.sdk?.preSessionSmartAction == true } ?: false
}

Pfad B – Kanalebene (VoiceCallChannel.preSessionSmartAction)

// Usage - "does the voice channel specifically require pre-session capture?"
val 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 eine Schaltfläche in seinem Dashboard klicken, um Daten vom Nutzer anzufordern, z. B. Senden Sie ein Foto Ihres amtlichen Ausweises oder Authentifizieren Sie sich mit biometrischen Daten.

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 Android BiometricPrompt) 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 Android-Tool wird geöffnet.

import androidx.biometric.BiometricPrompt
import androidx.core.content.ContextCompat

// Listen for Smart Action requests from the active SDK session.
//
// `SmartActionRequest` exposes a nested `smartAction: SmartAction`, and the
// switchable type lives at `request.smartAction.type`. The `SmartActionType`
// enum is `PascalCase: Unknown`, `Verification`, `Screenshot`, `Photo`, `Video`,
// `TextInput`, `ScreenShare`. Use `Verification` for Face ID / fingerprint flows.
fun handleSmartActionRequest(request: SmartActionRequest) {
    when (request.smartAction.type) {
        SmartActionType.Photo -> {
            promptUserForPhoto(message = "The agent requested a photo.") { capturedBitmap ->
                // Send the image back to the agent using the SDK.
                sendAttachment(image = capturedBitmap)
            }
        }

        SmartActionType.Verification -> {
            val executor = ContextCompat.getMainExecutor(this)
            val biometricPrompt = BiometricPrompt(this, executor,
                object : BiometricPrompt.AuthenticationCallback() {
                    override fun onAuthenticationSucceeded(
                        result: BiometricPrompt.AuthenticationResult
                    ) {
                        sendBiometricResult(success = true)
                    }

                    override fun onAuthenticationFailed() {
                        sendBiometricResult(success = false)
                    }

                    override fun onAuthenticationError(
                        errorCode: Int, errString: CharSequence
                    ) {
                        sendBiometricResult(success = false)
                    }
                }
            )

            val promptInfo = BiometricPrompt.PromptInfo.Builder()
                .setTitle("Identity Verification")
                .setSubtitle("Verify your identity to continue")
                .setNegativeBtnText("Cancel")
                .build()

            biometricPrompt.authenticate(promptInfo)
        }

        SmartActionType.TextInput -> {
            presentTextInputPrompt(message = "The agent requested text input.") { text ->
                sendSmartActionText(text)
            }
        }

        SmartActionType.Video -> {
            // Agent-requested video capture. Reuse the same disk-cached file
            // pattern recommended for pre-session media keep the recording on
            // disk and pass the local Uri to the SDK rather than holding a
            // large `ByteArray` in memory.
            promptUserForVideo(message = "The agent requested a video.") { capturedVideoUri ->
                sendAttachment(videoUri = capturedVideoUri)
            }
        }

        SmartActionType.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 `ScreenShare`, which
            // starts a live co-browse session.
            promptUserForScreenshot(message = "The agent requested a screenshot.") { capturedBitmap ->
                sendAttachment(image = capturedBitmap)
            }
        }

        SmartActionType.ScreenShare -> {
            // Hand off to the full screen share flow (see Headless Mobile SDK for Android: Voice, screen share, scheduled call, and email).
            // Don't confuse with `Screenshot`;  `ScreenShare` starts a
            // live co-browse session using `CCAIScreenShare`, while `Screenshot`
            // captures a single still frame.
            startScreenShareFlow()
        }

        SmartActionType.Unknown -> {
            // Future-proof: a smart action type the SDK does not recognize.
            // Log and continue; don't block the user.
            Log.w("CCAI", "Received unknown smart action type")
        }
    }
}

Von Agenten initiierte Smart Actions werden über die SDK-Ereignisse der aktiven Sitzung empfangen. Abonnieren Sie die relevanten Chat- oder Anrufergebnisse, bevor Sie die Sitzung starten, damit Ihre App den entsprechenden kundenorientierten Prompt präsentieren kann, sobald eine Anfrage eingeht.

Intelligente Aktionen benachrichtigen und verfolgen

Verwende smartActionService, um intelligente Aktionen zu bestätigen und zu aktualisieren, während der Nutzer sie durchläuft.

val router = CommunicationRouter(
    id = chatId,
    type = CommunicationType.Chat
)

// Notify the server that a smart action has been received.
lifecycleScope.launch {
    try {
        CCAI.smartActionService?.notifySmartActionReceived(
            router = router,
            smartActionId = smartActionId
        )
        Log.d("CCAI", "Smart action notification sent successfully")
    } catch (e: Exception) {
        Log.e("CCAI", "Failed to notify smart action: ${e.message}")
    }
}

// Update the smart action status as the user completes it.
lifecycleScope.launch {
    try {
        CCAI.smartActionService?.updateSmartActionStatus(
            router = router,
            smartActionId = smartActionId,
            status = SmartActionStatus.Finished
        )
        Log.d("CCAI", "Smart action status updated successfully")
    } catch (e: Exception) {
        Log.e("CCAI", "Failed to update smart action status: ${e.message}")
    }
}

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 externen ID und Smart Action-ID abgerufen. Anschließend wird die Antwort vor dem Senden validiert.

// Fetch a web form - `fetchWebForm` takes two positional parameters on Android.
lifecycleScope.launch {
    try {
        val webFormResponse = CCAI.chatService?.fetchWebForm(
            externalFormId = "form123",
            smartActionId = 123
        )
        if (webFormResponse != null) {
            Log.d("CCAI", "Web form received: $webFormResponse")
            // Render the web form in your custom UI.
            renderWebForm(webFormResponse)
        }
    } catch (e: Exception) {
        Log.e("CCAI", "Failed to fetch web form: ${e.message}")
    }
}

// Validate a web form response.
lifecycleScope.launch {
    try {
        val isValid = CCAI.chatService?.validateWebForm(webFormResponse)
        if (isValid == true) {
            Log.d("CCAI", "Web form is valid")
        } else {
            Log.d("CCAI", "Web form validation failed")
        }
    } catch (e: Exception) {
        Log.e("CCAI", "Failed to validate web form: ${e.message}")
    }
}

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 Formular-UI, in der die einzelnen Fragetypen (Textfelder, Drop-down-Menüs usw.) gerendert werden, Eingaben validiert und Antworten für die Übermittlung erfasst werden.

Implementierungsbeispiel

Mit diesem Code werden die Fragedefinitionen eines benutzerdefinierten Formulars abgerufen und dann die Antworten des Nutzers verpackt und gesendet.

// Retrieve custom form details
lifecycleScope.launch {
    try {
        val formDetails = CCAI.chatService?.getCustomFormDetails(formId = 123)
        if (formDetails != null) {
            Log.d("CCAI", "Form Title: ${formDetails.title ?: "No title"}")
            Log.d("CCAI", "Questions: ${formDetails.questions.size}")
            // Render the form dynamically based on question types
            renderCustomForm(formDetails)
        }
    } catch (e: Exception) {
        Log.e("CCAI", "Failed to get custom form details: ${e.message}")
    }
}

// Submit a custom form
val request = SubmitCustomFormRequest(
    smartActionId = 123,
    formResponse = listOf(
        SubmitCustomFormRequest.Answer(questionId = 1, value = "John Doe"),
        SubmitCustomFormRequest.Answer(questionId = 2, value = "john@example.com")
    )
)

lifecycleScope.launch {
    try {
        CCAI.chatService?.submitCustomForm(request = request)
        Log.d("CCAI", "Form submitted successfully")
    } catch (e: Exception) {
        Log.e("CCAI", "Failed to submit form: ${e.message}")
    }
}

Die vollständigen Enum-Definitionen für CustomFormDetailsResponse, CustomFormQuestion, CustomFormQuestionOption und CustomFormQuestionType finden Sie in der Headless Mobile SDK – Android 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 der CCAI Platform 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 seiner Galerie auswählt, übergeben Sie die lokale Datei Uri an das SDK. Verwenden Sie dazu dieselbe sendMessage API, die für alle ausgehenden Nachrichten verwendet wird. Weitere Informationen finden Sie unter Nachrichten senden.

Das SDK übernimmt die Komprimierung und den Upload.

// Called when the user picks an image from their photo gallery
fun userDidSelectImage(imageUri: Uri) {
    val messageBubble = myChatAdapter.addLoadingImageBubble()

    lifecycleScope.launch {
        try {
            CCAI.chatService?.sendMessage(
                OutgoingMessageContent.Photos(
                    images = listOf(imageUri),
                    smartAction = null
                )
            )
            messageBubble.markAsSent()
        } catch (e: Exception) {
            messageBubble.showError("Failed to send: ${e.message}")
        }
    }
}

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

Die CCAI Platform akzeptiert 19 Dateitypen in vier Kategorien. 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.

Was das SDK bietet: Nutzlasten für eingehende Chatnachrichten, die über die Nachricht Flow des Chatdienstes gesendet werden und Metadaten für Anhänge enthalten. Weitere Informationen finden Sie unter Headless Mobile SDK for Android: Advanced topics, localization, and post-session flows. 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

Eingehende Nachrichten mit der Nachrichten-Flow des Chatdienstes beobachten. Wenn eine neue Nachricht Media-Metadaten enthält, rufen Sie downloadMedia auf, bevor Sie die Datei rendern oder öffnen.

downloadMedia gibt DownloadMediaResponse { data: ByteArray, 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 cachen oder die Bytes beizubehalten. Wenn downloadMedia noch einmal aufgerufen wird, wird ein weiterer Netzwerkabruf ausgelöst.

import android.graphics.BitmapFactory
import java.io.File

lifecycleScope.launch {
    CCAI.chatService?.messagesReceived?.collect { messages ->
        for (message in messages) {
            renderIncomingMessage(message)
        }
    }
}

fun renderIncomingMessage(message: ChatMessage) {
    val media = message.media

    if (media == null) {
        myChatAdapter.insertTextBubble(text = message.text)
        return
    }

    lifecycleScope.launch {
        try {
            // `downloadMedia` returns the raw bytes plus an optional filename.
            val response = CCAI.chatService?.downloadMedia(
                mediaId = media.id,
                mediaType = media.type
            ) ?: return@launch

            when (media.type) {
                DownloadableMediaType.Photo -> {
                    // Decode in-memory; no disk write needed.
                    val bitmap = BitmapFactory.decodeByteArray(
                        response.data, 0, response.data.size
                    )
                    myChatAdapter.insertImageBubble(
                        bitmap = bitmap,
                        fileName = response.fileName
                    )
                }
                DownloadableMediaType.Video,
                DownloadableMediaType.Audio,
                DownloadableMediaType.Document -> {
                    // Larger media usually needs an on-disk file for a player
                    // or document viewer. Write to the app's cache directory
                    // yourself and hand the resulting File/Uri to your UI.
                    val file = File(
                        applicationContext.cacheDir,
                        response.fileName ?: "attachment"
                    )
                    file.writeBytes(response.data)
                    myChatAdapter.insertAttachmentBubble(
                        file = file,
                        mediaType = media.type
                    )
                }
            }
        } catch (e: Exception) {
            myChatAdapter.insertAttachmentErrorBubble(fileName = message.media?.name)
        }
    }
}

Weiterleitung (außerhalb der Geschäftszeiten und bei Überlastung)

Bei der Weiterleitung werden Nutzer umgeleitet, wenn Ihr Supportteam nicht verfügbar ist. Das passiert in der Regel in zwei Fällen:

  • Außerhalb der Öffnungszeiten: Der Nutzer versucht, den Support außerhalb der konfigurierten Öffnungszeiten zu kontaktieren.

  • Überlastung: Die Warteschlange ist geöffnet, aber die Wartezeit überschreitet den vom Administrator konfigurierten 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: List<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 Überlastung).

  • menuId: Int?: die ID der Quellwarteschlange, aus der Anfragen in diese Warteschlange umgeleitet werden.

QueueMenuDeflection enthält keine Display-Mitteilung oder ein menschenlesbares Label. Verwenden Sie für den Text, der Nutzern angezeigt wird (z. B. Unser Büro ist geschlossen),afterHoursMessage der Warteschlange (abgeleitet von QueueMenu.settings[].afterHours) oder Ihre eigenen vom Administrator konfigurierten Strings. Suchen Sie den Anzeigenamen der aufgelösten Zielwarteschlange im bereits abgerufenen Menübaum nach menuId.

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

Mit dem folgenden Code wird der Versuch eines Nutzers abgefangen, einen Chat zu starten. Es wird geprüft, ob die Umleitungsmetadaten des SDK auf QueueMenu vorhanden sind. Wenn eine Regel aktiv ist, wird ein Umleitungsbildschirm mit dem afterHoursMessage der Warteschlange (oder einem Fallback) angezeigt.

fun onSupportMenuTapped(queueMenu: QueueMenu) {
    // 1. Check if any deflection rules route into this queue.
    val deflections = queueMenu.deflectionFrom
    if (!deflections.isNullOrEmpty()) {
        // Deflection is active - stop routing. Show the custom deflection screen instead.
        val message = queueMenu.afterHoursMessage?.text
            ?: "Support is currently unavailable."
        showDeflectionScreen(
            message = message,
            deflections = deflections
        )
    } else {
        // No deflection rules apply. Safe to proceed to channel selection or directly to chat/call.
        startSupportFlow(queueMenu)
    }
}

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 die für die aktuelle Warteschlange konfigurierten afterHoursMessage werden 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

Mit diesem Code werden die Ablenkungseinträge verwendet und dynamisch ein Bildschirm erstellt. Als Schaltflächenlabel wird der Name der Quellwarteschlange verwendet (aus menuId aufgelöst). Wenn kein Name verfügbar ist, wird auf deflectionType zurückgegriffen.

fun showDeflectionScreen(message: String, deflections: List<QueueMenuDeflection>) {
    // 1. Update your UI with the admin's configured message (or your fallback).
    deflectionTitleTextView.text = message

    // 2. Loop through the incoming deflection rules and generate buttons.
    for (deflection in deflections) {
        val sourceMenu = deflection.menuId?.let { findMenuById(it) }
        val label = sourceMenu?.name
            ?: deflection.deflectionType?.name
            ?: "Alternative option"

        val button = MaterialButton(this).apply {
            text = label
            setOnClickListener {
                handleDeflectionAction(deflection)
            }
        }
        menuLinearLayout.addView(button)
    }

    // 3. Present the compiled screen to the user.
    deflectionContainer.isVisible = true
}

// Walk your previously fetched menu tree (for example, by using `QueueMenu.flatten()`) to resolve a `menuId`.
private fun findMenuById(id: Int): QueueMenu? =
    cachedRootMenus.flatMap { it.flatten() }.firstOrNull { it.id == id }

deflectionFrom ist die Liste der Umleitungsregeln, die in dieses Menü weitergeleitet werden. Die menuId jedes Eintrags gibt eine Quellwarteschlange an, die in die aktuelle Warteschlange umgeleitet wird. Ihre App entscheidet, wie diese Daten verfügbar gemacht werden. Bei einigen Integrationen wird die Zielwarteschlange als Hier werden Sie stattdessen weitergeleitet angezeigt, bei anderen wird nur das Vorhandensein einer Regel als Gate verwendet, um einen generischen Bildschirm mit der Meldung Bitte versuchen Sie es später noch einmal anzuzeigen.