Benachrichtigung erstellen

Benachrichtigungen enthalten kurze, aktuelle Informationen zu Ereignissen in Ihrer App, wenn sie nicht verwendet wird. In diesem Dokument erfahren Sie, wie Sie eine Benachrichtigung mit verschiedenen Funktionen erstellen. 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:

dependencies {
    implementation "androidx.core:core:2.2.0"
}

dependencies {
    implementation("androidx.core:core-ktx:2.2.0")
}

Einfache 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. In diesem Abschnitt wird gezeigt, wie Sie eine Benachrichtigung erstellen, auf die Nutzer tippen können, um eine Aktivität in Ihrer App zu starten.

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 mit setContentTitle() festgelegt wurde.

• Der Textkörper, der von setContentText()

• Die Benachrichtigungspriorität, festgelegt von 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.

var builder = NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle(textTitle)
        .setContentText(textContent)
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)

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. Sie können zusätzliche Informationen anzeigen, indem Sie eine maximierbare Benachrichtigung erstellen.

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:

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)

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, 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() {
    // 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)
    }
}

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 Benachrichtigungen unter Android 8.0 und höher posten, führen Sie diesen Code aus, sobald Ihre App gestartet wird. Sie können diesen Aufruf wiederholen, da das Erstellen einer vorhandenen keine Operation durchführt.

Der Konstruktor von NotificationChannel benötigt eine importance, für die eine der Konstanten aus der Klasse NotificationManager verwendet wird. 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 und niedriger zu unterstützen, wie im vorherigen Beispiel gezeigt.

Auch wenn Sie die Wichtigkeit oder Priorität von Benachrichtigungen selbst festlegen müssen, folgenden Beispiels nicht garantiert, dass das Warnverhalten nicht garantiert wird. In einigen Fällen kann das System die Wichtigkeitsstufe basierend auf anderen Faktoren ändern. Der Nutzer kann die Wichtigkeitsstufe für einen bestimmten Kanal jederzeit neu definieren.

Weitere Informationen zur Bedeutung der verschiedenen Ebenen finden Sie in den Wichtigkeit der Benachrichtigung Stufen.

Tippaktion für die 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:

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

// 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() die im vorherigen Beispiel gezeigt wurde, 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 existiert. Es gibt keinen Grund, warum der Nutzer während der normalen App-Nutzung zu dieser Aktivität wechseln sollte. Daher wird durch die Aktivität eine neue Aufgabe gestartet, anstatt sie dem vorhandenen Aufgaben- und Rückstapel der App hinzuzufügen. Dies ist die Art von Intent, die im vorherigen Beispiel erstellt wurde.

• Eine Aktivität, die im normalen 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 Intents Ihrer Benachrichtigung finden Sie unter Aktivität über Benachrichtigung starten.

Benachrichtigung anzeigen

Rufen Sie NotificationManagerCompat.notify() auf, um die Benachrichtigung anzuzeigen. Geben Sie dabei eine eindeutige ID für die Benachrichtigung und das Ergebnis von NotificationCompat.Builder.build() an. Dies wird im folgenden Beispiel gezeigt:

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

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 erstellen, 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 z. B. eine Aktivität starten, BroadcastReceiver, die einen Job im Hintergrund ausführen, damit die App nicht unterbrochen wird die bereits offen ist.

Im folgenden Codebeispiel wird beispielsweise gezeigt, wie eine Übertragung an einen bestimmten Empfänger gesendet wird:

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)

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

Direkte Antwortaktion 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 Ihre App gesendet, ohne dass eine Aktivität geöffnet wird. 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 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:

1. Instanz von erstellen RemoteInput.Builder die Sie Ihrer Benachrichtigungsaktion hinzufügen können. Der Konstruktor dieser Klasse akzeptiert einen String, den das System als Schlüssel für die Texteingabe verwendet. 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();
     

2. 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);
     

3. Hängen Sie RemoteInput einer Aktion mithilfe von addRemoteInput().

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

4. 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:

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

private CharSequence getMessageText(Intent intent) {
    Bundle remoteInput = RemoteInput.getResultsFromIntent(intent);
    if (remoteInput != null) {
        return remoteInput.getCharSequence(KEY_TEXT_REPLY);
    }
    return null;
 }

Aktualisiere die Benachrichtigung, nachdem du den Text verarbeitet hast, indem du NotificationManagerCompat.notify() mit derselben ID und demselben Tag aufrufst, 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.

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

// 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 entwickeln, erstellen Sie eine Nachricht im Messaging-Stil und hängen Sie die neue Nachricht an die Unterhaltung an.

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.

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

...
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), rufen Sie setProgress(0, 0, true) auf. Das Ergebnis ist ein Indikator, der denselben Stil wie die vorherige Fortschrittsanzeige hat, mit der Ausnahme, dass es sich um eine kontinuierliche Animation handelt, die keinen Abschluss anzeigt. Die Fortschrittsanimation wird ausgeführt, bis Sie setProgress(0, 0, false) aufrufen und die Benachrichtigung dann aktualisieren, um den Aktivitätsindikator 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 du den Dienst 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():

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)

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 Ihrer Benachrichtigung eine Vollbild-Intent zuordnen.

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:

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)

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 Sie beim Erstellen der Benachrichtigung setAutoCancel() aufrufen.
• 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 Ablauf der angegebenen Zeitüberschreitung abbrechen.

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 Klasse NotificationCompat.MessagingStyle können Sie mehrere der in der Benachrichtigung angezeigten Labels ändern, darunter den Konversationstitel, zusätzliche Nachrichten und die Inhaltsansicht der Benachrichtigung.

Im folgenden Code-Snippet sehen Sie, wie der Stil einer Benachrichtigung angepasst wird. mithilfe der Klasse MessagingStyle.

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

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:

• Sie können einen Titel für Gruppenchats mit mehr als zwei Personen festlegen, indem Sie auf MessagingStyle.setConversationTitle() tippen. 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/*“ werden unterstützt.

Direktantwort verwenden

Mit der Funktion „Direktantwort“ können Nutzer inline auf eine Nachricht antworten.

• Nachdem ein Nutzer mit der Inline-Antwort geantwortet hat, verwenden Sie MessagingStyle.addMessage() um die MessagingStyle-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(), um einer Unterhaltung mit Direktantworten Kontext zu geben, indem Sie der Benachrichtigung bisherige Nachrichten hinzufügen.

Intelligente Antwort aktivieren

• Um die Funktion „Intelligente Antwort“ zu aktivieren, ruf setAllowGeneratedResponses(true) auf die Antwortaktion. Dadurch sind Antworten der Funktion „Intelligente Antwort“ für alle wenn die Benachrichtigung mit einem Wear OS-Gerät verknüpft ist. Antworten der Funktion „Intelligente Antwort“ werden von einem aktiven Modell für maschinelles Lernen anhand des Kontexts der NotificationCompat.MessagingStyle-Benachrichtigung generiert. Es werden keine Daten ins Internet hochgeladen, um die Antworten zu generieren.

Benachrichtigungsmetadaten hinzufügen

• Weisen Sie Benachrichtigungsmetadaten zu, damit das System weiß, wie Ihre App behandelt werden soll Benachrichtigungen erhalten, wenn sich das Gerät im Do Not Disturb mode befindet. Beispiel: verwenden Sie die addPerson() oder setCategory(Notification.CATEGORY_MESSAGE) um den Modus „Bitte nicht stören“ außer Kraft zu setzen.