Benachrichtigung erstellen

Benachrichtigungen bieten kurze und 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 unter Android angezeigt werden, findest du in der Benachrichtigungsübersicht. Beispielcode, in dem Benachrichtigungen verwendet werden, finden Sie im People-Beispiel auf GitHub.

Im Code auf dieser Seite werden die NotificationCompat APIs aus der AndroidX-Bibliothek verwendet. Mit diesen APIs kannst du Funktionen hinzufügen, die nur unter neueren Android-Versionen verfügbar sind, und weiterhin die Kompatibilität mit Android 9 (API-Level 28) gewährleisten. Einige Funktionen, z. B. die Inline-Antwort, führen jedoch in früheren Versionen zu einer Nulloperation.

AndroidX Core Library hinzufügen

Obwohl die meisten mit Android Studio erstellten Projekte die erforderlichen Abhängigkeiten zur Verwendung von NotificationCompat enthalten, prüfen Sie, ob die Datei build.gradle auf Modulebene die folgende Abhängigkeit enthält:

Groovig

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

Kotlin

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

Hinweis: Andere Bibliotheken in der Gruppe androidx enthalten auch core als transitive Abhängigkeit. Wenn Sie bereits andere Jetpack APIs verwenden, haben Sie möglicherweise Zugriff auf NotificationCompat, ohne dass diese Abhängigkeit genau erforderlich ist.

Einfache Benachrichtigung erstellen

Eine Benachrichtigung in ihrer einfachsten und kompakten Form – auch als minimierte Form bezeichnet – enthält ein Symbol, einen Titel und einen kleinen Teil des Textinhalts. In diesem Abschnitt wird beschrieben, wie du eine Benachrichtigung erstellst, auf die der Nutzer tippen kann, um eine Aktivität in deiner App zu starten.

Abbildung 1: Eine Benachrichtigung mit einem Symbol, einem Titel und etwas Text.

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

Laufzeitberechtigung deklarieren

Android 13 (API-Level 33) und höher unterstützt eine Laufzeitberechtigung zum Posten von nicht ausgenommenen Benachrichtigungen (einschließlich Dienste 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.

Benachrichtigungsinhalt festlegen

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

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

• Einen Titel, der von setContentTitle() festgelegt wird.

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

• Die von setPriority() festgelegte Benachrichtigungspriorität. Die Priorität bestimmt, wie aufdringlich die Benachrichtigung unter Android 7.1 und niedriger ist. Legen Sie für Android 8.0 und höher stattdessen die Kanalwichtigkeit wie im nächsten Abschnitt beschrieben fest.

Kotlin

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

Java

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

Für den NotificationCompat.Builder-Konstruktor müssen Sie eine Kanal-ID angeben. Dies ist für die Kompatibilität mit Android 8.0 (API-Level 26) und höher erforderlich, wird in früheren Versionen jedoch ignoriert.

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

Abbildung 2: Eine maximierbare Benachrichtigung in ihrer minimierten und maximierten Form.

Wenn die Benachrichtigung länger sein soll, können Sie eine maximierbare Benachrichtigung aktivieren, indem Sie eine Stilvorlage mit setStyle() hinzufügen. Mit dem folgenden Code wird beispielsweise ein größerer Textbereich erstellt:

Kotlin

var builder = NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Much longer text that cannot fit one line...")
        .setStyle(NotificationCompat.BigTextStyle()
                .bigText("Much longer text that cannot fit one line..."))
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)

Java

NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Much longer text that cannot fit one line...")
        .setStyle(new NotificationCompat.BigTextStyle()
                .bigText("Much longer text that cannot fit one line..."))
        .setPriority(NotificationCompat.PRIORITY_DEFAULT);

Weitere Informationen zu anderen großen Benachrichtigungsformaten, z. B. zum Hinzufügen eines Bildes und zur Steuerung der 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:

Kotlin

