Benachrichtigung erstellen

Benachrichtigungen liefern kurze, aktuelle Informationen zu Ereignissen in deiner App, während sie nicht verwendet wird. In diesem Dokument erfahren Sie, wie Sie eine Benachrichtigung mit verschiedenen Funktionen erstellen. Eine Einführung dazu, wie Benachrichtigungen auf Android-Geräten angezeigt werden, finden Sie in der Übersicht über Benachrichtigungen. Beispielcode, der Benachrichtigungen verwendet, finden Sie im SociaLite-Beispiel auf GitHub.

Der Code auf dieser Seite verwendet die NotificationCompat APIs aus der AndroidX-Bibliothek. Mit diesen APIs können Sie Funktionen hinzufügen, die nur in neueren Android-Versionen verfügbar sind, und gleichzeitig die Kompatibilität mit Android 9 (API-Level 28) aufrechterhalten. Einige Funktionen, z. B. die Inline-Antwortaktion, führen jedoch bei früheren Versionen zu einem No-Op.

Einfache Benachrichtigung erstellen

Eine Benachrichtigung in ihrer einfachsten und kompaktesten Form, auch als minimierte Form bezeichnet, enthält ein Symbol, einen Titel und eine kleine Menge Text. In diesem Abschnitt wird gezeigt, wie Sie eine Benachrichtigung erstellen, auf die der Nutzer tippen kann, um eine Aktivität in Ihrer App zu starten.

Abbildung 1. Eine Benachrichtigung mit einem Symbol, einem Titel und Text.

Weitere Informationen zu den einzelnen Teilen einer Benachrichtigung finden Sie unter Anatomie einer Benachrichtigung.

Laufzeitberechtigung deklarieren

Android 13 (API‑Level 33) und höher unterstützt eine Laufzeitberechtigung zum Posten von Benachrichtigungen, die nicht ausgenommen sind (einschließlich Diensten im Vordergrund), aus einer App.

Die Berechtigung, die Sie in der Manifestdatei Ihrer App deklarieren müssen, wird im folgenden Code-Snippet angezeigt:

<manifest ...>
    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
    <application ...>
        ...
    </application>
</manifest>

Weitere Informationen zu Laufzeitberechtigungen finden Sie unter Laufzeitberechtigung für Benachrichtigungen.

Inhalt der Benachrichtigung festlegen

Legen Sie zuerst den Inhalt und den Kanal der Benachrichtigung mit einem NotificationCompat.Builder-Objekt fest. Im folgenden Beispiel wird gezeigt, wie Sie eine Benachrichtigung mit den folgenden Elementen erstellen:

  • Ein kleines Symbol, das mit setSmallIcon() festgelegt wird. Dies ist der einzige für Nutzer sichtbare Inhalt, der erforderlich ist.

  • Ein Titel, der von setContentTitle() festgelegt wird.

  • Der Textkörper, der von setContentText() festgelegt wird.

  • Die Benachrichtigungspriorität, die von setPriority() festgelegt wird. Die Priorität bestimmt, wie aufdringlich die Benachrichtigung unter Android 7.1 und niedriger ist. Legen Sie für Android 8.0 und höher stattdessen die Kanalwichtigkeit fest, wie im nächsten Abschnitt beschrieben.

val textTitle = "Title"
val textContent = "Content"
val builder = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .setContentTitle(textTitle)
    .setContentText(textContent)
    .setPriority(NotificationCompat.PRIORITY_DEFAULT)

Für den NotificationCompat.Builder-Konstruktor müssen Sie eine Kanal-ID angeben. Dies ist für die Kompatibilität mit Android 8.0 (API-Level 26) und höher erforderlich, wird aber von früheren Versionen ignoriert.

Standardmäßig wird der Textinhalt der Benachrichtigung so gekürzt, dass er in eine Zeile passt. Sie können zusätzliche Informationen anzeigen, indem Sie eine maximierbare Benachrichtigung erstellen.

