Benachrichtigungen enthalten kurze, aktuelle Informationen zu Ereignissen in deiner App, während sie nicht verwendet wird. In diesem Dokument erfährst du, wie du eine Benachrichtigung mit verschiedenen Funktionen erstellst. Eine Einführung dazu, wie Benachrichtigungen unter Android angezeigt werden, findest du unter Benachrichtigungen. Beispielcode, der Benachrichtigungen verwendet, finden Sie im People-Beispiel auf GitHub.
Im Code auf dieser Seite werden die NotificationCompat APIs aus der AndroidX-Bibliothek verwendet. Mit diesen APIs kannst du Funktionen hinzufügen, die nur unter neueren Versionen von Android verfügbar sind, und gleichzeitig Kompatibilität mit Android 9 (API-Level 28) ermöglichen. Einige Funktionen wie die Inline-Antwort führen jedoch in früheren Versionen zu einer Nulloperation.
AndroidX Core-Bibliothek hinzufügen
Die meisten mit Android Studio erstellten Projekte enthalten die erforderlichen Abhängigkeiten für die Verwendung von NotificationCompat. Prüfen Sie jedoch, ob Ihre build.gradle-Datei auf Modulebene die folgende Abhängigkeit enthält:
Cool
dependencies {
implementation "androidx.core:core:2.2.0"
}
Kotlin
dependencies {
implementation("androidx.core:core-ktx:2.2.0")
}
Grundlegende Benachrichtigung erstellen
Eine Benachrichtigung in ihrer einfachsten und kompaktsten Form – auch als minimierte Form bezeichnet – enthält ein Symbol, einen Titel und eine kleine Menge Textinhalt. In diesem Abschnitt wird beschrieben, 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 Benachrichtigungsanalyse.
Laufzeitberechtigung deklarieren
Android 13 (API-Level 33) und höher unterstützt eine Laufzeitberechtigung zum Senden von nicht ausgenommenen Benachrichtigungen (einschließlich FGS) 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
Lege zuerst mithilfe eines NotificationCompat.Builder-Objekts den Inhalt und den Kanal der Benachrichtigung fest. Das folgende Beispiel zeigt, wie du eine Benachrichtigung mit folgenden Elementen erstellst:
Ein kleines Symbol, das von
setSmallIcon()festgelegt wird. Dies ist der einzige für den Nutzer sichtbare Inhalt, der erforderlich ist.Ein von
setContentTitle()festgelegter Titel.Der von
setContentText()festgelegte Textkörper.Die durch
setPriority()festgelegte Benachrichtigungspriorität. Die Priorität bestimmt, wie aufdringlich die Benachrichtigung unter Android 7.1 und früher ist. Unter Android 8.0 und höher musst du stattdessen die Kanalwichtigkeit wie im nächsten Abschnitt beschrieben festlegen.
Kotlin
var builder = NotificationCompat.Builder(this, CHANNEL_ID)
.setSmallIcon(R.drawable.notification_icon)
.setContentTitle(textTitle)
.setContentText(textContent)
.setPriority(NotificationCompat.PRIORITY_DEFAULT)
Java
NotificationCompat.Builder builder = new NotificationCompat.Builder(this, 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 aus Gründen der Kompatibilität mit Android 8.0 (API-Level 26) und höher erforderlich, wird in früheren Versionen jedoch ignoriert.
Standardmäßig wird der Textinhalt der Benachrichtigung auf eine Zeile gekürzt. Sie können eine maximierbare Benachrichtigung erstellen, um zusätzliche Informationen anzuzeigen.
Abbildung 2: Eine maximierbare Benachrichtigung in minimierter und maximierter Form.
Wenn Sie möchten, dass die Benachrichtigung länger ist, können Sie eine maximierbare Benachrichtigung aktivieren, indem Sie mit setStyle() eine Stilvorlage hinzufügen.
Mit dem folgenden Code wird beispielsweise ein größerer Textbereich erstellt:
Kotlin
var builder = NotificationCompat.Builder(this, 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)
Java
NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
.setSmallIcon(R.drawable.notification_icon)
.setContentTitle("My notification")
.setContentText("Much longer text that cannot fit one line...")
.setStyle(new NotificationCompat.BigTextStyle()
.bigText("Much longer text that cannot fit one line..."))
.setPriority(NotificationCompat.PRIORITY_DEFAULT);
Weitere Informationen zu anderen großen Benachrichtigungsstilen, z. B. zum Hinzufügen von Bildern und 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 in der Version SDK_INT blockiert:
Kotlin
private fun createNotificationChannel() {
// 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 = getString(R.string.channel_name)
val descriptionText = 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 =
getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
notificationManager.createNotificationChannel(channel)
}
}
Java
private void createNotificationChannel() {
// 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) {
CharSequence name = getString(R.string.channel_name);
String description = getString(R.string.channel_description);
int importance = NotificationManager.IMPORTANCE_DEFAULT;
NotificationChannel channel = new NotificationChannel(CHANNEL_ID, name, importance);
channel.setDescription(description);
// Register the channel with the system; you can't change the importance
// or other notification behaviors after this.
NotificationManager notificationManager = getSystemService(NotificationManager.class);
notificationManager.createNotificationChannel(channel);
}
}
Da Sie unter Android 8.0 und höher den Benachrichtigungskanal erstellen müssen, bevor Sie Benachrichtigungen veröffentlichen, führen Sie diesen Code aus, sobald Ihre App gestartet wird. Dieser kann problemlos wiederholt aufgerufen werden, da beim Erstellen eines vorhandenen Benachrichtigungskanals kein Vorgang ausgeführt wird.
Für den NotificationChannel-Konstruktor ist ein importance erforderlich, für das eine der Konstanten aus der Klasse NotificationManager verwendet wird. Dieser Parameter legt fest, wie der Nutzer bei Benachrichtigungen, die zu diesem Kanal gehören, unterbrochen werden soll. Legen Sie die Priorität mit setPriority() so fest, dass sie Android 7.1 und frühere Versionen unterstützt, wie im vorherigen Beispiel gezeigt.
Obwohl Sie die Wichtigkeit oder Priorität der Benachrichtigungen festlegen müssen, wie im folgenden Beispiel gezeigt, kann das System das Benachrichtigungsverhalten nicht garantieren. In einigen Fällen kann das System die Prioritätsstufe basierend auf anderen Faktoren ändern und der Nutzer kann die Prioritätsstufe für einen bestimmten Kanal jederzeit neu definieren.
Weitere Informationen zur Bedeutung der verschiedenen Stufen finden Sie unter Wichtigkeitsstufen von Benachrichtigungen.
Tippaktion der Benachrichtigung festlegen
Jede Benachrichtigung muss auf ein Tippen reagieren. Dies geschieht in der Regel, um eine Aktivität in Ihrer App zu öffnen, die der Benachrichtigung entspricht. Dazu geben Sie einen Inhalts-Intent an, der mit einem PendingIntent-Objekt definiert ist, und übergeben es 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:
Kotlin
// Create an explicit intent for an Activity in your app.
val intent = Intent(this, AlertDetails::class.java).apply {
flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
}
val pendingIntent: PendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_IMMUTABLE)
val builder = NotificationCompat.Builder(this, 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)
Java
// Create an explicit intent for an Activity in your app.
Intent intent = new Intent(this, AlertDetails.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_IMMUTABLE);
NotificationCompat.Builder builder = new NotificationCompat.Builder(this, 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. Dadurch wird die Benachrichtigung automatisch entfernt, wenn der Nutzer darauf tippt.
Mit der im vorherigen Beispiel gezeigten Methode setFlags() bleibt die erwartete Navigation erhalten, nachdem der Nutzer die App über die Benachrichtigung geöffnet hat. Sie können sie je nach Art der Aktivität verwenden, die Sie starten. Dabei kann es sich um eine der folgenden Optionen handeln:
Eine Aktivität, die ausschließlich für Antworten auf die Benachrichtigung dient. Der Nutzer wechselt bei normaler App-Nutzung nicht zu dieser Aktivität. Die Aktivität startet also eine neue Aufgabe und wird nicht zur vorhandenen Aufgabe und zum Back-Stack Ihrer App hinzugefügt. Dies ist der im vorherigen Beispiel erstellte Intent-Typ.
Eine Aktivität, die im regulären App-Ablauf Ihrer App vorhanden ist. In diesem Fall wird durch den Start der Aktivität ein Back-Stack erstellt, damit die Erwartungen des Nutzers an die Zurück- und Nach-oben-Schaltflächen erhalten bleiben.
Weitere Informationen zu den verschiedenen Möglichkeiten zum Konfigurieren des Benachrichtigungs-Intents finden Sie unter Aktivität über eine Benachrichtigung starten.
Benachrichtigung anzeigen
Um die Benachrichtigung anzuzeigen, 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 gezeigt:
Kotlin
with(NotificationManagerCompat.from(this)) {
if (ActivityCompat.checkSelfPermission(
this@MainActivity,
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())
}
Java
with(NotificationManagerCompat.from(this)) {
if (ActivityCompat.checkSelfPermission(
this@MainActivity,
Manifest.permission.POST_NOTIFICATIONS
) != PackageManager.PERMISSION_GRANTED
) {
// TODO: Consider calling
// ActivityCompat#requestPermissions
// here to request the missing permissions, and then overriding
// public void onRequestPermissionsResult(int requestCode, String[] permissions,
// int[] grantResults)
// to handle the case where the user grants the permission. See the documentation
// for ActivityCompat#requestPermissions for more details.
return
}
// notificationId is a unique int for each notification that you must define.
notify(NOTIFICATION_ID, builder.build())
}
Speichere die Benachrichtigungs-ID, die du an NotificationManagerCompat.notify() übergibst, da du sie zum Aktualisieren oder Entfernen der Benachrichtigung benötigst.
Wenn Sie grundlegende Benachrichtigungen auf Geräten mit Android 13 und höher testen möchten, müssen Sie die Benachrichtigungen außerdem 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 zurückzustellen 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 einer Aktionsschaltfläche.
Wenn Sie eine Aktionsschaltfläche hinzufügen möchten, übergeben Sie eine PendingIntent an die Methode addAction(). Dies entspricht dem Einrichten der standardmäßigen Tippaktion für die Benachrichtigung. Allerdings können Sie statt einer Aktivität auch andere Aktionen ausführen, z. B. einen BroadcastReceiver starten, der einen Job im Hintergrund ausführt, damit die bereits geöffnete App nicht unterbrochen wird.
Der folgende Code zeigt beispielsweise, wie ein Broadcast an einen bestimmten Empfänger gesendet wird:
Kotlin
val ACTION_SNOOZE = "snooze"
val snoozeIntent = Intent(this, MyBroadcastReceiver::class.java).apply {
action = ACTION_SNOOZE
putExtra(EXTRA_NOTIFICATION_ID, 0)
}
val snoozePendingIntent: PendingIntent =
PendingIntent.getBroadcast(this, 0, snoozeIntent, 0)
val builder = NotificationCompat.Builder(this, CHANNEL_ID)
.setSmallIcon(R.drawable.notification_icon)
.setContentTitle("My notification")
.setContentText("Hello World!")
.setPriority(NotificationCompat.PRIORITY_DEFAULT)
.setContentIntent(pendingIntent)
.addAction(R.drawable.ic_snooze, getString(R.string.snooze),
snoozePendingIntent)
Java
String ACTION_SNOOZE = "snooze"
Intent snoozeIntent = new Intent(this, MyBroadcastReceiver.class);
snoozeIntent.setAction(ACTION_SNOOZE);
snoozeIntent.putExtra(EXTRA_NOTIFICATION_ID, 0);
PendingIntent snoozePendingIntent =
PendingIntent.getBroadcast(this, 0, snoozeIntent, 0);
NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
.setSmallIcon(R.drawable.notification_icon)
.setContentTitle("My notification")
.setContentText("Hello World!")
.setPriority(NotificationCompat.PRIORITY_DEFAULT)
.setContentIntent(pendingIntent)
.addAction(R.drawable.ic_snooze, getString(R.string.snooze),
snoozePendingIntent);
Weitere Informationen zum Erstellen eines BroadcastReceiver für die Ausführung von Hintergrundarbeit finden Sie unter Broadcasts – Übersicht.
Wenn Sie stattdessen eine Benachrichtigung mit Schaltflächen für die Medienwiedergabe erstellen möchten, z. B. zum Pausieren und Überspringen von Titeln, sehen Sie sich an, wie Sie eine Benachrichtigung mit Mediensteuerelementen erstellen.
Direktantwort-Aktion hinzufügen
Mit der in Android 7.0 (API-Ebene 24) eingeführten Direktantwort-Aktion können Nutzer Text direkt in die Benachrichtigung eingeben. Der Text wird dann an Ihre App übermittelt, ohne eine Aktivität zu öffnen. Beispielsweise können Sie mit einer Direktantwort-Aktion zulassen, dass Nutzer direkt in der Benachrichtigung auf Textnachrichten antworten oder Aufgabenlisten aktualisieren können.
Abbildung 4: Über die Schaltfläche „Antworten“ wird die Texteingabe geöffnet.
Die Direktantwort-Aktion wird als zusätzliche Schaltfläche in der Benachrichtigung angezeigt, mit der eine Texteingabe geöffnet wird. Wenn der Nutzer mit der Eingabe fertig ist, hängt das System die Textantwort an den Intent an, den Sie für die Benachrichtigungsaktion angeben, 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 der 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 Eingabetext abzurufen.Kotlin
// Key for the string that's delivered in the action's intent. private val KEY_TEXT_REPLY = "key_text_reply" var replyLabel: String = resources.getString(R.string.reply_label) var remoteInput: RemoteInput = RemoteInput.Builder(KEY_TEXT_REPLY).run { setLabel(replyLabel) build() }Java
// Key for the string that's delivered in the action's intent. private static final String KEY_TEXT_REPLY = "key_text_reply"; String replyLabel = getResources().getString(R.string.reply_label); RemoteInput remoteInput = new RemoteInput.Builder(KEY_TEXT_REPLY) .setLabel(replyLabel) .build(); - Erstellen Sie eine
PendingIntentfür die Antwortaktion.Kotlin
// Build a PendingIntent for the reply action to trigger. var replyPendingIntent: PendingIntent = PendingIntent.getBroadcast(applicationContext, conversation.getConversationId(), getMessageReplyIntent(conversation.getConversationId()), PendingIntent.FLAG_UPDATE_CURRENT)Java
// Build a PendingIntent for the reply action to trigger. PendingIntent replyPendingIntent = PendingIntent.getBroadcast(getApplicationContext(), conversation.getConversationId(), getMessageReplyIntent(conversation.getConversationId()), PendingIntent.FLAG_UPDATE_CURRENT); - Hängen Sie das Objekt
RemoteInputmithilfe vonaddRemoteInput()an eine Aktion an.Kotlin
// Create the reply action and add the remote input. var action: NotificationCompat.Action = NotificationCompat.Action.Builder(R.drawable.ic_reply_icon, getString(R.string.label), replyPendingIntent) .addRemoteInput(remoteInput) .build()Java
// Create the reply action and add the remote input. NotificationCompat.Action action = new NotificationCompat.Action.Builder(R.drawable.ic_reply_icon, getString(R.string.label), replyPendingIntent) .addRemoteInput(remoteInput) .build(); - Wenden Sie die Aktion auf eine Benachrichtigung an und geben Sie die Benachrichtigung aus.
Kotlin
// Build the notification and add the action. val newMessageNotification = Notification.Builder(context, CHANNEL_ID) .setSmallIcon(R.drawable.ic_message) .setContentTitle(getString(R.string.title)) .setContentText(getString(R.string.content)) .addAction(action) .build() // Issue the notification. with(NotificationManagerCompat.from(this)) { notificationManager.notify(notificationId, newMessageNotification) }Java
// Build the notification and add the action. Notification newMessageNotification = new Notification.Builder(context, CHANNEL_ID) .setSmallIcon(R.drawable.ic_message) .setContentTitle(getString(R.string.title)) .setContentText(getString(R.string.content)) .addAction(action) .build(); // Issue the notification. NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this); notificationManager.notify(notificationId, newMessageNotification);
Das System fordert den Nutzer zur Eingabe einer Antwort auf, wenn er die Benachrichtigungsaktion auslöst (siehe Abbildung 4).
Nutzereingabe aus Antwort abrufen
Um Nutzereingaben über die Antwort-UI der Benachrichtigung zu erhalten, rufen Sie RemoteInput.getResultsFromIntent() auf und übergeben Sie das von BroadcastReceiver empfangene Intent:
Kotlin
private fun getMessageText(intent: Intent): CharSequence? {
return RemoteInput.getResultsFromIntent(intent)?.getCharSequence(KEY_TEXT_REPLY)
}
Java
private CharSequence getMessageText(Intent intent) {
Bundle remoteInput = RemoteInput.getResultsFromIntent(intent);
if (remoteInput != null) {
return remoteInput.getCharSequence(KEY_TEXT_REPLY);
}
return null;
}
Nachdem du den Text verarbeitet hast, aktualisiere die Benachrichtigung, indem du NotificationManagerCompat.notify() mit derselben ID und demselben Tag (falls verwendet) aufrufst. Dies ist erforderlich, um die Direktantwort-UI auszublenden und dem Nutzer zu bestätigen, dass seine Antwort korrekt empfangen und verarbeitet wurde.
Kotlin
// Build a new notification, which informs the user that the system
// handled their interaction with the previous notification.
val repliedNotification = Notification.Builder(context, CHANNEL_ID)
.setSmallIcon(R.drawable.ic_message)
.setContentText(getString(R.string.replied))
.build()
// Issue the new notification.
NotificationManagerCompat.from(this).apply {
notificationManager.notify(notificationId, repliedNotification)
}
Java
// Build a new notification, which informs the user that the system
// handled their interaction with the previous notification.
Notification repliedNotification = new Notification.Builder(context, CHANNEL_ID)
.setSmallIcon(R.drawable.ic_message)
.setContentText(getString(R.string.replied))
.build();
// Issue the new notification.
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
notificationManager.notify(notificationId, repliedNotification);
Verwenden Sie bei der Arbeit mit dieser neuen Benachrichtigung den Kontext, der an die Methode onReceive() des Empfängers übergeben wird.
Hänge die Antwort unten an die Benachrichtigung an, indem du setRemoteInputHistory() aufrufst.
Wenn Sie jedoch eine Messaging-App erstellen, erstellen Sie eine Benachrichtigung im Nachrichtenstil und hängen Sie die neue Nachricht an die Unterhaltung an.
Weitere Tipps zu Benachrichtigungen von Messaging-Apps finden Sie im Abschnitt Best Practices für Messaging-Apps.
Fortschrittsanzeige hinzufügen
Benachrichtigungen können eine animierte Fortschrittsanzeige enthalten, die Nutzern den Status eines laufenden Vorgangs anzeigt.
Abbildung 5: Die Fortschrittsanzeige während eines Vorgangs.
Wenn Sie jederzeit schätzen können, wie viel des Vorgangs abgeschlossen ist, verwenden Sie die "determinierte" Form des Indikators (siehe Abbildung 5). Rufen Sie dazu setProgress(max, progress,
false) auf.
Der erste Parameter entspricht dem Wert „complete“, z. B. „100“. Das zweite ist, wie viel
fertig ist. Der letzte Balken gibt an, dass dies eine feste Fortschrittsanzeige ist.
Rufen Sie während des Vorgangs kontinuierlich setProgress(max, progress,
false) mit einem aktualisierten Wert für progress auf und geben Sie die Benachrichtigung noch einmal aus, wie im folgenden Beispiel gezeigt.
Kotlin
val builder = NotificationCompat.Builder(this, CHANNEL_ID).apply {
setContentTitle("Picture Download")
setContentText("Download in progress")
setSmallIcon(R.drawable.ic_notification)
setPriority(NotificationCompat.PRIORITY_LOW)
}
val PROGRESS_MAX = 100
val PROGRESS_CURRENT = 0
NotificationManagerCompat.from(this).apply {
// Issue the initial notification with zero progress.
builder.setProgress(PROGRESS_MAX, PROGRESS_CURRENT, false)
notify(notificationId, builder.build())
// Do the job that tracks the progress here.
// Usually, this is in a worker thread.
// To show progress, update PROGRESS_CURRENT and update the notification with:
// builder.setProgress(PROGRESS_MAX, PROGRESS_CURRENT, false);
// notificationManager.notify(notificationId, builder.build());
// When done, update the notification once more to remove the progress bar.
builder.setContentText("Download complete")
.setProgress(0, 0, false)
notify(notificationId, builder.build())
}
Java
...
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID);
builder.setContentTitle("Picture Download")
.setContentText("Download in progress")
.setSmallIcon(R.drawable.ic_notification)
.setPriority(NotificationCompat.PRIORITY_LOW);
// Issue the initial notification with zero progress.
int PROGRESS_MAX = 100;
int PROGRESS_CURRENT = 0;
builder.setProgress(PROGRESS_MAX, PROGRESS_CURRENT, false);
notificationManager.notify(notificationId, builder.build());
// Do the job that tracks the progress here.
// Usually, this is in a worker thread.
// To show progress, update PROGRESS_CURRENT and update the notification with:
// builder.setProgress(PROGRESS_MAX, PROGRESS_CURRENT, false);
// notificationManager.notify(notificationId, builder.build());
// When done, update the notification once more to remove the progress bar.
builder.setContentText("Download complete")
.setProgress(0,0,false);
notificationManager.notify(notificationId, builder.build());
Am Ende des Vorgangs muss progress gleich max sein. Sie können die Fortschrittsanzeige verlassen, um anzuzeigen, dass der Vorgang abgeschlossen ist, oder ihn entfernen. Aktualisieren Sie in beiden Fällen den Benachrichtigungstext, um anzuzeigen, dass der Vorgang abgeschlossen ist. Rufen Sie setProgress(0, 0, false) auf, um die Fortschrittsanzeige zu entfernen.
Rufen Sie setProgress(0, 0, true) auf, um eine unbestimmte Fortschrittsanzeige (ein Balken, der keinen Fortschrittsprozentsatz angibt) anzuzeigen. Das Ergebnis ist ein Indikator mit demselben Stil wie die vorherige Fortschrittsanzeige, mit der Ausnahme, dass es sich um eine fortlaufende Animation handelt, die keinen Abschluss anzeigt. Die Fortschrittsanimation wird ausgeführt, bis Sie setProgress(0, 0, false) aufrufen und dann die Benachrichtigung aktualisieren, um die Aktivitätsanzeige zu entfernen.
Denken Sie daran, den Benachrichtigungstext zu ändern, um anzugeben, dass der Vorgang abgeschlossen ist.
Systemweite Kategorie festlegen
Android verwendet vordefinierte systemweite Kategorien, um zu bestimmen, ob der Nutzer mit einer bestimmten Benachrichtigung gestört wird, wenn er den Modus „Bitte nicht stören“ aktiviert.
Wenn Ihre Benachrichtigung in eine der in NotificationCompat definierten Benachrichtigungskategorien fällt, z. B. CATEGORY_ALARM, CATEGORY_REMINDER, CATEGORY_EVENT oder CATEGORY_CALL, geben Sie dies entsprechend an, indem Sie die entsprechende Kategorie an setCategory() übergeben:
Kotlin
var builder = NotificationCompat.Builder(this, CHANNEL_ID)
.setSmallIcon(R.drawable.notification_icon)
.setContentTitle("My notification")
.setContentText("Hello World!")
.setPriority(NotificationCompat.PRIORITY_DEFAULT)
.setCategory(NotificationCompat.CATEGORY_MESSAGE)
Java
NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
.setSmallIcon(R.drawable.notification_icon)
.setContentTitle("My notification")
.setContentText("Hello World!")
.setPriority(NotificationCompat.PRIORITY_DEFAULT)
.setCategory(NotificationCompat.CATEGORY_MESSAGE);
Anhand dieser Informationen zu deiner Benachrichtigungskategorie entscheidet das System, ob deine Benachrichtigung angezeigt wird, wenn der Modus „Bitte nicht stören“ aktiviert ist. Sie müssen jedoch keine systemweite Kategorie festlegen. Das solltest du nur tun, wenn deine Benachrichtigungen mit einer der in NotificationCompat definierten Kategorien übereinstimmen.
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 abhängig vom Sperrstatus des Geräts eine der folgenden Optionen:
- Wenn das Gerät des Nutzers gesperrt ist, wird eine Aktivität im Vollbildmodus angezeigt, die den Sperrbildschirm verdeckt.
- Wenn das Gerät des Nutzers entsperrt ist, wird die Benachrichtigung in einem erweiterten Format mit Optionen zum Bearbeiten oder Schließen der Benachrichtigung angezeigt.
Das folgende Code-Snippet zeigt, wie Sie Ihre Benachrichtigung mit einem Full-Screen Intent verknüpfen:
Kotlin
val fullScreenIntent = Intent(this, ImportantActivity::class.java)
val fullScreenPendingIntent = PendingIntent.getActivity(this, 0,
fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT)
var builder = NotificationCompat.Builder(this, CHANNEL_ID)
.setSmallIcon(R.drawable.notification_icon)
.setContentTitle("My notification")
.setContentText("Hello World!")
.setPriority(NotificationCompat.PRIORITY_DEFAULT)
.setFullScreenIntent(fullScreenPendingIntent, true)
Java
Intent fullScreenIntent = new Intent(this, ImportantActivity.class);
PendingIntent fullScreenPendingIntent = PendingIntent.getActivity(this, 0,
fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.Builder builder = new NotificationCompat.Builder(this, 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 die Detailebene festlegen möchten, die in der Benachrichtigung auf dem Sperrbildschirm sichtbar ist, 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: Es wird kein Teil der Benachrichtigung auf dem Sperrbildschirm angezeigt.VISIBILITY_PRIVATE: Auf dem Sperrbildschirm werden nur grundlegende Informationen wie das Benachrichtigungssymbol und der Titel des Inhalts angezeigt. Es wird nicht der vollständige Inhalt der Benachrichtigung angezeigt.
Wenn Sie VISIBILITY_PRIVATE festlegen, können Sie auch eine alternative Version des Benachrichtigungsinhalts bereitstellen, in der bestimmte Details ausgeblendet werden. Eine SMS-App könnte beispielsweise eine Benachrichtigung mit der Meldung „Sie haben drei neue Textnachrichten“ anzeigen, aber den Nachrichteninhalt und die Absender ausblenden. Erstellen Sie dazu zuerst wie gewohnt die alternative Benachrichtigung mit NotificationCompat.Builder. Hängen Sie dann die alternative Benachrichtigung mit setPublicVersion() an die normale Benachrichtigung an.
Denken Sie daran, dass der Nutzer immer die vollständige Kontrolle darüber hat, ob seine Benachrichtigungen auf dem Sperrbildschirm angezeigt werden, und sie über die Benachrichtigungskanäle Ihrer App steuern kann.
Benachrichtigung aktualisieren
Wenn Sie eine Benachrichtigung aktualisieren möchten, nachdem Sie sie gesendet haben, rufen Sie noch einmal NotificationManagerCompat.notify() auf und übergeben Sie dabei dieselbe ID wie zuvor. Wenn die vorherige Benachrichtigung geschlossen wird, wird stattdessen eine neue Benachrichtigung erstellt.
Sie haben auch die Möglichkeit, setOnlyAlertOnce() aufzurufen, damit der Nutzer nur beim ersten Erscheinen der Benachrichtigung durch Ton-, Vibrations- oder visuelle Hinweise unterbrochen wird. Spätere Aktualisierungen sind nicht möglich.
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. Bei dieser Methode werden auch laufende Benachrichtigungen gelöscht. - Sie rufen
cancelAll()auf. Dadurch werden alle zuvor von Ihnen ausgegebenen Benachrichtigungen entfernt. - Die angegebene Dauer läuft ab, wenn Sie beim Erstellen der Benachrichtigung mit
setTimeoutAfter()ein Zeitlimit festlegen. Bei Bedarf können Sie eine Benachrichtigung vor Ablauf des angegebenen Zeitlimits abbrechen.
Best Practices für Messaging-Apps
Beachten 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 Vorlage für den Benachrichtigungsstil speziell für Nachrichteninhalte. Mit der Klasse NotificationCompat.MessagingStyle können Sie mehrere der in der Benachrichtigung angezeigten Labels ändern, z. B. den Titel der Unterhaltung, zusätzliche Nachrichten und die Inhaltsansicht der Benachrichtigung.
Im folgenden Code-Snippet wird gezeigt, wie Sie den Stil einer Benachrichtigung mithilfe der Klasse MessagingStyle anpassen.
Kotlin
val user = Person.Builder()
.setIcon(userIcon)
.setName(userName)
.build()
val notification = NotificationCompat.Builder(this, 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()
Java
Person user = new Person.Builder()
.setIcon(userIcon)
.setName(userName)
.build();
Notification notification = new NotificationCompat.Builder(this, CHANNEL_ID)
.setContentTitle("2 new messages with " + sender)
.setContentText(subject)
.setSmallIcon(R.drawable.new_message)
.setStyle(new 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-Level 28) muss außerdem die Klasse Person verwendet werden, damit die Benachrichtigung und ihre Avatare optimal gerendert werden können.
Wenn Sie NotificationCompat.MessagingStyle verwenden, gehen Sie so vor:
- Rufen Sie
MessagingStyle.setConversationTitle()auf, um einen Titel für Gruppenchats mit mehr als zwei Personen festzulegen. Ein guter Titel für die Unterhaltung kann der Name des Gruppenchats oder eine Liste der Teilnehmer der Unterhaltung sein, wenn dieser keinen Namen hat. Andernfalls könnte die Nachricht fälschlicherweise als zu einer Einzelunterhaltung mit dem Absender der aktuellsten Nachricht in der Konversation gehörend angesehen werden. - Verwenden Sie die Methode
MessagingStyle.setData(), um Mediennachrichten wie Bilder einzuschließen. MIME-Typen mit dem Muster „image/*“ werden unterstützt.
Direktantwort verwenden
Mit Direktantworten können Nutzer direkt auf eine Nachricht antworten.
- Nachdem ein Nutzer mit der Inline-Antwort geantwortet hat, aktualisiere die
MessagingStyle-Benachrichtigung mitMessagingStyle.addMessage(). Du kannst die Benachrichtigung nicht zurückziehen oder abbrechen. Wenn die Benachrichtigung nicht abgebrochen wird, kann der Nutzer mehrere Antworten darauf senden. - Um die Inline-Antwort-Aktion mit Wear OS kompatibel zu machen, rufen Sie
Action.WearableExtender.setHintDisplayInlineAction(true)auf. - Verwenden Sie die Methode
addHistoricMessage(), um Kontext für eine Direct-Response-Unterhaltung bereitzustellen, indem Sie der Benachrichtigung historische Nachrichten hinzufügen.
Intelligente Antwort aktivieren
- Rufe zum Aktivieren der Funktion
setAllowGeneratedResponses(true)bei der Antwortaktion auf. Dadurch sind Antworten der Funktion „Intelligente Antwort“ für Nutzer verfügbar, wenn die Benachrichtigung mit einem Wear OS-Gerät verknüpft ist. Intelligente Antworten werden von einem ML-Modell für maschinelles Lernen auf der Uhr generiert. Dabei wird der von derNotificationCompat.MessagingStyle-Benachrichtigung bereitgestellte Kontext verwendet. Zum Generieren der Antworten werden keine Daten in das Internet hochgeladen.
Benachrichtigungsmetadaten hinzufügen
- Weisen Sie Benachrichtigungsmetadaten zu, um dem System mitzuteilen, wie Ihre App-Benachrichtigungen verarbeitet werden sollen, wenn sich das Gerät im
Do Not Disturb mode-Modus befindet. Verwenden Sie beispielsweise die MethodeaddPerson()odersetCategory(Notification.CATEGORY_MESSAGE), um „Bitte nicht stören“ außer Kraft zu setzen.