Benachrichtigung erstellen

Benachrichtigungen enthalten kurze, aktuelle Informationen zu Ereignissen in Ihrer App, wenn 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 für Benachrichtigungen finden Sie im Beispiel für Personen auf GitHub.

Im Code auf dieser Seite werden die NotificationCompat-APIs aus der AndroidX-Bibliothek verwendet. Mit diesen APIs können Sie Funktionen hinzufügen, die nur in neueren Android-Versionen verfügbar sind, und gleichzeitig die Kompatibilität mit Android 9 (API-Ebene 28) beibehalten. Einige Funktionen, z. B. die Inline-Antwortfunktion, funktionieren in älteren Versionen jedoch nicht.

AndroidX Core Library 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 die build.gradle-Datei auf Modulebene die folgende Abhängigkeit enthält:

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

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

Grundlegende Benachrichtigung erstellen

Eine Benachrichtigung in ihrer einfachsten und kompaktesten Form – auch minimierte Form genannt – enthält ein Symbol, einen Titel und einen kleinen 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 Text.

Weitere Informationen zu den einzelnen Teilen einer Benachrichtigung finden Sie unter Anatomie einer Benachrichtigung.

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 du in der Manifestdatei deiner App deklarieren musst, 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

Legen Sie zuerst den Inhalt und den Kanal der Benachrichtigung mit einem NotificationCompat.Builder-Objekt fest. Das folgende Beispiel zeigt, wie du eine Benachrichtigung mit folgenden Elementen erstellst:

• Ein kleines Symbol, das mit setSmallIcon() festgelegt wird. Dies ist der einzige für Nutzer sichtbare Inhalt, der erforderlich ist.

• Ein von setContentTitle() festgelegter Titel.

• Der Textkörper, festgelegt durch setContentText().

• 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 legen Sie stattdessen die Kanalwichtigkeit wie im nächsten Abschnitt beschrieben fest.

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 Konstruktor von NotificationCompat.Builder ist eine Kanal-ID erforderlich. Dies ist für die Kompatibilität mit Android 8.0 (API-Ebene 26) und höher erforderlich, wird aber von älteren Versionen ignoriert.

Der Textinhalt einer Benachrichtigung wird standardmäßig auf eine Zeile gekürzt. Sie können zusätzliche Informationen anzeigen, indem Sie eine maximierbare Benachrichtigung erstellen.

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

Wenn du möchtest, dass mehr Text in deiner Benachrichtigung angezeigt wird, kannst du eine maximierbare Benachrichtigung aktivieren, indem du eine Stilvorlage mit setStyle() hinzufügst. Mit dem folgenden Code wird beispielsweise ein größeres Textfeld 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 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. 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. Diese Funktion kann wiederholt aufgerufen werden, da beim Erstellen eines vorhandenen Benachrichtigungskanals kein Vorgang ausgeführt wird.

Der Konstruktor von NotificationChannel benötigt eine importance, für die eine der Konstanten aus der Klasse NotificationManager verwendet wird. Dieser Parameter bestimmt, wie der Nutzer bei Benachrichtigungen, die zu diesem Kanal gehören, unterbrochen werden soll. Legen Sie die Priorität mit setPriority() fest, um Android 7.1 und niedriger zu unterstützen, wie im vorherigen Beispiel gezeigt.

Sie müssen die Wichtigkeit oder Priorität der Benachrichtigung wie im folgenden Beispiel gezeigt festlegen. Das System kann jedoch nicht garantieren, dass die Benachrichtigung so angezeigt wird, wie Sie es wünschen. 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 unter Wichtigkeitsstufen von Benachrichtigungen.

Tippaktion für die Benachrichtigung festlegen

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

Im folgenden Snippet wird gezeigt, wie Sie eine grundlegende Intent erstellen, um eine Aktivität zu öffnen, wenn der Nutzer auf die Benachrichtigung tippt:

// Create an explicit intent for an Activity in your app.
val intent = Intent(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() auf, wodurch die Benachrichtigung automatisch entfernt wird, wenn der Nutzer darauf tippt.

Mit der im vorherigen Beispiel gezeigten setFlags()-Methode wird die erwartete Navigation des Nutzers beibehalten, nachdem er Ihre App über die Benachrichtigung geöffnet hat. Je nach Art der Aktivität, die Sie starten, kann es sinnvoll sein, sie zu verwenden:

• 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 gelangt. Daher wird durch die Aktivität eine neue Aufgabe gestartet, anstatt sie dem vorhandenen Aufgaben- und Rückstapel der App hinzuzufügen. Dies ist der im vorherigen Beispiel erstellte Intent-Typ.

• Eine Aktivität, die im normalen App-Ablauf Ihrer App vorhanden ist. In diesem Fall wird durch das Starten der Aktivität ein Rückstapel erstellt, damit die Erwartungen der Nutzer an die Schaltflächen „Zurück“ und „Oben“ erfüllt werden.

Weitere Informationen zu den verschiedenen Möglichkeiten zum Konfigurieren des Intents Ihrer Benachrichtigung finden Sie unter Aktivität über 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(). Das ist im folgenden Beispiel zu sehen:

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 an NotificationManagerCompat.notify() übergeben, da Sie sie benötigen, wenn Sie die Benachrichtigung aktualisieren oder entfernen möchten.

Wenn Sie grundlegende Benachrichtigungen auf Geräten mit Android 13 und höher testen möchten, müssen Sie 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 Nutzer schnell reagieren können, z. B. eine Erinnerung zurückstellen oder auf eine SMS antworten. Diese Aktionsschaltflächen dürfen jedoch nicht die Aktion duplizieren, die ausgeführt wird, wenn der Nutzer auf die Benachrichtigung tippt.

Abbildung 3 Benachrichtigung mit einer Aktionsschaltfläche

Wenn Sie eine Aktionsschaltfläche hinzufügen möchten, übergeben Sie der Methode addAction() einen PendingIntent. Dies entspricht dem Einrichten der standardmäßigen Tippaktion für die Benachrichtigung. Allerdings können Sie statt einer Aktivität 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.

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 zum Ausführen von Hintergrundarbeiten finden Sie in der Übersicht über Streams.

Wenn Sie stattdessen eine Benachrichtigung mit Schaltflächen für die Medienwiedergabe erstellen möchten, z. B. zum Pausieren und Überspringen von Titeln, lesen Sie den Hilfeartikel Benachrichtigung mit Mediensteuerung erstellen.

Direkte Antwortaktion hinzufügen

Mit der Direktantwortaktion, die in Android 7.0 (API-Ebene 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. Mit einer Direktantwort können Sie beispielsweise Nutzern die Möglichkeit geben, direkt in der Benachrichtigung auf Nachrichten zu antworten oder Aufgabenlisten zu aktualisieren.

Abbildung 4 Durch Tippen auf die Schaltfläche „Antworten“ wird die Texteingabe geöffnet.

Die Direktantwort wird als zusätzliche Schaltfläche in der Benachrichtigung angezeigt, über die 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 direkte Antworten unterstützt:

1. 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 Text der Eingabe 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 das RemoteInput-Objekt mit addRemoteInput() 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();
     

4. Wenden Sie die Aktion auf eine Benachrichtigung an und senden Sie sie.

   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 auf, eine Antwort einzugeben, wenn er die Benachrichtigungsaktion auslöst, wie in Abbildung 4 dargestellt.

Nutzereingabe aus der Antwort abrufen

Um Nutzereingaben über die Antwort-UI der Benachrichtigung zu erhalten, rufen Sie RemoteInput.getResultsFromIntent() auf und ü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 Benutzeroberfläche für die direkte Antwort auszublenden und dem Nutzer zu bestätigen, dass seine Antwort eingegangen und korrekt verarbeitet wurde.

// 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 bei dieser neuen Benachrichtigung den Kontext, der an die onReceive()-Methode 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 Informationen 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 abschätzen können, wie weit der Vorgang fortgeschritten ist, verwenden Sie die „bestimmte“ Form des Indikators (wie in Abbildung 5 dargestellt), indem Sie setProgress(max, progress, false) aufrufen. Der erste Parameter ist der Wert für „complete“, z. B. 100. Das zweite ist, wie viel fertig ist. Letzteres gibt an, dass es sich um einen bestimmten Fortschritt handelt.

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

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 die Fortschrittsanzeige verlassen, um anzuzeigen, dass der Vorgang abgeschlossen ist, oder ihn entfernen. Aktualisieren Sie in beiden Fällen den Benachrichtigungstext, um anzugeben, dass der Vorgang abgeschlossen ist. Wenn Sie die Fortschrittsanzeige entfernen möchten, rufen Sie setProgress(0, 0, false) auf.

Wenn Sie eine unbestimmte Fortschrittsanzeige (eine Anzeige, die keinen Prozentsatz für den Fortschritt angibt) anzeigen lassen möchten, drücken Sie setProgress(0, 0, true). 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 der Nutzer durch eine bestimmte Benachrichtigung gestört werden soll, wenn er den Modus „Bitte nicht stören“ aktiviert hat.

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 an, indem Sie die entsprechende Kategorie an setCategory() übergeben:

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 über die Benachrichtigungskategorie entscheidet das System, ob eine Benachrichtigung angezeigt werden soll, 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 eine Vollbild-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 Vollbildaktivität angezeigt, die den Sperrbildschirm bedeckt.
• Wenn das Gerät des Nutzers entsperrt ist, wird die Benachrichtigung in einer erweiterten Form angezeigt, die Optionen zum Bearbeiten oder Schließen der Benachrichtigung enthält.

Im folgenden Code-Snippet wird gezeigt, wie Sie Ihre Benachrichtigung mit einem Intent für den Vollbildmodus verknüpfen:

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

Wenn Sie festlegen möchten, wie detailliert die Benachrichtigung auf dem Sperrbildschirm angezeigt wird, geben Sie einen der folgenden Werte an:setVisibility()

• VISIBILITY_PUBLIC: Der vollständige Inhalt der Benachrichtigung wird auf dem Sperrbildschirm angezeigt.

• VISIBILITY_SECRET: Kein Teil der Benachrichtigung wird auf dem Sperrbildschirm angezeigt.

• VISIBILITY_PRIVATE: Auf dem Sperrbildschirm werden nur grundlegende Informationen wie das Benachrichtigungssymbol und der Titel des Inhalts angezeigt. Der vollständige Inhalt der Benachrichtigung wird nicht 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 die Benachrichtigung „Sie haben 3 neue Nachrichten“ anzeigen, aber den Inhalt der Nachrichten und die Absender ausblenden. Wenn Sie diese alternative Benachrichtigung bereitstellen möchten, erstellen Sie sie zuerst wie gewohnt mit NotificationCompat.Builder. Fügen Sie dann die alternative Benachrichtigung mit setPublicVersion() an die normale Benachrichtigung an.

Denken Sie daran, dass der Nutzer immer die Kontrolle darüber hat, ob seine Benachrichtigungen auf dem Sperrbildschirm angezeigt werden. Er kann sie anhand der Benachrichtigungskanäle Ihrer App steuern.

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

Optional können Sie setOnlyAlertOnce() aufrufen, damit die Benachrichtigung den Nutzer nur beim ersten Mal, wenn sie angezeigt wird, durch Ton, Vibration oder visuelle Hinweise unterbricht, nicht aber bei späteren Aktualisierungen.

Benachrichtigung entfernen

Benachrichtigungen bleiben sichtbar, bis eines der folgenden Ereignisse eintritt:

• Der Nutzer schließt die Benachrichtigung.
• Der Nutzer tippt auf die Benachrichtigung, wenn Sie beim Erstellen der Benachrichtigung setAutoCancel() aufrufen.
• Sie rufen cancel() für eine bestimmte Benachrichtigungs-ID auf. Mit 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 festgelegt haben. Bei Bedarf können Sie eine Benachrichtigung vor Ablauf des angegebenen Zeitlimits abbrechen.

Best Practices für Messaging-Apps

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

MessagingStyle verwenden

Ab Android 7.0 (API-Ebene 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.

Das folgende Code-Snippet zeigt, wie der Stil einer Benachrichtigung mithilfe der Klasse MessagingStyle angepasst wird.

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-Ebene 28) ist außerdem die Verwendung der Klasse Person erforderlich, um die Benachrichtigung und ihre Avatare optimal zu rendern.

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. Ein guter Unterhaltungstitel könnte der Name des Gruppenchats sein oder, falls er keinen Namen hat, eine Liste der Teilnehmer an der Unterhaltung. Andernfalls wird die Nachricht möglicherweise fälschlicherweise als zu einer Unterhaltung mit dem Absender der letzten Nachricht in der Unterhaltung gehörend angesehen.
• Verwenden Sie die Methode MessagingStyle.setData(), um Mediennachrichten wie Bilder einzufügen. MIME-Typen des Musters „image/*“ werden unterstützt.

Direktantwort verwenden

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

• Nachdem ein Nutzer mit der Inline-Antwortaktion geantwortet hat, aktualisiere die MessagingStyle-Benachrichtigung mit MessagingStyle.addMessage() und ziehe die Benachrichtigung nicht zurück oder ändere sie nicht. Wenn die Benachrichtigung nicht abgebrochen wird, kann der Nutzer mehrere Antworten über die Benachrichtigung senden.
• Wenn Sie die Aktion „Direktnachricht senden“ mit Wear OS kompatibel machen möchten, 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 intelligente Antworten 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 der NotificationCompat.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 Methode addPerson() oder setCategory(Notification.CATEGORY_MESSAGE), um die Funktion „Bitte nicht stören“ zu überschreiben.