Abbildung 2: Eine maximierbare Benachrichtigung in minimierter und maximierter Form.

Wenn du eine längere Benachrichtigung erstellen möchtest, kannst du eine maximierbare Benachrichtigung aktivieren, indem du eine Stilvorlage mit setStyle() hinzufügst. Mit dem folgenden Code wird beispielsweise ein größerer Textbereich erstellt:

val builder = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .setContentTitle("My notification")
    .setContentText("Much longer text that cannot fit one line...")
    .setStyle(NotificationCompat.BigTextStyle()
        .bigText("Much longer text that cannot fit one line..."))
    .setPriority(NotificationCompat.PRIORITY_DEFAULT)

Weitere Informationen zu anderen großen Benachrichtigungsstilen, einschließlich des Hinzufügens eines Bildes und von Steuerelementen für die Medienwiedergabe, finden Sie unter Maximierbare Benachrichtigung erstellen.

Kanal erstellen und Wichtigkeit festlegen

Bevor Sie die Benachrichtigung unter Android 8.0 und höher senden können, müssen Sie den Benachrichtigungskanal Ihrer App beim System registrieren. Übergeben Sie dazu eine Instanz von NotificationChannel an createNotificationChannel(). Der folgende Code wird durch eine Bedingung für die SDK_INT-Version blockiert:

fun createNotificationChannel(context: Context) {
    // Create the NotificationChannel, but only on API 26+ because
    // the NotificationChannel class is not in the Support Library.
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        val name = context.getString(R.string.channel_name)
        val descriptionText = context.getString(R.string.channel_description)
        val importance = NotificationManager.IMPORTANCE_DEFAULT
        val channel = NotificationChannel(CHANNEL_ID, name, importance).apply {
            description = descriptionText
        }
        // Register the channel with the system.
        val notificationManager: NotificationManager =
            context.getSystemService(NotificationManager::class.java) as NotificationManager
        notificationManager.createNotificationChannel(channel)
    }
}

Da Sie den Benachrichtigungskanal erstellen müssen, bevor Sie Benachrichtigungen unter Android 8.0 und höher posten, führen Sie diesen Code aus, wenn Ihre App gestartet wird. Es ist sicher, den Aufruf wiederholt auszuführen, da das Erstellen eines vorhandenen Kanals keine Auswirkungen hat.

Der NotificationChannel-Konstruktor erfordert eine Wichtigkeitsstufe mit einer NotificationManager-Konstante. Dadurch wird festgelegt, wie der Nutzer unterbrochen wird. Wenn Sie Android 7.1 und niedriger unterstützen möchten, legen Sie die Priorität auch mit setPriority() fest, wie im vorherigen Beispiel gezeigt.

Obwohl Sie die Wichtigkeit oder Priorität festlegen müssen, kann das System das Verhalten der Benachrichtigung nicht garantieren. Das System kann die Wichtigkeit basierend auf anderen Faktoren anpassen und der Nutzer kann die Wichtigkeitsstufe des Kanals jederzeit anpassen.

Weitere Informationen zur Bedeutung der verschiedenen Stufen finden Sie unter Wichtigkeitsstufen von Benachrichtigungen.

Tippaktion für die Benachrichtigung festlegen

Jede Benachrichtigung muss auf ein Tippen reagieren, in der Regel, um eine Aktivität in deiner App zu öffnen, die der Benachrichtigung entspricht. Geben Sie dazu einen Content-Intent an, der mit einem PendingIntent-Objekt definiert ist, und übergeben Sie ihn an setContentIntent().

Das folgende Snippet zeigt, wie Sie einen einfachen Intent erstellen, um eine Aktivität zu öffnen, wenn der Nutzer auf die Benachrichtigung tippt:

// Create an explicit intent for an Activity in your app.
val intent = Intent(context, AlertDetails::class.java).apply {
    flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
}
val pendingIntent: PendingIntent =
    PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_IMMUTABLE)

