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 Versionen von Android verfügbar sind, und gleichzeitig die Kompatibilität mit Android 9 (API-Level 28) beibehalten. Einige Funktionen, z. B. die Inline-Antwortaktion, 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 finden Sie unter Aufbau von Benachrichtigungen.

Laufzeitberechtigung deklarieren

In Android 13 (API‑Level 33) und höher wird eine Laufzeitberechtigung zum Senden von Benachrichtigungen, bei denen die Zustimmung erforderlich ist (einschließlich Benachrichtigungen von Diensten im Vordergrund), über eine 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 builder = NotificationCompat.Builder(context, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .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 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.notification_icon)
        .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:

private 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(Context.NOTIFICATION_SERVICE) as NotificationManager
        notificationManager.createNotificationChannel(channel)
    }
}

Da Sie den Benachrichtigungskanal erstellen müssen, bevor Sie Benachrichtigungen unter Android 8.0 und höher senden, sollten Sie diesen Code ausführen, sobald Ihre App gestartet wird. Dieser Aufruf kann wiederholt erfolgen, da beim Erstellen eines vorhandenen Benachrichtigungskanals keine Aktion ausgeführt wird.

Für den NotificationChannel-Konstruktor ist ein importance erforderlich, das eine der Konstanten aus der Klasse NotificationManager verwendet. Mit diesem Parameter wird festgelegt, wie der Nutzer bei Benachrichtigungen, die zu diesem Channel gehören, unterbrochen wird. Legen Sie die priority 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 wie im folgenden Beispiel gezeigt festlegen, das System garantiert jedoch nicht das angezeigte Verhalten. In einigen Fällen kann das System die Wichtigkeit basierend auf anderen Faktoren ändern. Nutzer können die Wichtigkeit für einen bestimmten Channel aber jederzeit neu festlegen.

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

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.notification_icon)
        .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 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(NOTIFICATION_ID, 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, in dem Sie Benachrichtigungen anfordern.

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.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        .setContentIntent(pendingIntent)
        .addAction(R.drawable.ic_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, erfahren Sie hier, wie Sie eine Benachrichtigung mit Mediensteuerelementen erstellen.

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 „Direktantwort“ 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, 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.
private val KEY_TEXT_REPLY = "key_text_reply"
val replyLabel: String = context.resources.getString(R.string.reply_label)
val remoteInput: RemoteInput = RemoteInput.Builder(KEY_TEXT_REPLY).run {
    setLabel(replyLabel)
    build()
}

Erstelle eine PendingIntent für die Antwortaktion.

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

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.ic_reply_icon,
        context.getString(R.string.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 direkte Antworten 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.ic_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 KEY_REPLY = "key_reply"
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
            try {
                val inputStream = context.contentResolver.openInputStream(imageUri)
                val bitmap = BitmapFactory.decodeStream(inputStream)
                // Display the image
                // ...
            } catch (e: Exception) {
                Log.e("ReplyReceiver", "Failed to process image URI", e)
            }
        }
    }
}

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

Hängen Sie die Antwort unten an die Benachrichtigung an, indem Sie setRemoteInputHistory() aufrufen. 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 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.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        .setFullScreenIntent(fullScreenPendingIntent, true)

Sichtbarkeit des Sperrbildschirms festlegen

Wenn Sie den Detaillierungsgrad der Benachrichtigung auf dem Sperrbildschirm festlegen möchten, 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 „Du hast 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. 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 sichtbar sind. Er 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 eines der folgenden Ereignisse 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 user = Person.Builder()
    .setIcon(userIcon)
    .setName(userName)
    .build()

val notification = NotificationCompat.Builder(context, CHANNEL_ID)
    .setContentTitle("2 new messages with $sender")
    .setContentText(subject)
    .setSmallIcon(R.drawable.new_message)
    .setStyle(NotificationCompat.MessagingStyle(user)
        .addMessage(messages[1].getText(), messages[1].getTime(), messages[1].getPerson())
        .addMessage(messages[2].getText(), messages[2].getTime(), messages[2].getPerson())
    )
    .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 Unterhaltung mit direkten Antworten 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) in der 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 verwendet, der durch die NotificationCompat.MessagingStyle-Benachrichtigung bereitgestellt wird. Es werden keine Daten ins Internet hochgeladen, um die Antworten zu generieren.

Metadaten für Benachrichtigungen hinzufügen