Benachrichtigung erstellen

Benachrichtigungen liefern kurze, zeitnahe Informationen zu Ereignissen in Ihrer App, wenn sie nicht verwendet wird. In diesem Dokument wird gezeigt, wie Sie eine Benachrichtigung mit verschiedenen Funktionen erstellen. Eine Einführung in die Darstellung von Benachrichtigungen unter Android, finden Sie in der Übersicht zu 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) gewährleisten. Einige Funktionen wie die Inline-Antwortaktion führen jedoch in früheren Versionen zu einer No-Op.

Einfache Benachrichtigung erstellen

Eine Benachrichtigung in ihrer einfachsten und kompaktesten Form, auch minimierte Form genannt, zeigt ein Symbol, einen Titel und eine kleine Menge Textinhalt an. In diesem Abschnitt wird gezeigt, wie Sie eine Benachrichtigung erstellen, die der Nutzer antippen kann, um eine Aktivität in Ihrer App zu starten.

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

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

Laufzeitberechtigung deklarieren

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

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. Das folgende Beispiel zeigt, wie Sie eine Benachrichtigung mit den folgenden Elementen erstellen:

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

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

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

  • Die Benachrichtigungspriorität, die mit setPriority() festgelegt wird. Die Priorität bestimmt, wie aufdringlich die Benachrichtigung unter Android 7.1 und früher ist. Unter Android 8.0 und höher legen Sie stattdessen die Kanalwichtigkeit fest, wie im nächsten Abschnitt gezeigt.

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.

Der Textinhalt einer Benachrichtigung wird standardmäßig auf eine Zeile gekürzt. Sie können zusätzliche Informationen anzeigen, indem Sie eine erweiterbare Benachrichtigung erstellen.

Abbildung 2 : Eine erweiterbare Benachrichtigung in ihrer minimierten und maximierten Form.

Wenn Ihre Benachrichtigung länger sein soll, können Sie eine erweiterbare Benachrichtigung aktivieren, indem Sie mit setStyle() eine Stilvorlage hinzufügen. Mit dem folgenden Code wird beispielsweise ein größeres Textfeld 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 Erweiterbare 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. Dazu übergeben Sie 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 senden, führen Sie diesen Code aus, sobald Ihre App gestartet wird. Sie können ihn bedenkenlos wiederholt aufrufen, da beim Erstellen eines vorhandenen Benachrichtigungskanals keine Aktion ausgeführt wird.

Der NotificationChannel-Konstruktor erfordert eine importance mit einer der Konstanten aus der NotificationManager-Klasse. Dieser Parameter bestimmt, wie der Nutzer für Benachrichtigungen unterbrochen wird, die zu diesem Kanal gehören. Legen Sie die Priorität mit setPriority() fest, um Android 7.1 und früher zu unterstützen, wie im vorherigen Beispiel gezeigt.

Sie müssen zwar die Wichtigkeit oder Priorität der Benachrichtigung festlegen, wie im folgenden Beispiel gezeigt, aber das System garantiert nicht das gewünschte Benachrichtigungsverhalten. In einigen Fällen ändert das System die Wichtigkeitsstufe möglicherweise basierend auf anderen Faktoren. Der Nutzer kann die Wichtigkeitsstufe für einen bestimmten Kanal jederzeit neu definieren.

Weitere Informationen zu den verschiedenen Stufen finden Sie unter Wichtigkeitsstufen von Benachrichtigungen.

Tippaktion für die Benachrichtigung festlegen

Jede Benachrichtigung muss auf ein Tippen reagieren, in der Regel durch Öffnen einer Aktivität in Ihrer App, die der Benachrichtigung entspricht. Geben Sie dazu einen Inhalts-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 erwartete Navigation des Nutzers erhalten bleibt, nachdem er Ihre App über die Benachrichtigung geöffnet hat. Je nach Art der Aktivität, die Sie starten, kann es sinnvoll sein, sie zu verwenden. Folgende Möglichkeiten gibt es:

Benachrichtigung anzeigen

Rufen Sie NotificationManagerCompat.notify() auf, um die Benachrichtigung anzuzeigen. Übergeben Sie eine eindeutige ID für die Benachrichtigung und das Ergebnis von NotificationCompat.Builder.build(). Das ist im folgenden Beispiel zu sehen:

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

Speichern Sie die Benachrichtigungs-ID, die Sie an NotificationManagerCompat.notify() übergeben, da Sie sie benötigen, wenn Sie die Benachrichtigung aktualisieren oder entfernen möchten.

Wenn Sie einfache Benachrichtigungen auf Geräten mit Android 13 und höher testen möchten, aktivieren Sie Benachrichtigungen manuell oder erstellen Sie ein Dialogfeld, um Benachrichtigungen anzufordern.

Aktionsschaltflächen hinzufügen

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

