Benachrichtigung erstellen

Benachrichtigungen enthalten kurze, zeitnahe Informationen zu Ereignissen in Ihrer App, wenn sie nicht verwendet wird. In diesem Dokument wird beschrieben, wie Sie eine Benachrichtigung mit verschiedenen Funktionen erstellen. Eine Einführung in die Darstellung von Benachrichtigungen unter Android finden Sie in der Übersicht über Benachrichtigungen. Beispielcode, in dem Benachrichtigungen verwendet werden, finden Sie im SociaLite-Beispiel auf GitHub.

Im Code auf dieser Seite werden die NotificationCompat APIs aus der AndroidX-Bibliothek verwendet. 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) beibehalten. Einige Funktionen, z. B. die Inline-Antwort, führen jedoch in 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 wenig 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 etwas Text.

Weitere Informationen zu den einzelnen Teilen einer Benachrichtigung

Laufzeitberechtigung deklarieren

In Android 13 (API‑Level 33) und höher wird eine Laufzeitberechtigung zum Senden von Benachrichtigungen, bei denen ihre Zustimmung erforderlich ist (einschließlich Diensten im Vordergrund), aus einer App unterstützt.

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

<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 Eigenschaften 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 wurde.

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

  • Die von setPriority() festgelegte Benachrichtigungspriorität. Die Priorität bestimmt, wie aufdringlich die Benachrichtigung unter Android 7.1 und niedriger ist. Unter Android 8.0 und höher legen Sie 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-Ebene 26) und höher erforderlich, wird jedoch 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 maximierbare Benachrichtigung erstellen.

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

Wenn du möchtest, dass mehr Text in deiner Benachrichtigung angezeigt wird, 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 Benachrichtigungen erstellen.

Channel 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 in der Version SDK_INT 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 beim Start Ihrer App aus. Es ist sicher, den Aufruf wiederholt auszuführen, da beim Erstellen eines vorhandenen Channels nichts passiert.

Der NotificationChannel-Konstruktor erfordert eine Wichtigkeitsstufe, die mit einer NotificationManager-Konstante angegeben wird. Dies bestimmt, wie der Nutzer unterbrochen wird. Um Android 7.1 und niedriger zu unterstützen, legen Sie die Priorität auch mit setPriority() fest, wie im vorherigen Beispiel gezeigt.

Sie müssen zwar die Wichtigkeit oder Priorität festlegen, das System garantiert jedoch nicht das Benachrichtigungsverhalten. Das System kann die Wichtigkeit basierend auf anderen Faktoren anpassen. Nutzer können die Wichtigkeit eines Kanals jederzeit anpassen.

Weitere Informationen zu den verschiedenen Benachrichtigungsstufen

Tippaktion für die Benachrichtigung festlegen

Jede Benachrichtigung muss auf ein Tippen reagieren, in der Regel, um eine Aktivität in Ihrer App zu öffnen, die der Benachrichtigung entspricht. Geben Sie dazu eine Inhaltsabsicht an, die mit einem PendingIntent-Objekt definiert ist, und übergeben Sie sie 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)

Mit diesem Code wird setAutoCancel() aufgerufen, 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 beibehalten wird, 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 Aktivitäten sind möglich:

  • Eine Aktivität, die ausschließlich für Antworten auf die Benachrichtigung vorhanden ist. Es gibt keinen Grund, warum der Nutzer während der normalen App-Nutzung zu dieser Aktivität navigiert. Daher wird durch die Aktivität eine neue Aufgabe gestartet, anstatt sie der vorhandenen Aufgabe und dem Backstack Ihrer App hinzuzufügen. Dies ist der Typ von Intent, 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 Backstack erstellt, damit die Erwartungen des Nutzers an die Zurück- und Auf-Schaltflächen 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())

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 grundlegende Benachrichtigungen auf Geräten mit Android 13 und höher testen möchten, müssen Sie Benachrichtigungen manuell aktivieren oder ein Dialogfeld erstellen, 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 zu verschieben oder auf eine Nachricht 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: Benachrichtigung mit einem Aktionsbutton.

Wenn Sie einen Aktionsbutton hinzufügen möchten, übergeben Sie ein PendingIntent an die Methode addAction(). 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 einen Job im Hintergrund ausführt, damit die Aktion die bereits geöffnete App nicht unterbricht.

Der folgende Code zeigt beispielsweise, wie eine Broadcast-Nachricht 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 zum Ausführen von Hintergrundaufgaben 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 Pausieren und Überspringen von Titeln, finden Sie hier Informationen dazu.

Direktantwortaktion hinzufügen

Mit der in Android 7.0 (API-Ebene 24) eingeführten Aktion für die 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. Mit einer Aktion für die direkte Antwort können Nutzer beispielsweise direkt in der Benachrichtigung auf SMS antworten oder Aufgabenlisten aktualisieren.

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

Die Aktion „Direkt antworten“ wird als zusätzliche Schaltfläche in der Benachrichtigung angezeigt, über die ein Texteingabefeld geöffnet wird. Wenn der Nutzer die Eingabe beendet hat, hängt das System die Textantwort an den Intent an, den Sie für die Benachrichtigungsaktion angegeben haben, und sendet den Intent an Ihre App.

Button „Antworten“ hinzufügen

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