private fun createNotificationChannel() {
    // Create the NotificationChannel, but only on API 26+ because
    // the NotificationChannel class is not in the Support Library.
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        val name = getString(R.string.channel_name)
        val descriptionText = getString(R.string.channel_description)
        val importance = NotificationManager.IMPORTANCE_DEFAULT
        val channel = NotificationChannel(CHANNEL_ID, name, importance).apply {
            description = descriptionText
        }
        // Register the channel with the system.
        val notificationManager: NotificationManager =
            getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
        notificationManager.createNotificationChannel(channel)
    }
}

Java

private void createNotificationChannel() {
    // Create the NotificationChannel, but only on API 26+ because
    // the NotificationChannel class is not in the Support Library.
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        CharSequence name = getString(R.string.channel_name);
        String description = getString(R.string.channel_description);
        int importance = NotificationManager.IMPORTANCE_DEFAULT;
        NotificationChannel channel = new NotificationChannel(CHANNEL_ID, name, importance);
        channel.setDescription(description);
        // Register the channel with the system; you can't change the importance
        // or other notification behaviors after this.
        NotificationManager notificationManager = getSystemService(NotificationManager.class);
        notificationManager.createNotificationChannel(channel);
    }
}

Da Sie unter Android 8.0 und höher den Benachrichtigungskanal erstellen müssen, bevor Sie Benachrichtigungen veröffentlichen, führen Sie diesen Code beim Start Ihrer Anwendung aus. Es kann bedenkenlos wiederholt aufgerufen werden, da beim Erstellen eines vorhandenen Benachrichtigungskanals keine Aktion ausgeführt wird.

Für den Konstruktor NotificationChannel ist ein importance erforderlich. Dabei wird eine der Konstanten aus der Klasse NotificationManager verwendet. Dieser Parameter bestimmt, wie der Nutzer bei Benachrichtigungen zu diesem Kanal unterbrochen wird. Legen Sie die Priorität mit setPriority() fest, um Android 7.1 und niedriger zu unterstützen, wie im vorherigen Beispiel gezeigt.

Obwohl Sie die Wichtigkeit oder Priorität von Benachrichtigungen wie im folgenden Beispiel gezeigt festlegen müssen, kann das System das erhaltene Benachrichtigungsverhalten nicht garantieren. In einigen Fällen kann das System die Wichtigkeitsstufe auf Grundlage anderer Faktoren ändern und 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 der Benachrichtigung festlegen

Jede Benachrichtigung muss auf ein Tippen reagieren – in der Regel, um eine Aktivität in der App zu öffnen, die der Benachrichtigung entspricht. Geben Sie dazu einen mit einem PendingIntent-Objekt definierten Inhalts-Intent an und übergeben Sie ihn an setContentIntent().

Das folgende Snippet zeigt, wie Sie einen Basis-Intent erstellen, um eine Aktivität zu öffnen, wenn der Nutzer auf die Benachrichtigung tippt:

Kotlin

// Create an explicit intent for an Activity in your app.
val intent = Intent(this, AlertDetails::class.java).apply {
    flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
}
val pendingIntent: PendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_IMMUTABLE)

val builder = NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        // Set the intent that fires when the user taps the notification.
        .setContentIntent(pendingIntent)
        .setAutoCancel(true)

Java

// Create an explicit intent for an Activity in your app.
Intent intent = new Intent(this, AlertDetails.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_IMMUTABLE);

NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        // Set the intent that fires when the user taps the notification.
        .setContentIntent(pendingIntent)
        .setAutoCancel(true);

Dieser Code ruft setAutoCancel() auf. Dadurch wird die Benachrichtigung automatisch entfernt, wenn der Nutzer darauf tippt.

Mit der im vorherigen Beispiel gezeigten Methode setFlags() wird die erwartete Navigation des Nutzers beibehalten, nachdem er die App über die Benachrichtigung geöffnet hat. Abhängig von der Art der Aktivität, die Sie starten, kann es sich um folgende handeln:

• Eine Aktivität, die ausschließlich für Antworten auf die Benachrichtigung existiert. Da es keinen Grund gibt, warum der Nutzer diese Aktivität während der normalen Verwendung der App aufruft, wird mit der Aktivität eine neue Aufgabe gestartet und nicht der vorhandenen Aufgabe und Backstack der App hinzugefügt. Dies ist der im vorherigen Beispiel erstellte Intent.

• Eine Aktivität im normalen App-Ablauf Ihrer App. In diesem Fall wird beim Starten der Aktivität ein Back-Stack erstellt, sodass die Nutzererwartungen an die Zurück- und Nach-oben-Schaltflächen erhalten bleiben.

Weitere Informationen zu den verschiedenen Möglichkeiten zum Konfigurieren des Intents Ihrer Benachrichtigung finden Sie unter Aktivität über eine Benachrichtigung starten.

Benachrichtigung anzeigen

Rufen Sie zum Anzeigen der Benachrichtigung NotificationManagerCompat.notify() auf und übergeben Sie eine eindeutige ID für die Benachrichtigung und das Ergebnis von NotificationCompat.Builder.build(). Dies wird im folgenden Beispiel veranschaulicht:

Kotlin

with(NotificationManagerCompat.from(this)) {
    if (ActivityCompat.checkSelfPermission(
            this@MainActivity,
            Manifest.permission.POST_NOTIFICATIONS
        ) != PackageManager.PERMISSION_GRANTED
    ) {
        // TODO: Consider calling
        // ActivityCompat#requestPermissions
        // here to request the missing permissions, and then overriding
        // public fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>,
        //                                        grantResults: IntArray)
        // to handle the case where the user grants the permission. See the documentation
        // for ActivityCompat#requestPermissions for more details.

        return@with
    }
    // notificationId is a unique int for each notification that you must define.
    notify(NOTIFICATION_ID, builder.build())
}

Java

with(NotificationManagerCompat.from(this)) {
   if (ActivityCompat.checkSelfPermission(
           this@MainActivity,
           Manifest.permission.POST_NOTIFICATIONS
       ) != PackageManager.PERMISSION_GRANTED
   ) {
       // TODO: Consider calling
       // ActivityCompat#requestPermissions
       // here to request the missing permissions, and then overriding
       // public void onRequestPermissionsResult(int requestCode, String[] permissions,
       //                                        int[] grantResults)
       // to handle the case where the user grants the permission. See the documentation
       // for ActivityCompat#requestPermissions for more details.

       return
   }
   // notificationId is a unique int for each notification that you must define.
   notify(NOTIFICATION_ID, builder.build())
}

Speichern Sie die Benachrichtigungs-ID, die Sie an NotificationManagerCompat.notify() übergeben. Sie benötigen sie zum Aktualisieren oder Entfernen der Benachrichtigung.

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.

Hinweis: Ab Android 8.1 (API-Level 27) können Apps einen Benachrichtigungston nicht öfter als einmal pro Sekunde ausgeben. Wenn Ihre App innerhalb einer Sekunde mehrere Benachrichtigungen sendet, werden alle wie erwartet angezeigt, es wird jedoch nur bei der ersten Benachrichtigung pro Sekunde ein Ton ausgegeben.

Aktionsschaltflächen hinzufügen

Eine Benachrichtigung kann bis zu drei Aktionsschaltflächen enthalten, mit denen der Nutzer schnell reagieren kann, z. B. um eine Erinnerung zurückzustellen oder auf eine SMS zu antworten. Diese Aktionsschaltflächen dürfen jedoch nicht die Aktion duplizieren, die ausgeführt wird, wenn der Nutzer auf die Benachrichtigung tippt.

Abbildung 3: Eine Benachrichtigung mit einer Aktionsschaltfläche.

Wenn Sie eine Aktionsschaltfläche hinzufügen möchten, übergeben Sie einen PendingIntent an die Methode addAction(). Dies entspricht dem Einrichten der standardmäßigen Tippaktion der Benachrichtigung. Statt eine Aktivität zu starten, können Sie jedoch andere Aktionen ausführen, z. B. ein BroadcastReceiver starten, das einen Job im Hintergrund ausführt, damit die bereits geöffnete App nicht durch die Aktion unterbrochen wird.