val builder = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .setContentTitle("My notification")
    .setContentText("Hello World!")
    .setPriority(NotificationCompat.PRIORITY_DEFAULT)
    // Set the intent that fires when the user taps the notification.
    .setContentIntent(pendingIntent)
    .setAutoCancel(true)

Dieser Code ruft setAutoCancel() auf, wodurch die Benachrichtigung automatisch entfernt wird, wenn der Nutzer darauf tippt.

Die Intent-Flags im vorherigen Beispiel sorgen dafür, dass die Navigation nach dem Öffnen der App über die Benachrichtigung wie erwartet funktioniert. Sie können sie je nach Art der Aktivität verwenden, die Sie starten. Dies kann eine der folgenden sein:

  • Eine Aktivität, die ausschließlich für Antworten auf die Benachrichtigung vorhanden ist. Es gibt keinen Grund, warum der Nutzer diese Aktivität bei der normalen App-Nutzung aufrufen sollte. Daher wird für die Aktivität eine neue Aufgabe gestartet, anstatt sie der vorhandenen Aufgabe und dem Back Stack Ihrer App hinzuzufügen. Dies ist der Intent-Typ, der im vorherigen Beispiel erstellt wurde.

  • Eine Aktivität, die im regulären App-Ablauf Ihrer App vorhanden ist. In diesem Fall wird beim Starten der Aktivität ein Back Stack erstellt, damit die Erwartungen des Nutzers an die Schaltflächen „Zurück“ und „Nach oben“ erfüllt werden.

Benachrichtigung anzeigen

Damit die Benachrichtigung angezeigt wird, rufen Sie NotificationManagerCompat.notify() auf und übergeben Sie eine eindeutige ID für die Benachrichtigung und das Ergebnis von NotificationCompat.Builder.build(). Dies wird im folgenden Beispiel veranschaulicht:

with(NotificationManagerCompat.from(context)) {
    if (ActivityCompat.checkSelfPermission(
            context,
            Manifest.permission.POST_NOTIFICATIONS
        ) != PackageManager.PERMISSION_GRANTED
    ) {
        // TODO: Consider calling ActivityCompat#requestPermissions here
        // to request the missing permissions, and then overriding
        // public fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>,
        //                                        grantResults: IntArray)
        // to handle the case where the user grants the permission. See the documentation
        // for ActivityCompat#requestPermissions for more details.

        return@with
    }
    // notificationId is a unique int for each notification that you must define.
    notify(notificationId, builder.build())

Speichere die Benachrichtigungs-ID, die du an NotificationManagerCompat.notify() übergibst, da du sie benötigst, wenn du die Benachrichtigung aktualisieren oder entfernen möchtest.

Wenn du grundlegende Benachrichtigungen auf Geräten mit Android 13 oder höher testen möchtest, musst du Benachrichtigungen manuell aktivieren oder ein Dialogfeld erstellen, um Benachrichtigungen anzufordern.

Aktionsbuttons hinzufügen

Eine Benachrichtigung kann bis zu drei Aktionsschaltflächen enthalten, mit denen der Nutzer schnell reagieren kann, z. B. um eine Erinnerung zu verschieben oder auf eine SMS zu antworten. Diese Aktionsschaltflächen dürfen jedoch nicht die Aktion duplizieren, die ausgeführt wird, wenn der Nutzer auf die Benachrichtigung tippt.

Abbildung 3: Eine Benachrichtigung mit einem Aktionsbutton.

Wenn Sie einen Aktionsbutton hinzufügen möchten, übergeben Sie einen PendingIntent an die Methode addAction(). Das ist so, als ob du die Standard-Tippaktion der Benachrichtigung einrichtest, nur dass du statt einer Aktivität andere Dinge tun kannst, z. B. einen BroadcastReceiver starten, der einen Job im Hintergrund ausführt, damit die Aktion die bereits geöffnete App nicht unterbricht.

Der folgende Code zeigt beispielsweise, wie ein Broadcast an einen bestimmten Empfänger gesendet wird:

val ACTION_SNOOZE = "snooze"
val snoozeIntent = Intent(context, MyBroadcastReceiver::class.java).apply {
    action = ACTION_SNOOZE
    putExtra(EXTRA_NOTIFICATION_ID, 0)
}
val snoozePendingIntent: PendingIntent =
    PendingIntent.getBroadcast(context, 0, snoozeIntent, PendingIntent.FLAG_IMMUTABLE)
val builder = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .setContentTitle("My notification")
    .setContentText("Hello World!")
    .setPriority(NotificationCompat.PRIORITY_DEFAULT)
    .setContentIntent(pendingIntent)
    .addAction(R.drawable.snooze, context.getString(R.string.snooze),
        snoozePendingIntent)

Weitere Informationen zum Erstellen eines BroadcastReceiver für die Ausführung von Hintergrundaufgaben finden Sie in der Übersicht über Broadcasts.

Wenn Sie stattdessen eine Benachrichtigung mit Schaltflächen für die Medienwiedergabe erstellen möchten, z. B. zum Pausieren und Überspringen von Titeln, lesen Sie den Hilfeartikel Benachrichtigung mit Mediensteuerung erstellen.

Aktion für Direktantwort hinzufügen

Mit der in Android 7.0 (API-Level 24) eingeführten Aktion „Direktantwort“ können Nutzer Text direkt in die Benachrichtigung eingeben. Der Text wird dann an Ihre App gesendet, ohne dass eine Aktivität geöffnet wird. Beispielsweise kannst du eine Direktantwortaktion verwenden, damit Nutzer direkt in der Benachrichtigung auf Nachrichten antworten oder Aufgabenlisten aktualisieren können.

Abbildung 4: Wenn du auf „Antworten“ tippst, wird die Texteingabe geöffnet.

Die Direktantwortaktion wird als zusätzliche Schaltfläche in der Benachrichtigung angezeigt, über die eine Texteingabe geöffnet wird. Wenn der Nutzer die Eingabe beendet hat, hängt das System die Textantwort an den Intent an, den du für die Benachrichtigungsaktion angegeben hast, und sendet den Intent an deine App.

Button „Antworten“ hinzufügen

So erstellen Sie eine Benachrichtigungsaktion, die Direktantworten unterstützt:

Erstelle eine Instanz von RemoteInput.Builder, die du deiner Benachrichtigungsaktion hinzufügen kannst. Der Konstruktor dieser Klasse akzeptiert einen String, den das System als Schlüssel für die Texteingabe verwendet. Ihre App verwendet diesen Schlüssel später, um den Text der Eingabe abzurufen.

// Key for the string that's delivered in the action's intent.
val replyLabel: String = context.resources.getString(R.string.reply_label)
val remoteInput: RemoteInput = RemoteInput.Builder(KEY_TEXT_REPLY).run {
    setLabel(replyLabel)
    build()
}

Erstellen Sie einen PendingIntent für die Antwortaktion.

// Build a PendingIntent for the reply action to trigger.
val replyPendingIntent: PendingIntent =
    PendingIntent.getBroadcast(context,
        conversationId,
        getMessageReplyIntent(conversationId),
        PendingIntent.FLAG_MUTABLE)

Hängen Sie das RemoteInput-Objekt mit addRemoteInput() an eine Aktion an.

// Create the reply action and add the remote input.
val action: NotificationCompat.Action =
    NotificationCompat.Action.Builder(R.drawable.reply,
        context.getString(R.string.reply_label), replyPendingIntent)
        .addRemoteInput(remoteInput)
        .build()

Wenden Sie die Aktion auf eine Benachrichtigung an und geben Sie die Benachrichtigung aus.

// Build the notification and add the action.
val newMessageNotification = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_message)
    .setContentTitle(context.getString(R.string.title))
    .setContentText(context.getString(R.string.content))
    .addAction(action)
    .build()