Abbildung 3 : Eine Benachrichtigung mit einem Aktionsbutton.

Übergeben Sie ein PendingIntent an die addAction() Methode, um einen Aktionsbutton hinzuzufügen. Das ist so, als würden Sie die Standard-Tippaktion der Benachrichtigung einrichten. Anstatt eine Aktivität zu starten, können Sie jedoch andere Aktionen ausführen, z. B. einen BroadcastReceiver starten, der eine Aufgabe im Hintergrund ausführt, sodass die Aktion die bereits geöffnete App nicht unterbricht.

Der folgende Code zeigt beispielsweise, wie Sie eine Broadcast-Nachricht an einen bestimmten Empfänger senden:

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 zum Ausführen von Hintergrund aufgaben finden Sie in der Übersicht zu Broadcasts.

Wenn Sie stattdessen eine Benachrichtigung mit Schaltflächen für die Medienwiedergabe erstellen möchten, z. B. zum Anhalten und Überspringen von Titeln, finden Sie unter Benachrichtigung mit Medien steuerelementen erstellen weitere Informationen.

Direktantwortaktion hinzufügen

Mit der Direktantwortaktion, die in Android 7.0 (API-Level 24) eingeführt wurde, 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. Sie können beispielsweise eine Direktantwortaktion verwenden, damit Nutzer direkt in der Benachrichtigung auf SMS antworten oder Aufgabenlisten aktualisieren können.

Abbildung 4 : Wenn Sie auf die Schaltfläche „Antworten“ tippen, wird die Texteingabe geöffnet.

Die Direktantwortaktion wird als zusätzliche Schaltfläche in der Benachrichtigung angezeigt, die eine Texteingabe öffnet. Wenn der Nutzer die Eingabe beendet hat, fügt das System die Textantwort an den Intent an, den Sie für die Benachrichtigungsaktion angegeben haben, und sendet den Intent an Ihre App.

Schaltfläche „Antworten“ hinzufügen

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

Erstellen Sie eine Instanz von RemoteInput.Builder die Sie Ihrer Benachrichtigungsaktion hinzufügen können. Der Konstruktor dieser Klasse akzeptiert einen String, der vom System als Schlüssel für die Texteingabe verwendet wird. 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 ein 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 senden Sie die Benachrichtigung.

// 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, wie in Abbildung 4 gezeigt.

Nutzereingabe aus der Antwort abrufen

Rufen Sie RemoteInput.getResultsFromIntent() auf, um Nutzereingaben aus der Antwort-UI der Benachrichtigung zu erhalten. Übergeben Sie dazu den Intent, der von Ihrem BroadcastReceiver empfangen wurde:

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

Nachdem Sie den Text verarbeitet haben, aktualisieren Sie die Benachrichtigung, indem Sie NotificationManagerCompat.notify() mit derselben ID und demselben Tag aufrufen, falls verwendet. Dies ist erforderlich, um die Direktantwort-UI auszublenden und dem Nutzer zu bestätigen, dass seine Antwort korrekt empfangen und 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 ähnlich wie bei RemoteInput. 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 Sie mit dieser neuen Benachrichtigung arbeiten, verwenden Sie den Kontext, der an die Methode des Empfängers onReceive() übergeben wird.

Hängen Sie die Antwort unten an die Benachrichtigung an, indem Sie setRemoteInputHistory() aufrufen. Wenn Sie jedoch eine Messaging-App erstellen, erstellen Sie eine Benachrichtigung im Messaging-Stil und hängen Sie die neue Nachricht an die Unterhaltung an.

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

Dringende Nachricht anzeigen

Ihre App muss möglicherweise eine dringende, zeitkritische Nachricht anzeigen, z. B. einen eingehenden Anruf oder einen klingelnden Wecker. In diesen Fällen können Sie Ihrer Benachrichtigung einen Full-Screen Intent zuordnen.

Wenn die Benachrichtigung aufgerufen wird, sehen Nutzer je nach Sperrstatus des Geräts eine der folgenden Optionen:

  • Wenn das Gerät des Nutzers gesperrt ist, wird eine Vollbildaktivität angezeigt, die den Sperrbildschirm abdeckt.
  • Wenn das Gerät des Nutzers entsperrt ist, wird die Benachrichtigung in erweiterter Form angezeigt, einschließlich Optionen zum Verarbeiten oder Schließen der Benachrichtigung.

Das folgende Code-Snippet zeigt, 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)

Sperrbildschirm-Sichtbarkeit festlegen

Rufen Sie setVisibility() auf und geben Sie einen der folgenden Werte an, um den Detaillierungsgrad zu steuern, der in der Benachrichtigung auf dem Sperrbildschirm sichtbar ist:

  • 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 bereitstellen, in der bestimmte Details ausgeblendet sind. Eine SMS-App kann beispielsweise eine Benachrichtigung anzeigen, die „Sie haben 3 neue SMS“ enthält, aber den Inhalt der Nachrichten und die Absender ausblendet. Um diese alternative Benachrichtigung bereitzustellen, erstellen Sie sie zuerst wie gewohnt mit NotificationCompat.Builder. Hängen Sie dann die alternative Benachrichtigung mit setPublicVersion() an die normale Benachrichtigung an.