Der folgende Code zeigt beispielsweise, wie eine Nachricht an einen bestimmten Empfänger gesendet wird:

Kotlin

val ACTION_SNOOZE = "snooze"

val snoozeIntent = Intent(this, MyBroadcastReceiver::class.java).apply {
    action = ACTION_SNOOZE
    putExtra(EXTRA_NOTIFICATION_ID, 0)
}
val snoozePendingIntent: PendingIntent =
    PendingIntent.getBroadcast(this, 0, snoozeIntent, 0)
val builder = NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        .setContentIntent(pendingIntent)
        .addAction(R.drawable.ic_snooze, getString(R.string.snooze),
                snoozePendingIntent)

Java

String ACTION_SNOOZE = "snooze"

Intent snoozeIntent = new Intent(this, MyBroadcastReceiver.class);
snoozeIntent.setAction(ACTION_SNOOZE);
snoozeIntent.putExtra(EXTRA_NOTIFICATION_ID, 0);
PendingIntent snoozePendingIntent =
        PendingIntent.getBroadcast(this, 0, snoozeIntent, 0);

NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        .setContentIntent(pendingIntent)
        .addAction(R.drawable.ic_snooze, getString(R.string.snooze),
                snoozePendingIntent);

Weitere Informationen zum Erstellen eines BroadcastReceiver für Hintergrundarbeiten finden Sie in der Übersicht zu Broadcasts.

Wenn Sie stattdessen eine Benachrichtigung mit Schaltflächen für die Medienwiedergabe erstellen möchten, z. B. zum Pausieren und Überspringen von Titeln, finden Sie hier Informationen zum Erstellen einer Benachrichtigung mit Mediensteuerelementen.

Hinweis :Ab Android 10 (API-Level 29) und höher generiert die Plattform automatisch Aktionsschaltflächen für Benachrichtigungen, wenn eine App keine eigenen hat. Wenn du nicht möchtest, dass in den Benachrichtigungen deiner App vorgeschlagene Antworten oder Aktionen angezeigt werden, kannst du vom System generierte Antworten und Aktionen mit setAllowGeneratedReplies() und setAllowSystemGeneratedContextualActions() deaktivieren.

Aktion für direkte Antworten hinzufügen

Mit der in Android 7.0 (API-Ebene 24) eingeführten Aktion für direkte Antworten können Nutzer Text direkt in die Benachrichtigung eingeben. Der Text wird dann an Ihre App gesendet, ohne eine Aktivität zu öffnen. Sie können beispielsweise eine Direktantwort-Aktion verwenden, damit Nutzer von der Benachrichtigung aus auf Textnachrichten antworten oder Aufgabenlisten aktualisieren können.

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

Die Aktion für direkte Antworten 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.

Antwortschaltfläche 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 Anwendung 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);
     

   Achtung:Wenn Sie eine PendingIntent wiederverwenden, antwortet ein Nutzer möglicherweise nicht auf die geplante Unterhaltung, sondern auf eine andere Unterhaltung. Sie müssen einen Anfragecode angeben, der für jede Unterhaltung anders ist, oder einen Intent angeben, der nicht true zurückgibt, wenn Sie equals() für den Antwort-Intent einer anderen Unterhaltung aufrufen. Die Unterhaltungs-ID wird häufig als Teil des Extras-Bundles des Intents übergeben, beim Aufrufen von equals() jedoch ignoriert.
3. Hängen Sie das Objekt RemoteInput mithilfe von 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 die Benachrichtigung.

   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 die Benachrichtigungsaktion ausgelöst wird (siehe Abbildung 4).

Nutzereingabe aus der Antwort abrufen