Erstellen Sie eine Instanz von RemoteInput.Builder, die Sie Ihrer Benachrichtigungsaktion hinzufügen können. 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 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)

aufrufen.

Hängen Sie das Objekt RemoteInput 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()

Die Aktion wird auf eine Benachrichtigung angewendet und die Benachrichtigung wird ausgegeben.

// 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).

Nutzer-Eingabe aus der Antwort abrufen

Wenn Sie Nutzereingaben über die Antwort-UI der Benachrichtigung empfangen möchten, rufen Sie RemoteInput.getResultsFromIntent() auf und übergeben Sie die Intent, die von Ihrem BroadcastReceiver empfangen wurde:

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

Aktualisieren Sie die Benachrichtigung nach der Verarbeitung des Texts, indem Sie NotificationManagerCompat.notify() mit derselben ID und demselben Tag (falls verwendet) aufrufen. Das ist erforderlich, um die Benutzeroberfläche für die direkte Antwort 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 mit RemoteInput funktioniert ä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"
    }
}

Verwenden Sie bei dieser neuen Benachrichtigung den Kontext, der an die onReceive()-Methode des Empfängers übergeben wird.

Hänge die Antwort an das Ende der Benachrichtigung an, indem du setRemoteInputHistory() aufrufst. Wenn Sie jedoch eine Messaging-App entwickeln, 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 ausgelöst 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 abdeckt.
  • Wenn das Gerät des Nutzers entsperrt ist, wird die Benachrichtigung in erweiterter Form angezeigt. Sie enthält Optionen zum Bearbeiten 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)

Sichtbarkeit des Sperrbildschirms 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 Benachrichtigungssymbol und der Inhaltstitel 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 kann beispielsweise eine Benachrichtigung mit dem Text „Sie haben 3 neue SMS“ anzeigen, aber den Inhalt der Nachrichten und die Absender ausblenden. Um diese alternative Benachrichtigung bereitzustellen, erstellen Sie zuerst die alternative Benachrichtigung mit NotificationCompat.Builder wie gewohnt. Hängen Sie dann die alternative Benachrichtigung mit setPublicVersion() an die normale Benachrichtigung an.

Der Nutzer hat immer die volle Kontrolle darüber, ob seine Benachrichtigungen auf dem Sperrbildschirm angezeigt werden, und kann sie anhand der Benachrichtigungschannels Ihrer App verwalten.

Benachrichtigung aktualisieren

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

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

Benachrichtigung entfernen

Benachrichtigungen bleiben sichtbar, bis einer der folgenden Fälle eintritt:

  • Der Nutzer schließt die Benachrichtigung.
  • Der Nutzer tippt auf die Benachrichtigung, wenn Sie setAutoCancel() aufrufen, wenn Sie die Benachrichtigung erstellen.
  • 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 ausgegebenen Benachrichtigungen entfernt werden.
  • Die angegebene Dauer läuft ab, wenn Sie beim Erstellen der Benachrichtigung mit setTimeoutAfter() ein Zeitlimit festlegen. Bei Bedarf können Sie eine Benachrichtigung abbrechen, bevor das angegebene Zeitlimit abläuft.

Best Practices für Messaging-Apps

Berücksichtigen Sie die hier aufgeführten Best Practices, wenn Sie Benachrichtigungen für Ihre Messaging- und Chat-Apps erstellen.

MessagingStyle verwenden

Ab Android 7.0 (API-Level 24) bietet Android eine Benachrichtigungsstilvorlage speziell für Messaging-Inhalte. Mit der Klasse NotificationCompat.MessagingStyle können Sie mehrere Labels ändern, die in der Benachrichtigung angezeigt werden, z. B. den Konversationstitel, zusätzliche Nachrichten und die 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-Ebene 28) ist es auch erforderlich, die Klasse Person zu verwenden, um eine optimale Darstellung der Benachrichtigung und ihrer Avatare zu erhalten.

Gehen Sie bei der 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 Unterhaltungstitel ist beispielsweise der Name des Gruppenchats oder, falls dieser keinen Namen hat, eine Liste der Teilnehmer der Unterhaltung. Andernfalls könnte die Nachricht fälschlicherweise als Teil einer Einzelunterhaltung 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 Funktion „Direkte Antwort“ können Nutzer inline auf eine Nachricht antworten.

  • Nachdem ein Nutzer mit der Inline-Antwortaktion geantwortet hat, verwenden Sie MessagingStyle.addMessage(), um die MessagingStyle-Benachrichtigung zu aktualisieren. Ziehen Sie die Benachrichtigung nicht zurück und brechen Sie sie nicht ab. Wenn die Benachrichtigung nicht geschlossen wird, 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 Methode addHistoricMessage(), um einer Direktantwort-Unterhaltung Kontext hinzuzufügen, indem Sie der Benachrichtigung frühere Nachrichten hinzufügen.

„Intelligente Antwort“ aktivieren

  • Um die Funktion „Intelligente Antwort“ zu aktivieren, rufen Sie setAllowGeneratedResponses(true) für die Antwortaktion auf. Dadurch sind Smart Reply-Antworten für Nutzer verfügbar, wenn die Benachrichtigung an ein Wear OS-Gerät weitergeleitet wird. Antworten für die 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.

Metadaten für Benachrichtigungen hinzufügen