Beachten Sie, dass der Nutzer immer die volle Kontrolle darüber hat, ob seine Benachrichtigungen auf dem Sperrbildschirm sichtbar sind, und sie anhand der Benachrichtigungskanäle Ihrer App steuern kann.

Benachrichtigung aktualisieren

Wenn Sie eine Benachrichtigung nach dem Senden aktualisieren möchten, rufen Sie NotificationManagerCompat.notify() noch einmal auf und übergeben Sie dieselbe ID wie zuvor. Wenn die vorherige Benachrichtigung geschlossen wurde, wird stattdessen eine neue Benachrichtigung erstellt.

Optional können Sie setOnlyAlertOnce() aufrufen, damit Ihre Benachrichtigung den Nutzer nur beim ersten Erscheinen mit Ton, Vibration oder visuellen Hinweisen unterbricht, nicht bei späteren Aktualisierungen.

Benachrichtigung entfernen

Benachrichtigungen bleiben sichtbar, bis eine der folgenden Bedingungen erfüllt ist:

  • 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.
  • Sie rufen cancelAll() auf, wodurch alle zuvor gesendeten 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 das angegebene Zeitlimit abläuft.

Best Practices für Messaging-Apps

Beachten Sie beim Erstellen von Benachrichtigungen für Ihre Messaging- und Chat-Apps die hier aufgeführten Best Practices.

MessagingStyle verwenden

Ab Android 7.0 (API-Level 24) bietet Android eine Benachrichtigungsstilvorlage speziell für Messaging-Inhalte. Mit der NotificationCompat.MessagingStyle Klasse können Sie mehrere der Labels ändern, die in der Benachrichtigung angezeigt werden, einschließlich des Unterhaltungstitels, zusätzlicher Nachrichten und der Inhaltsansicht für die Benachrichtigung.

Das folgende Code-Snippet zeigt, wie Sie den Stil einer Benachrichtigung mit der Klasse MessagingStyle anpassen.

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 auch erforderlich, die Person Klasse zu verwenden, um eine optimale Darstellung der Benachrichtigung und ihrer Avatare zu erhalten.

Beachten Sie bei der Verwendung von NotificationCompat.MessagingStyle Folgendes:

  • Rufen Sie MessagingStyle.setConversationTitle() auf, um einen Titel für Gruppen chats mit mehr als zwei Personen festzulegen. Ein guter Unterhaltungstitel kann der Name des Gruppenchats oder, falls er keinen Namen hat, eine Liste der Teilnehmer der Unterhaltung sein. Andernfalls wird die Nachricht möglicherweise fälschlicherweise einer Einzelunterhaltung mit dem Absender der letzten Nachricht in der Unterhaltung zugeordnet.
  • Verwenden Sie die MessagingStyle.setData() Methode, um Mediennachrichten wie Bilder einzufügen. MIME-Typen des Musters image/* werden unterstützt.

Direktantwort verwenden

Mit der Direktantwort kann ein Nutzer direkt auf eine Nachricht antworten.

  • Nachdem ein Nutzer mit der Inline-Antwortaktion geantwortet hat, verwenden Sie MessagingStyle.addMessage(), um die MessagingStyle Benachrichtigung zu aktualisieren, und ziehen Sie die Benachrichtigung nicht zurück oder brechen Sie sie nicht ab. Wenn Sie die Benachrichtigung nicht abbrechen, kann der Nutzer mehrere Antworten über die Benachrichtigung senden.
  • Damit die Inline-Antwortaktion mit Wear OS kompatibel ist, rufen Sie Action.WearableExtender.setHintDisplayInlineAction(true) auf.
  • Verwenden Sie die addHistoricMessage() Methode, um einer Direktantwortunterhaltung Kontext zu geben, indem Sie der Benachrichtigung frühere Nachrichten hinzufügen.

Intelligente Antwort aktivieren

  • Rufen Sie setAllowGeneratedResponses(true) für die Antwortaktion auf, um die Funktion „Intelligente Antwort“ zu aktivieren. Dadurch sind intelligente Antworten für Nutzer verfügbar, wenn die Benachrichtigung an ein Wear OS-Gerät weitergeleitet wird. Intelligente Antworten werden von einem vollständig auf der Smartwatch ausgeführten Modell für maschinelles Lernen generiert, das den Kontext der NotificationCompat.MessagingStyle-Benachrichtigung verwendet. Es werden keine Daten ins Internet hochgeladen, um die Antworten zu generieren.

Benachrichtigungsmetadaten hinzufügen