Um Nutzereingaben von der Antwort-UI der Benachrichtigung zu erhalten, rufen Sie RemoteInput.getResultsFromIntent() auf und übergeben Sie die von Ihrer BroadcastReceiver empfangene Intent:

Kotlin

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

Java

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

Nachdem du den Text verarbeitet hast, aktualisiere die Benachrichtigung, indem du NotificationManagerCompat.notify() mit derselben ID und demselben Tag (falls verwendet) aufrufst. Dies ist erforderlich, um die Benutzeroberfläche für direkte Antworten auszublenden und dem Nutzer zu bestätigen, dass seine Antwort richtig empfangen und verarbeitet wird.

Kotlin

// Build a new notification, which informs the user that the system
// handled their interaction with the previous notification.
val repliedNotification = Notification.Builder(context, CHANNEL_ID)
        .setSmallIcon(R.drawable.ic_message)
        .setContentText(getString(R.string.replied))
        .build()

// Issue the new notification.
NotificationManagerCompat.from(this).apply {
    notificationManager.notify(notificationId, repliedNotification)
}

Java

// Build a new notification, which informs the user that the system
// handled their interaction with the previous notification.
Notification repliedNotification = new Notification.Builder(context, CHANNEL_ID)
        .setSmallIcon(R.drawable.ic_message)
        .setContentText(getString(R.string.replied))
        .build();

// Issue the new notification.
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
notificationManager.notify(notificationId, repliedNotification);

Verwenden Sie bei der Arbeit mit dieser neuen Benachrichtigung den Kontext, der an die Methode onReceive() des Empfängers übergeben wurde.

Hängen Sie die Antwort durch Aufrufen von setRemoteInputHistory() an das Ende der Benachrichtigung an. Wenn Sie jedoch eine Messaging-App erstellen, erstellen Sie eine Benachrichtigung im Nachrichtenstil und hängen die neue Nachricht an die Unterhaltung an.

Weitere Hinweise zu Benachrichtigungen von Messaging-Apps finden Sie im Abschnitt zu 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 abschätzen können, wie viel eines Vorgangs zu einem beliebigen Zeitpunkt abgeschlossen ist, verwenden Sie die bestimmte Form des Indikators (siehe Abbildung 5), indem Sie setProgress(max, progress, false) aufrufen. Der erste Parameter gibt den Wert für „complete“ an, z. B. „100“. Das zweite ist die Vollständigkeit. Das letzte gibt an, dass es sich um einen bestimmten Fortschrittsbalken handelt.

Rufen Sie im Verlauf 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.

Hinweis: Da die Fortschrittsanzeige es erfordert, dass Ihre App die Benachrichtigung kontinuierlich aktualisiert, muss dieser Code in einem Hintergrunddienst ausgeführt werden.

Kotlin

val builder = NotificationCompat.Builder(this, CHANNEL_ID).apply {
    setContentTitle("Picture Download")
    setContentText("Download in progress")
    setSmallIcon(R.drawable.ic_notification)
    setPriority(NotificationCompat.PRIORITY_LOW)
}
val PROGRESS_MAX = 100
val PROGRESS_CURRENT = 0
NotificationManagerCompat.from(this).apply {
    // Issue the initial notification with zero progress.
    builder.setProgress(PROGRESS_MAX, PROGRESS_CURRENT, false)
    notify(notificationId, builder.build())

    // Do the job that tracks the progress here.
    // Usually, this is in a worker thread.
    // To show progress, update PROGRESS_CURRENT and update the notification with:
    // builder.setProgress(PROGRESS_MAX, PROGRESS_CURRENT, false);
    // notificationManager.notify(notificationId, builder.build());

    // When done, update the notification once more to remove the progress bar.
    builder.setContentText("Download complete")
            .setProgress(0, 0, false)
    notify(notificationId, builder.build())
}

Java

...
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID);
builder.setContentTitle("Picture Download")
        .setContentText("Download in progress")
        .setSmallIcon(R.drawable.ic_notification)
        .setPriority(NotificationCompat.PRIORITY_LOW);