// Issue the notification.
NotificationManagerCompat.from(context).notify(notificationId, newMessageNotification)

Das System fordert den Nutzer auf, eine Antwort einzugeben, wenn er die Benachrichtigungsaktion auslöst (siehe Abbildung 4).

Nutzereingabe aus der Antwort abrufen

Wenn du Nutzereingaben über die Antwort-UI der Benachrichtigung erhalten möchtest, rufe RemoteInput.getResultsFromIntent() auf und übergib den Intent, der von deinem BroadcastReceiver empfangen wurde:

private fun getMessageText(intent: Intent): CharSequence? {
    return RemoteInput.getResultsFromIntent(intent)?.getCharSequence(KEY_TEXT_REPLY)
}

Nachdem du den Text verarbeitet hast, aktualisiere die Benachrichtigung, indem du NotificationManagerCompat.notify() mit derselben ID und demselben Tag aufrufst, falls verwendet. Dies ist erforderlich, um die Benutzeroberfläche für Direktantworten auszublenden und dem Nutzer zu bestätigen, dass seine Antwort empfangen und korrekt verarbeitet wurde.

// Build a new notification, which informs the user that the system
// handled their interaction with the previous notification.
val repliedNotification = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.message)
    .setContentText(context.getString(R.string.replied))
    .build()

// Issue the new notification.
NotificationManagerCompat.from(context).notify(notificationId, repliedNotification)

Andere Daten abrufen

Die Verarbeitung anderer Datentypen funktioniert mit RemoteInput ähnlich. Im folgenden Beispiel wird ein Bild als Eingabe verwendet.

val replyLabel: String = context.resources.getString(R.string.reply_label)
val remoteInput: RemoteInput = RemoteInput.Builder(KEY_REPLY).run {
    setLabel(replyLabel)
    // Allow for image data types in the input.
    // This method can be used again to allow for other data types.
    setAllowDataType("image/*", true)
    build()
}

Rufen Sie RemoteInput#getDataResultsFromIntent auf und extrahieren Sie die entsprechenden Daten.

class ReplyReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        val dataResults = RemoteInput.getDataResultsFromIntent(intent, KEY_REPLY)
        val imageUri: Uri? = dataResults?.get("image/*") as? Uri

        if (imageUri != null) {
            // Extract the image
            context.contentResolver.openInputStream(imageUri)?.use { inputStream ->
                val bitmap = BitmapFactory.decodeStream(inputStream)
                // Display the image
                // ...
            }
        }
    }

    companion object {
        const val KEY_REPLY = "key_reply"
        const val KEY_TEXT_REPLY = "key_text_reply"
    }
}

Wenn du mit dieser neuen Benachrichtigung arbeitest, verwende den Kontext, der an die Methode onReceive() des Empfängers übergeben wird.

Hänge die Antwort am Ende der Benachrichtigung an, indem du setRemoteInputHistory() aufrufst. Wenn du jedoch eine Messaging-App erstellst, erstelle eine Benachrichtigung im Messaging-Stil und hänge die neue Nachricht an die Unterhaltung an.

Weitere Informationen zu Benachrichtigungen von Messaging-Apps finden Sie im Abschnitt Best Practices für Messaging-Apps.

Dringende Nachricht anzeigen

In deiner App muss möglicherweise eine dringende, zeitkritische Nachricht angezeigt werden, z. B. ein eingehender Anruf oder ein klingelnder Wecker. In diesen Fällen kannst du einen Full-Screen Intent mit deiner Benachrichtigung verknüpfen.

Wenn die Benachrichtigung aufgerufen wird, sehen Nutzer je nach Sperrstatus des Geräts Folgendes:

  • Wenn das Gerät des Nutzers gesperrt ist, wird eine Vollbild-Activity angezeigt, die den Sperrbildschirm verdeckt.
  • Wenn das Gerät des Nutzers entsperrt ist, wird die Benachrichtigung in einer maximierten Form angezeigt, die Optionen zum Verarbeiten oder Schließen der Benachrichtigung enthält.

