Benachrichtigungen bieten kurze, zeitnahe Informationen über Ereignisse in Ihrer App, während das Gerät nicht verwendet wird. In diesem Dokument erfahren Sie, wie Sie eine Benachrichtigung mit verschiedene Funktionen. Eine Einführung dazu, wie Benachrichtigungen auf Android-Geräten angezeigt werden, finden Sie unter Benachrichtigungen. Beispielcode, der Benachrichtigungen verwendet, finden Sie im Artikel Personen mit Beispiel auf GitHub.
Für den Code auf dieser Seite wird die Methode
NotificationCompat
APIs aus der AndroidX-Bibliothek Mit diesen APIs können Sie Funktionen hinzufügen, die nur
auf neueren Versionen von Android und bieten gleichzeitig weiterhin Kompatibilität mit Android
9 (API-Level 28). Einige Funktionen, wie die Inline-Antwort,
führen bei früheren Versionen
keine Vorgänge mehr.
AndroidX Core-Bibliothek hinzufügen
Die meisten mit Android Studio erstellten Projekte enthalten die erforderlichen
für die Verwendung von NotificationCompat
,
prüfen Sie, ob Ihre Modulebene
Die Datei build.gradle
enthält die folgende Abhängigkeit:
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 Benachrichtigung bezeichnet Formular: Es werden ein Symbol, ein Titel und ein wenig Text angezeigt. Dieses Abschnitt zeigt, wie eine Benachrichtigung erstellt wird, auf die der Nutzer tippen kann, um eine Aktivitäten in Ihrer App.
Abbildung 1: Eine Benachrichtigung mit ein Symbol, einen Titel und etwas Text.
Weitere Informationen zu den einzelnen Teilen einer Benachrichtigung finden Sie unter Benachrichtigungen Anatomie.
Laufzeitberechtigung deklarieren
Android 13 (API-Level 33) und höher unterstützt eine Laufzeitberechtigung zum Posten nicht ausgenommene Benachrichtigungen (einschließlich Dienste im Vordergrund) von einer App.
Die Berechtigung, die Sie in der Manifestdatei Ihrer App deklarieren müssen, wird angezeigt im folgenden Code-Snippet einfügen:
<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 den Inhalt und den Kanal der Benachrichtigung mit einem
NotificationCompat.Builder
-Objekt enthält. Das folgende Beispiel zeigt, wie Sie eine Benachrichtigung mit der
Folgendes:
Ein kleines Symbol, das von
setSmallIcon()
Dies ist der einzige für den Nutzer sichtbare Inhalt, der erforderlich ist.Ein Titel, der von
setContentTitle()
Der Textkörper, der von
setContentText()
Die Benachrichtigungspriorität, die durch
setPriority()
Die Priorität bestimmt, wie aufdringlich die Benachrichtigung unter Android 7.1 und zuvor. Legen Sie für Android 8.0 und höher stattdessen die Kanalwichtigkeit fest auf wie im nächsten Abschnitt beschrieben.
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 einen Kanal angeben
ID. Dies ist aus Gründen der Kompatibilität mit Android 8.0 (API-Level 26) und
später, wird aber in früheren Versionen ignoriert.
Standardmäßig wird der Textinhalt der Benachrichtigung auf eine Zeile gekürzt. Ich können durch Erstellen einer maximierbaren Benachrichtigung zusätzliche Informationen angezeigt werden.
Abbildung 2: Expandable-Anzeige in den minimierten und maximierten Formularen anzuzeigen.
Wenn die Benachrichtigung länger sein soll, können Sie ein erweiterbares
indem Sie eine Stilvorlage mit
setStyle()
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 ein Bild und eine Medienwiedergabesteuerung, erhalten Sie unter Erweiterbare Benachrichtigung.
Kanal erstellen und Wichtigkeit festlegen
Bevor Sie die Benachrichtigung unter Android 8.0 und höher senden können, registrieren Sie Ihr
Benachrichtigungskanal der App mit dem
indem Sie eine Instanz von
NotificationChannel
bis
createNotificationChannel()
Der folgende Code wird durch eine Bedingung im
SDK_INT
-Version:
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 den Benachrichtigungskanal erstellen müssen, bevor Sie etwas posten Benachrichtigungen unter Android 8.0 und höher, führen Sie diesen Code aus, beginnt. Sie können diesen Aufruf wiederholen, da das Erstellen einer vorhandenen keine Operation durchführt.
Für den NotificationChannel
-Konstruktor ist ein importance
erforderlich, wobei eine der folgenden Methoden verwendet wird:
Konstanten aus der
NotificationManager
-Kurs. Dieses
legt fest, wie der Nutzer bei entsprechenden Benachrichtigungen unterbrochen wird.
diesem Kanal hinzugefügt. Legen Sie die Priorität mit setPriority()
fest, um Android 7.1 zu unterstützen.
und früher, wie im vorherigen Beispiel gezeigt.
Auch wenn Sie die Wichtigkeit oder Priorität der Benachrichtigungen selbst festlegen müssen, folgenden Beispiels nicht garantiert, dass das Warnverhalten nicht garantiert wird. In In einigen Fällen ändert das System die Wichtigkeit basierend auf anderen Faktoren, Die Nutzenden können die Wichtigkeitsstufe für eine bestimmte Kanal.
Weitere Informationen zur Bedeutung der verschiedenen Ebenen finden Sie in den Wichtigkeit der Benachrichtigung Stufen.
Tippaktion der Benachrichtigung festlegen
Jede Benachrichtigung muss auf ein Tippen reagieren. Dies geschieht normalerweise, um eine Aktivität in Ihrem
die der Benachrichtigung entspricht. Geben Sie dazu einen Inhalts-Intent an.
definiert mit PendingIntent
und übergeben es an
setContentIntent()
Das folgende Snippet zeigt, wie Sie einen einfachen Intent zum Öffnen einer Aktivität erstellen 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);
Dieser Code ruft
setAutoCancel()
,
Dadurch wird die Benachrichtigung automatisch entfernt, wenn der Nutzer darauf tippt.
Methode setFlags()
wie im vorherigen Beispiel gezeigt,
behält die erwartete Navigation des Nutzers
nachdem sie Ihre App über die Benachrichtigung geöffnet haben. Vielleicht möchten Sie
je nach Art der Aktivität, die Sie beginnen,
Folgendes:
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, sodass die Aktivität eine neue Aufgabe startet und nicht der vorhandene Aufgabe und zurück Stacks. Dies ist die Art des Intents, der im vorherigen Beispiel erstellt wurde.
Eine Aktivität, die im regulären App-Ablauf Ihrer App vorhanden ist. In diesem Fall Durch das Starten der Aktivität wird ein Back-Stack erstellt, damit die Erwartungen der Nutzenden für die Schaltflächen „Zurück“ und „Nach oben“ sind beibehalten werden.
Weitere Informationen zu den verschiedenen Möglichkeiten zum Konfigurieren des Benachrichtigungs-Intents findest du unter Aktivität über eine Benachrichtigung starten
Benachrichtigung anzeigen
Um die Benachrichtigung anzuzeigen, rufen Sie
NotificationManagerCompat.notify()
,
und ihm eine eindeutige ID für die Benachrichtigung und das Ergebnis
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()) }
Speichern Sie die Benachrichtigungs-ID, die Sie übergeben, in NotificationManagerCompat.notify()
.
da Sie sie benötigen, wenn Sie die Einstellungen aktualisieren oder entfernen möchten,
Benachrichtigung.
Um grundlegende Benachrichtigungen auf Geräten mit Android 13 und höher können Sie Benachrichtigungen manuell aktivieren oder ein Dialogfeld Benachrichtigungen zu Anfragen.
Aktionsschaltflächen hinzufügen
Eine Benachrichtigung kann bis zu drei Aktionsschaltflächen enthalten, über die der Nutzer antworten kann. z. B. um eine Erinnerung zurückzustellen oder auf eine SMS zu antworten. Aber diese Aktionsschaltflächen dürfen nicht die Aktion duplizieren, die ausgeführt wird, wenn der Nutzer auf die Benachrichtigung.
Abbildung 3: Eine Benachrichtigung mit eine Aktionsschaltfläche.
Wenn Sie eine Aktionsschaltfläche hinzufügen möchten, übergeben Sie eine PendingIntent
an den
addAction()
. Dies entspricht der Einrichtung der standardmäßigen Tippaktion für Benachrichtigungen, mit Ausnahme von
können Sie auch andere Dinge tun, z. B. eine
BroadcastReceiver
, die
einen Job im Hintergrund ausführen, damit die App nicht unterbrochen wird
die bereits offen ist.
Der folgende Code zeigt beispielsweise, wie ein Broadcast an eine bestimmte Empfänger:
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)</span> 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);</span> 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 einer BroadcastReceiver
für die Hintergrundausführung
findest du in der Übersicht zu Übertragungen.
Wenn Sie stattdessen eine Benachrichtigung mit Wiedergabeschaltflächen für Medien erstellen möchten, wie z. B. zum Pausieren oder Überspringen von Titeln, erfahren Sie, wie Sie eine Benachrichtigung mit Medien erstellen .
Direktantwort-Aktion hinzufügen
Mit der Direct-Response-Aktion, 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 Ihr ohne eine Aktivität zu öffnen. Sie können z. B. eine Direktantwort-Aktion damit Nutzer auf SMS antworten oder Aufgabenlisten aktualisieren können – direkt im Benachrichtigung.
Abbildung 4: Tippe auf „Antworten“ öffnet die Texteingabe.
Die Direktantwort-Aktion erscheint als zusätzliche Schaltfläche in der Benachrichtigung, die öffnet eine Texteingabe. Wenn der Nutzer mit der Eingabe fertig ist, hängt das System den Text an. Antwort an den Intent, den Sie für die Benachrichtigungsaktion angeben, und sendet den auf Ihre App aufmerksam machen.
Schaltfläche „Antworten“ hinzufügen
So erstellen Sie eine Benachrichtigungsaktion, die Direktantworten unterstützt:
- Instanz von erstellen
RemoteInput.Builder
die Sie Ihrer Benachrichtigungsaktion hinzufügen können. Der Konstruktor dieser Klasse akzeptiert Eine Zeichenfolge, die das System als Schlüssel für die Texteingabe verwendet. Meine App später verwendet diesen Schlüssel, 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
PendingIntent
fü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
RemoteInput
einer Aktion mithilfe vonaddRemoteInput()
.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 wie in Abbildung 4 dargestellt.
Nutzereingabe aus Antwort abrufen
Um Nutzereingaben über die Antwort-UI zu erhalten, rufen Sie
RemoteInput.getResultsFromIntent()
,
Übergeben Sie die Intent
, die Ihr BroadcastReceiver
erhalten hat:
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 Sie die SMS verarbeitet haben, aktualisieren Sie die Benachrichtigung, indem Sie
NotificationManagerCompat.notify()
mit derselben ID und demselben Tag, falls verwendet. Dies ist
erforderlich, um die Direktantwort-Benutzeroberfläche auszublenden und dem Nutzer zu bestätigen, dass seine Antwort
korrekt empfangen und verarbeitet wird.
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 beim Arbeiten mit dieser neuen Benachrichtigung den Kontext, der an die
Empfänger
onReceive()
.
Hängen Sie die Antwort unten in der Benachrichtigung an, indem Sie
setRemoteInputHistory()
Wenn Sie jedoch eine Messaging-App erstellen, erstellen Sie eine Messaging-App
Benachrichtigung und fügen Sie den
neue Nachricht zur Konversation.
Weitere Tipps zu Benachrichtigungen von Messaging-Apps findest du im Abschnitt zu Best Practices für Messaging-Apps
Fortschrittsanzeige hinzufügen
Benachrichtigungen können eine animierte Fortschrittsanzeige enthalten, Status eines laufenden Vorgangs.
Abbildung 5: Die Fortschrittsanzeige während eine Operation.
Wenn Sie jederzeit schätzen können, wie viele Vorgänge abgeschlossen sind, verwenden Sie die Methode
„determiniert“ wie in Abbildung 5 dargestellt, indem Sie die
setProgress(max, progress,
false)
Der erste Parameter gibt an, Wert ist, wie 100. Das zweite ist
wie viel abgeschlossen ist. Der letzte gibt an, dass dies ein definitiver Fortschritt ist.
.
Rufen Sie während des Vorgangs kontinuierlich setProgress(max, progress,
false)
mit einem aktualisierten Wert für progress
auf und senden Sie die Benachrichtigung noch einmal.
wie im folgenden Beispiel dargestellt.
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 das Feld
um anzuzeigen, dass der Vorgang abgeschlossen ist, oder ihn zu entfernen. In beiden Fällen
Benachrichtigungstext aktualisieren, um anzuzeigen, dass der Vorgang abgeschlossen ist. Entfernen
die Fortschrittsanzeige, setProgress(0, 0, false)
aufrufen.
Zum Anzeigen einer unbestimmten Fortschrittsanzeige (eine Leiste, die nicht auf den Abschluss hinweist)
Prozentsatz) angezeigt wird, rufen Sie setProgress(0, 0, true)
auf. Das Ergebnis ist ein Indikator,
Den gleichen Stil wie die vorherige Fortschrittsanzeige, außer dass es sich um eine fortlaufende
Animation, die nicht auf den Abschluss hinweist. Die Fortschrittsanimation läuft bis
rufen Sie setProgress(0, 0, false)
auf und aktualisieren Sie dann die Benachrichtigung, um
die Aktivitätsanzeige.
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 du stören möchtest Der Nutzer erhält eine Benachrichtigung, wenn er Bitte nicht stören aktiviert hat. Modus an.
Wenn Ihre Benachrichtigung in eine der Benachrichtigungskategorien fällt, die in
NotificationCompat
, z. B.
CATEGORY_ALARM
,
CATEGORY_REMINDER
,
CATEGORY_EVENT
oder
CATEGORY_CALL
– Erklärung
indem Sie die entsprechende Kategorie an
setCategory()
:
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 Ihrer Benachrichtigungskategorie
Entscheidungen zum Anzeigen von Benachrichtigungen, wenn sich das Gerät im Modus „Bitte nicht“ befindet
stören. Sie müssen jedoch keine systemweite Kategorie festlegen. Tun Sie dies nur
wenn Ihre Benachrichtigungen mit einer der in den
NotificationCompat
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 einem Full-Screen Intent mit Ihrer Benachrichtigung.
Wenn die Benachrichtigung aufgerufen wird, sehen Nutzer je nach Sperrstatus des Geräts:
- Ist das Gerät des Nutzers gesperrt, wird eine Aktivität im Vollbildmodus angezeigt, die das gesamte Sperrbildschirm.
- Wenn das Gerät des Nutzers entsperrt ist, wird die Benachrichtigung in einem maximierten das Optionen zum Bearbeiten oder Schließen der Benachrichtigung enthält.
Das folgende Code-Snippet zeigt, wie Sie Ihre Benachrichtigung mit Full-Screen Intent:
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
So legen Sie fest, wie detailliert die Benachrichtigung auf dem Sperrbildschirm ist:
Anruf
setVisibility()
und geben Sie einen der folgenden Werte an:
VISIBILITY_PUBLIC
: wird der vollständige Inhalt der Benachrichtigung auf dem Sperrbildschirm angezeigt.VISIBILITY_SECRET
: wird kein Teil der Benachrichtigung auf dem Sperrbildschirm angezeigt.VISIBILITY_PRIVATE
: allgemeine Informationen wie das Benachrichtigungssymbol und den Inhalt wird auf dem Sperrbildschirm angezeigt. Der vollständige Inhalt der Benachrichtigung wird nicht anzeigen.
Wenn Sie VISIBILITY_PRIVATE
festlegen, können Sie auch eine alternative Version von bereitstellen
der Benachrichtigungsinhalt, durch den bestimmte Details verdeckt werden. Beispiel: eine SMS-App
zeigt möglicherweise eine Benachrichtigung
„Du hast drei neue SMS“ an, aber
blendet den Nachrichteninhalt und die Absender aus. Um diese Alternative bereitzustellen,
Erstellen Sie zunächst die alternative Benachrichtigung mit
NotificationCompat.Builder
wie gewohnt. Fügen Sie dann die alternative Benachrichtigung
zur normalen Benachrichtigung mit
setPublicVersion()
Denken Sie daran, dass die Nutzenden immer die ultimative Kontrolle darüber haben, ob ihre werden auf dem Sperrbildschirm angezeigt und können Benachrichtigungskanäle der App.
Benachrichtigung aktualisieren
Um eine Benachrichtigung nach dem Senden zu aktualisieren, rufen Sie
NotificationManagerCompat.notify()
und übergeben Sie die gleiche ID, die Sie verwendet haben.
vorher. Wenn die vorherige Benachrichtigung geschlossen wird, wird eine neue erstellt
.
Sie können optional
setOnlyAlertOnce()
sodass der Nutzer durch Töne, Vibrationen oder visuelle Elemente
Hinweise: nur beim ersten Erscheinen der Benachrichtigung
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 du
setAutoCancel()
anrufst und erstellen Sie die Benachrichtigung. - Sie rufen
cancel()
für eine bestimmte Benachrichtigungs-ID. Bei dieser Methode werden auch laufende Benachrichtigungen. - Sie rufen
cancelAll()
, Dadurch werden alle zuvor gesendeten Benachrichtigungen entfernt. - Die angegebene Dauer läuft ab, wenn Sie beim Erstellen des
Benachrichtigung, mit
setTimeoutAfter()
Bei Bedarf können Sie eine Benachrichtigung vor dem angegebenen Zeitlimit abbrechen. Dauer des Projekts.
Best Practices für Messaging-Apps
Beachten Sie beim Erstellen von Benachrichtigungen für Ihr Messaging- und Chat-Apps.
MessagingStyle verwenden
Ab Android 7.0 (API-Level 24) bietet Android einen Benachrichtigungsstil
für Messaging-Inhalte. Mit der
NotificationCompat.MessagingStyle
können Sie einige der in der Benachrichtigung angezeigten Labels ändern.
einschließlich des Titels der Unterhaltung,
zusätzlicher Nachrichten und der Inhaltsansicht für
die Benachrichtigung.
Im folgenden Code-Snippet sehen Sie, wie der Stil einer Benachrichtigung angepasst wird.
mithilfe der Klasse MessagingStyle
.
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) ist außerdem die Verwendung des
Person
, um ein
optimale Darstellung der Benachrichtigung und ihrer Avatare.
Wenn Sie NotificationCompat.MessagingStyle
verwenden, gehen Sie so vor:
- Anruf
MessagingStyle.setConversationTitle()
, um einen Titel für Gruppenchats mit mehr als zwei Personen festzulegen. Eine gute Der Titel der Unterhaltung kann der Name des Gruppenchats sein oder, falls nicht, einen Namen, eine Liste der Gesprächsteilnehmer. Andernfalls kann es vorkommen, dass die Nachricht fälschlicherweise zu einer Einzelunterhaltung mit Der Absender der neuesten Nachricht in der Konversation - Verwenden Sie die Methode
MessagingStyle.setData()
um Mediennachrichten wie Bilder einzubeziehen. MIME-Typen des Musters image/* unterstützt.
Direktantwort verwenden
Mit Direktantworten können Nutzer direkt auf eine Nachricht antworten.
- Nachdem ein Nutzer mit der Inline-Antwort geantwortet hat, verwenden Sie
MessagingStyle.addMessage()
um dieMessagingStyle
-Benachrichtigung zu aktualisieren, und brechen Sie den Vorgang nicht zurück Benachrichtigung. Wenn die Benachrichtigung nicht abgebrochen wird, kann der Nutzer mehrere auf die Benachrichtigung. - Um die Inline-Antwort-Aktion mit Wear OS kompatibel zu machen, rufen Sie
Action.WearableExtender.setHintDisplayInlineAction(true)
- Verwenden Sie die Methode
addHistoricMessage()
Methode, um Kontext zu einer Direct-Response-Unterhaltung bereitzustellen, indem Verlaufsdaten Benachrichtigungen zu ändern.
„Intelligente Antwort“ aktivieren
- Um die Funktion „Intelligente Antwort“ zu aktivieren, ruf
setAllowGeneratedResponses(true)
für die Antwortaktion. Dadurch sind Antworten der Funktion „Intelligente Antwort“ für alle wenn die Benachrichtigung mit einem Wear OS-Gerät verknüpft ist. Intelligente Antwort werden die Antworten von einem ML-Modell für maschinelles Lernen ausschließlich auf der Uhr generiert. den vonNotificationCompat.MessagingStyle
bereitgestellten Kontext und es werden keine Daten ins Internet hochgeladen, Antworten.
Benachrichtigungsmetadaten hinzufügen
- Weisen Sie Benachrichtigungsmetadaten zu, um dem System mitzuteilen, wie Ihre App behandelt werden soll
Benachrichtigungen erhalten, wenn sich das Gerät im
Do Not Disturb mode
befindet. Beispiel: verwenden Sie dieaddPerson()
odersetCategory(Notification.CATEGORY_MESSAGE)
um den Modus „Bitte nicht stören“ außer Kraft zu setzen.