// Issue the initial notification with zero progress.
int PROGRESS_MAX = 100;
int PROGRESS_CURRENT = 0;
builder.setProgress(PROGRESS_MAX, PROGRESS_CURRENT, false);
notificationManager.notify(notificationId, builder.build());

// Do the job that tracks the progress here.
// Usually, this is in a worker thread.
// To show progress, update PROGRESS_CURRENT and update the notification with:
// builder.setProgress(PROGRESS_MAX, PROGRESS_CURRENT, false);
// notificationManager.notify(notificationId, builder.build());

// When done, update the notification once more to remove the progress bar.
builder.setContentText("Download complete")
        .setProgress(0,0,false);
notificationManager.notify(notificationId, builder.build());

Am Ende des Vorgangs muss progress gleich max sein. Sie können die Fortschrittsanzeige verlassen, um anzuzeigen, dass der Vorgang abgeschlossen ist, oder ihn entfernen. In beiden Fällen müssen Sie den Benachrichtigungstext aktualisieren, um zu zeigen, dass der Vorgang abgeschlossen ist. Rufen Sie setProgress(0, 0, false) auf, um die Fortschrittsanzeige zu entfernen.

Um einen unbestimmten Fortschrittsbalken anzuzeigen (ein Balken, der nicht den Prozentsatz für die Fertigstellung angibt), rufen Sie setProgress(0, 0, true) auf. Das Ergebnis ist ein Indikator im selben Stil wie die vorherige Fortschrittsanzeige, mit der Ausnahme, dass es sich um eine fortlaufende Animation handelt, die nicht auf den Abschluss hindeutet. Die Fortschrittsanimation wird so lange ausgeführt, bis Sie setProgress(0, 0, false) aufrufen und dann die Benachrichtigung so aktualisieren, dass die Aktivitätsanzeige entfernt wird.

Denken Sie daran, den Benachrichtigungstext zu ändern, um anzuzeigen, dass der Vorgang abgeschlossen ist.

Hinweis: Wenn Sie eine Datei herunterladen müssen, können Sie DownloadManager verwenden, das eine eigene Benachrichtigung enthält, damit Sie den Downloadfortschritt verfolgen können.

Systemweite Kategorie festlegen

Android verwendet vordefinierte systemweite Kategorien, um zu bestimmen, ob der Nutzer mit einer bestimmten Benachrichtigung gestört werden soll, wenn er den Bitte nicht stören-Modus aktiviert.

Wenn Ihre Benachrichtigung in eine der in NotificationCompat definierten Benachrichtigungskategorien fällt, z. B. CATEGORY_ALARM, CATEGORY_REMINDER, CATEGORY_EVENT oder CATEGORY_CALL, geben Sie dies entsprechend an, indem Sie die entsprechende Kategorie an setCategory() übergeben:

Kotlin

var builder = NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        .setCategory(NotificationCompat.CATEGORY_MESSAGE)

Java

NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        .setCategory(NotificationCompat.CATEGORY_MESSAGE);

Anhand dieser Informationen zu Ihrer Benachrichtigungskategorie entscheidet das System, ob Ihre Benachrichtigung im „Bitte nicht stören“-Modus angezeigt wird. Sie müssen jedoch keine systemweite Kategorie festlegen. Das solltest du nur tun, wenn deine Benachrichtigungen einer der in NotificationCompat definierten Kategorien entsprechen.

Dringende Nachricht anzeigen

Ihre App muss möglicherweise eine dringende, zeitkritische Nachricht wie einen eingehenden Anruf oder einen klingelnden Wecker anzeigen. In diesen Fällen kannst du deiner Benachrichtigung einen Full-Screen Intent zuordnen.

Achtung :Benachrichtigungen mit Full-Screen-Intents sind erheblich aufdringlich. Daher ist es wichtig, diese Art von Benachrichtigung nur bei dringenden, zeitkritischen Nachrichten zu verwenden.

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 abdeckt.
• Wenn das Gerät des Nutzers entsperrt ist, wird die Benachrichtigung in einem erweiterten Formular mit Optionen zum Umgang mit oder Schließen der Benachrichtigung angezeigt.