Im folgenden Code-Snippet wird gezeigt, wie Sie Ihre Benachrichtigung mit einem Full-Screen Intent verknüpfen:

val fullScreenIntent = Intent(context, ImportantActivity::class.java)
val fullScreenPendingIntent = PendingIntent.getActivity(context, 0,
    fullScreenIntent, PendingIntent.FLAG_IMMUTABLE)

val builder = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .setContentTitle("My notification")
    .setContentText("Hello World!")
    .setPriority(NotificationCompat.PRIORITY_DEFAULT)
    .setFullScreenIntent(fullScreenPendingIntent, true)

Sichtbarkeit auf dem Sperrbildschirm festlegen

Wenn Sie festlegen möchten, wie viele Details in der Benachrichtigung auf dem Sperrbildschirm angezeigt werden, rufen Sie setVisibility() auf und geben Sie einen der folgenden Werte an:

  • VISIBILITY_PUBLIC: Der vollständige Inhalt der Benachrichtigung wird auf dem Sperrbildschirm angezeigt.

  • VISIBILITY_SECRET: Auf dem Sperrbildschirm wird kein Teil der Benachrichtigung angezeigt.

  • VISIBILITY_PRIVATE: Auf dem Sperrbildschirm werden nur grundlegende Informationen wie das Symbol der Benachrichtigung und der Titel des Inhalts angezeigt. Der vollständige Inhalt der Benachrichtigung wird nicht angezeigt.

Wenn Sie VISIBILITY_PRIVATE festlegen, können Sie auch eine alternative Version des Benachrichtigungsinhalts angeben, in der bestimmte Details ausgeblendet werden. Eine SMS-App könnte beispielsweise eine Benachrichtigung mit dem Text „Du hast 3 neue Nachrichten“ anzeigen, aber den Inhalt der Nachrichten und die Absender ausblenden. Wenn Sie diese alternative Benachrichtigung bereitstellen möchten, erstellen Sie sie zuerst wie gewohnt mit NotificationCompat.Builder. Hänge dann die alternative Benachrichtigung mit setPublicVersion() an die normale Benachrichtigung an.

Denke daran, dass der Nutzer immer die endgültige Kontrolle darüber hat, ob seine Benachrichtigungen auf dem Sperrbildschirm sichtbar sind, und sie anhand der Benachrichtigungskanäle deiner App steuern kann.

Benachrichtigung aktualisieren

Wenn du eine Benachrichtigung nach dem Senden aktualisieren möchtest, rufe NotificationManagerCompat.notify() noch einmal auf und übergib dieselbe ID, die du zuvor verwendet hast. Wenn die vorherige Benachrichtigung geschlossen wurde, wird stattdessen eine neue Benachrichtigung erstellt.

Optional kannst du setOnlyAlertOnce() aufrufen, damit die Benachrichtigung den Nutzer nur beim ersten Erscheinen und nicht bei späteren Aktualisierungen unterbricht – mit Ton, Vibration oder visuellen Hinweisen.

Benachrichtigung entfernen

Benachrichtigungen bleiben sichtbar, bis eines der folgenden Ereignisse eintritt:

  • Der Nutzer schließt die Benachrichtigung.
  • Der Nutzer tippt auf die Benachrichtigung, wenn Sie beim Erstellen der Benachrichtigung setAutoCancel() aufrufen.
  • Sie rufen cancel() für eine bestimmte Benachrichtigungs-ID auf. Mit dieser Methode werden auch laufende Benachrichtigungen gelöscht.
  • Du rufst cancelAll() auf, wodurch alle zuvor ausgegebenen Benachrichtigungen entfernt werden.
  • Die angegebene Dauer ist abgelaufen, wenn Sie beim Erstellen der Benachrichtigung mit setTimeoutAfter() ein Zeitlimit festgelegt haben. Bei Bedarf können Sie eine Benachrichtigung abbrechen, bevor die angegebene Zeitüberschreitung abläuft.

