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 in die Darstellung von Benachrichtigungen auf Android-Geräten finden Sie in der Übersicht zu Benachrichtigungen. Beispielcode für Benachrichtigungen finden Sie im Beispiel für Personen auf GitHub.

Im Code auf dieser Seite werden die APIs NotificationCompat 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 wie die Inline-Antwortaktion 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")
}

Einfache 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 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 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-Ebene 33) und höher unterstützt eine Laufzeitberechtigung für das Posten von nicht ausgenommenen Benachrichtigungen (einschließlich Diensten im Vordergrund) von einer App.

Die Berechtigung, die Sie in der Manifestdatei Ihrer App deklarieren müssen, wird im folgenden Code-Snippet angezeigt:

<manifest ...>
    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
    <application ...>
        ...
    </application>
</manifest>

Weitere Informationen zu Laufzeitberechtigungen finden Sie unter Laufzeitberechtigung für Benachrichtigungen.

Inhalt der Benachrichtigung festlegen

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

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

• Ein Titel, der mit setContentTitle() festgelegt wurde.

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

• Die Benachrichtigungspriorität, festgelegt von setPriority(). Die Priorität bestimmt, wie aufdringlich die Benachrichtigung unter Android 7.1 und niedriger ist. Unter Android 8.0 und höher legen Sie stattdessen die Kanalwichtigkeit 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 Stilen für große Benachrichtigungen, einschließlich der Möglichkeit, ein Bild und Steuerelemente für die Medienwiedergabe hinzuzufügen, 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. Mit diesem Parameter wird festgelegt, wie der Nutzer bei Benachrichtigungen dieses Kanals unterbrochen wird. 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 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 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

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. 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 Benachrichtigungen manuell aktivieren oder ein Dialogfeld zum Anfordern von Benachrichtigungen erstellen.

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 Eine Benachrichtigung mit einer Aktionsschaltfläche.

Wenn Sie eine Aktionsschaltfläche hinzufügen möchten, übergeben Sie der Methode addAction() einen PendingIntent. Das ist vergleichbar mit dem Einrichten der Standardaktion für das Tippen auf die Benachrichtigung. Anstatt eine Aktivität zu starten, können Sie aber auch andere Aktionen ausführen, z. B. eine BroadcastReceiver starten, die einen Job im Hintergrund ausführt, damit die Aktion die bereits geöffnete App nicht unterbricht.

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 Wenn Sie auf die Schaltfläche „Antworten“ tippen, wird die Texteingabe geöffnet.

Die Aktion „Direkt antworten“ wird als zusätzliche Schaltfläche in der Benachrichtigung angezeigt, über die eine Texteingabe geöffnet wird. 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 direkte Antworten unterstützt:

1. Erstellen Sie eine Instanz von 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. 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

Wenn Sie Nutzereingaben über die Antwortoberfläche der Benachrichtigung erhalten möchten, rufen Sie RemoteInput.getResultsFromIntent() auf und übergeben Sie die Intent, die von Ihrer BroadcastReceiver empfangen wurde:

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.

Fügen Sie die Antwort unten in der Benachrichtigung ein, indem Sie auf setRemoteInputHistory() tippen. 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 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. Zweitens: Wie viel ist bereits erledigt? Letzteres gibt an, dass der Fortschritt bestimmt werden kann.

Rufe während des Vorgangs kontinuierlich setProgress(max, progress, false) mit einem aktualisierten Wert für progress auf und sende 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 = max sein. Sie können die Fortschrittsanzeige beibehalten, um anzuzeigen, dass der Vorgang abgeschlossen ist, oder sie 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 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 so zu ändern, dass er darauf hinweist, 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 ist nur dann sinnvoll, wenn Ihre Benachrichtigungen zu einer der in NotificationCompat definierten Kategorien gehören.

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 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 Symbol der Benachrichtigung und der Inhaltstitel angezeigt. Der vollständige Inhalt der Benachrichtigung wird nicht angezeigt.

Wenn Sie VISIBILITY_PRIVATE festlegen, können Sie auch eine alternative Version des Benachrichtigungsinhalts angeben, in der bestimmte Details ausgeblendet werden. Eine SMS-App 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 nach dem Senden aktualisieren möchten, rufen Sie NotificationManagerCompat.notify() noch einmal 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 geben cancelAll() ein. Dadurch werden alle zuvor von Ihnen gegebenen 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 der angegebenen Zeitüberschreitung 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, darunter den Konversationstitel, zusätzliche Nachrichten und die Inhaltsansicht der Benachrichtigung.

Im folgenden Code-Snippet wird gezeigt, 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.

So verwenden Sie NotificationCompat.MessagingStyle:

• 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 Inline-Antwortaktion mit Wear OS kompatibel machen möchten, rufen Sie Action.WearableExtender.setHintDisplayInlineAction(true) auf.
• Verwenden Sie die Methode addHistoricMessage(), um einer Unterhaltung mit Direktantworten Kontext zu geben, indem Sie der Benachrichtigung bisherige Nachrichten hinzufügen.

Intelligente Antwort aktivieren

• Wenn Sie die Funktion „Intelligente Antwort“ aktivieren möchten, rufen Sie die Aktion „Antworten“ mit der Taste setAllowGeneratedResponses(true) auf. Dadurch sind intelligente Antworten für Nutzer verfügbar, 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, um dem System mitzuteilen, wie Ihre App-Benachrichtigungen behandelt werden sollen, wenn sich das Gerät in Do Not Disturb mode befindet. Verwenden Sie beispielsweise die Methode addPerson() oder setCategory(Notification.CATEGORY_MESSAGE), um die Funktion „Bitte nicht stören“ zu überschreiben.