Hinweis :Wenn deine App auf Android 10 (API-Level 29) oder höher ausgerichtet ist, musst du in der Manifestdatei deiner App die Berechtigung USE_FULL_SCREEN_INTENT anfordern, damit das System die Vollbildaktivität für die zeitkritische Benachrichtigung startet.

Das folgende Code-Snippet zeigt, wie Sie Ihre Benachrichtigung mit einem Full-Screen-Intent verknüpfen:

Kotlin

val fullScreenIntent = Intent(this, ImportantActivity::class.java)
val fullScreenPendingIntent = PendingIntent.getActivity(this, 0,
    fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT)

var builder = NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        .setFullScreenIntent(fullScreenPendingIntent, true)

Java

Intent fullScreenIntent = new Intent(this, ImportantActivity.class);
PendingIntent fullScreenPendingIntent = PendingIntent.getActivity(this, 0,
        fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT);

NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        .setFullScreenIntent(fullScreenPendingIntent, true);

Sichtbarkeit des Sperrbildschirms festlegen

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

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

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

• VISIBILITY_PRIVATE: Auf dem Sperrbildschirm werden nur allgemeine 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 angeben, in der bestimmte Details verborgen sind. Eine SMS-App kann beispielsweise eine Benachrichtigung mit dem Inhalt „Du hast drei neue SMS haben“ anzeigen, aber den Inhalt und die Absender der Nachricht werden ausgeblendet. Um diese alternative Benachrichtigung bereitzustellen, musst du zuerst die alternative Benachrichtigung wie gewohnt mit NotificationCompat.Builder erstellen. Hängen Sie dann die alternative Benachrichtigung mit setPublicVersion() an die normale Benachrichtigung an.

Nutzer haben immer die ultimative Kontrolle darüber, ob ihre Benachrichtigungen auf dem Sperrbildschirm angezeigt werden und wie sie diese basierend auf den Benachrichtigungskanälen Ihrer App steuern können.

Benachrichtigung aktualisieren

Um eine Benachrichtigung nach dem Senden zu aktualisieren, rufen Sie NotificationManagerCompat.notify() noch einmal auf und übergeben Sie dieselbe ID, die Sie zuvor verwendet haben. Wird die vorherige Benachrichtigung geschlossen, wird stattdessen eine neue Benachrichtigung erstellt.

Sie können optional setOnlyAlertOnce() aufrufen. Dadurch wird der Nutzer durch Töne, Vibrationen oder visuelle Hinweise unterbrochen, wenn die Benachrichtigung zum ersten Mal angezeigt wird, und nicht bei späteren Updates.

Achtung :Android wendet beim Aktualisieren einer Benachrichtigung eine Ratenbegrenzung an. Wenn Sie Aktualisierungen zu häufig – viele in weniger als einer Sekunde – veröffentlichen, werden sie möglicherweise vom System verworfen.

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.
• Für eine bestimmte Benachrichtigungs-ID rufen Sie cancel() auf. Mit dieser Methode werden auch laufende Benachrichtigungen gelöscht.
• Sie rufen cancelAll() auf. Damit werden alle Benachrichtigungen entfernt, die Sie zuvor gesendet haben.
• Die angegebene Dauer läuft ab, wenn Sie beim Erstellen der Benachrichtigung mit setTimeoutAfter() ein Zeitlimit festlegen. Bei Bedarf können Sie eine Benachrichtigung abbrechen, bevor das angegebene Zeitlimit erreicht wird.

Best Practices für Messaging-Apps

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

MessagingStyle verwenden

Ab Android 7.0 (API-Ebene 24) bietet Android eine Benachrichtigungsstilvorlage speziell für Nachrichteninhalte. Mit der Klasse NotificationCompat.MessagingStyle können Sie mehrere Labels, die in der Benachrichtigung angezeigt werden, ändern, darunter den Titel der Unterhaltung, zusätzliche Nachrichten und die Inhaltsansicht der Benachrichtigung.

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