Best Practices für Messaging-Apps

Beachte die hier aufgeführten Best Practices, wenn du Benachrichtigungen für deine Messaging- und Chat-Apps erstellst.

MessagingStyle verwenden

Ab Android 7.0 (API-Level 24) bietet Android eine Vorlage für Benachrichtigungsstile speziell für Nachrichteninhalte. Mit der Klasse NotificationCompat.MessagingStyle kannst du mehrere der in der Benachrichtigung angezeigten Labels ändern, darunter den Titel der Unterhaltung, zusätzliche Nachrichten und die Inhaltsansicht für die Benachrichtigung.

Das folgende Code-Snippet zeigt, wie Sie den Stil einer Benachrichtigung mithilfe der Klasse MessagingStyle anpassen können.

val message1 = NotificationCompat.MessagingStyle.Message(
    messages[0].text,
    messages[0].time,
    messages[0].sender
)
val message2 = NotificationCompat.MessagingStyle.Message(
    messages[1].text,
    messages[1].time,
    messages[1].sender
)
notification = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .setStyle(
        NotificationCompat.MessagingStyle(Person.Builder().setName("Me").build())
            .addMessage(message1)
            .addMessage(message2)
    )
    .build()

Ab Android 9.0 (API-Level 28) ist es außerdem erforderlich, die Klasse Person zu verwenden, um eine optimale Darstellung der Benachrichtigung und ihrer Avatare zu erhalten.

Gehen Sie bei Verwendung von NotificationCompat.MessagingStyle so vor:

  • Rufen Sie MessagingStyle.setConversationTitle() auf, um einen Titel für Gruppenchats mit mehr als zwei Personen festzulegen. Ein guter Titel für eine Unterhaltung könnte der Name des Gruppenchats oder, wenn er keinen Namen hat, eine Liste der Teilnehmer der Unterhaltung sein. Andernfalls könnte die Nachricht fälschlicherweise als Teil einer 1:1-Unterhaltung mit dem Absender der letzten Nachricht in der Unterhaltung angesehen werden.
  • Verwenden Sie die Methode MessagingStyle.setData(), um Mediennachrichten wie Bilder einzufügen. MIME-Typen des Musters image/* werden unterstützt.

Direktantwort verwenden

Mit der Direktantwort können Nutzer inline auf eine Nachricht antworten.

  • Wenn ein Nutzer mit der Inline-Antwortaktion antwortet, aktualisiere die MessagingStyle-Benachrichtigung mit MessagingStyle.addMessage(). Ziehe die Benachrichtigung nicht zurück und brich sie nicht ab. Wenn die Benachrichtigung nicht abgebrochen wird, kann der Nutzer mehrere Antworten über die Benachrichtigung senden.
  • Damit die Aktion für Inline-Antworten mit Wear OS kompatibel ist, rufe Action.WearableExtender.setHintDisplayInlineAction(true) auf.
  • Verwenden Sie die Methode addHistoricMessage(), um einer Direktantwort-Unterhaltung Kontext zu verleihen, indem Sie der Benachrichtigung ältere Nachrichten hinzufügen.

„Intelligente Antwort“ aktivieren

  • Wenn Sie die Funktion „Intelligente Antwort“ aktivieren möchten, rufen Sie setAllowGeneratedResponses(true) für die Antwortaktion auf. Dadurch sind die Antworten der Funktion „Intelligente Antwort“ für Nutzer verfügbar, wenn die Benachrichtigung an ein Wear OS-Gerät weitergeleitet wird. Die Antworten der Funktion „Intelligente Antwort“ werden von einem Machine-Learning-Modell generiert, das vollständig auf der Smartwatch ausgeführt wird. Dabei wird der Kontext der NotificationCompat.MessagingStyle-Benachrichtigung verwendet. Es werden keine Daten ins Internet hochgeladen, um die Antworten zu generieren.

Benachrichtigungsmetadaten hinzufügen