Kotlin

val user = Person.Builder()
    .setIcon(userIcon)
    .setName(userName)
    .build()

val notification = NotificationCompat.Builder(this, CHANNEL_ID)
    .setContentTitle("2 new messages with $sender")
    .setContentText(subject)
    .setSmallIcon(R.drawable.new_message)
    .setStyle(NotificationCompat.MessagingStyle(user)
        .addMessage(messages[1].getText(), messages[1].getTime(), messages[1].getPerson())
        .addMessage(messages[2].getText(), messages[2].getTime(), messages[2].getPerson())
    )
    .build()

Java

Person user = new Person.Builder()
    .setIcon(userIcon)
    .setName(userName)
    .build();

Notification notification = new NotificationCompat.Builder(this, CHANNEL_ID)
    .setContentTitle("2 new messages with " + sender)
    .setContentText(subject)
    .setSmallIcon(R.drawable.new_message)
    .setStyle(new NotificationCompat.MessagingStyle(user)
        .addMessage(messages[1].getText(), messages[1].getTime(), messages[1].getPerson())
        .addMessage(messages[2].getText(), messages[2].getTime(), messages[2].getPerson())
    )
    .build();

Ab Android 9.0 (API-Level 28) ist außerdem die Verwendung der Klasse Person erforderlich, um ein optimales Rendering der Benachrichtigung und ihrer Avatare zu erhalten.

Wenn du NotificationCompat.MessagingStyle verwendest, gehe so vor:

• Rufen Sie MessagingStyle.setConversationTitle() auf, um einen Titel für Gruppenchats mit mehr als zwei Personen festzulegen. Ein guter Unterhaltungstitel könnte der Name des Gruppenchats oder, falls er keinen Namen hat, eine Liste der Teilnehmer der Unterhaltung sein. Andernfalls kann die Nachricht als zu einer 1:1-Unterhaltung mit dem Absender der neuesten Nachricht in der Konversation gehörend angesehen werden.
• Verwenden Sie die Methode MessagingStyle.setData(), um Mediennachrichten wie Bilder einzuschließen. Es werden MIME-Typen des Musters „image/*“ unterstützt.

Direktantwort verwenden

Mit der Direktantwort können Nutzer direkt auf eine Nachricht antworten.

• Nachdem ein Nutzer mit der Inline-Antwortaktion geantwortet hat, verwenden Sie MessagingStyle.addMessage(), um die MessagingStyle-Benachrichtigung zu aktualisieren. Ziehen Sie die Benachrichtigung weder zurück noch brechen Sie sie ab. Wenn die Benachrichtigung nicht abgebrochen wird, kann der Nutzer mehrere Antworten aus der Benachrichtigung senden.
• Rufe Action.WearableExtender.setHintDisplayInlineAction(true) auf, um die Inline-Antwort-Aktion mit Wear OS kompatibel zu machen.
• Verwenden Sie die Methode addHistoricMessage(), um Kontext für eine Direct-Response-Unterhaltung bereitzustellen, indem Sie ältere Nachrichten zur Benachrichtigung hinzufügen.

Intelligente Antwort aktivieren

• Um „Intelligente Antwort“ zu aktivieren, rufen Sie für die Antwortaktion setAllowGeneratedResponses(true) 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 Modell für maschinelles Lernen vollständig auf der Uhr generiert. Dabei wird der von der NotificationCompat.MessagingStyle-Benachrichtigung bereitgestellten Kontext verwendet. Es werden keine Daten in das Internet hochgeladen, um die Antworten zu generieren.

Metadaten für Benachrichtigungen hinzufügen

• Weisen Sie Benachrichtigungsmetadaten zu, um dem System mitzuteilen, wie Ihre App-Benachrichtigungen verarbeitet 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 „Bitte nicht stören“ zu überschreiben.