Benachrichtigung erstellen

Benachrichtigungen liefern kurze, zeitnahe Informationen zu Ereignissen in Ihrer App, wenn sie nicht verwendet wird. In diesem Dokument wird beschrieben, wie Sie eine Benachrichtigung mit verschiedenen Funktionen erstellen. Eine Einführung in die Darstellung von Benachrichtigungen unter Android finden Sie in der Übersicht über Benachrichtigungen. Beispielcode, der Benachrichtigungen verwendet, finden Sie im SociaLite-Beispiel 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-Antwortaktion, führen jedoch in früheren Versionen zu einem No-Op.

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

Groovy

dependencies {
    implementation "androidx.core:core-ktx:1.16.0"
}

Kotlin

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

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

Einfache Benachrichtigung erstellen

Eine Benachrichtigung in ihrer einfachsten und kompaktesten Form – auch minimierte Form genannt – enthält ein Symbol, einen Titel und wenig Text. In diesem Abschnitt wird gezeigt, 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 etwas Text.

Weitere Informationen zu den einzelnen Teilen einer Benachrichtigung finden Sie unter Aufbau von Benachrichtigungen.

Laufzeitberechtigung deklarieren

Unter Android 13 (API‑Level 33) und höher wird eine Laufzeitberechtigung zum Senden von nicht ausgenommenen Benachrichtigungen (einschließlich Diensten im Vordergrund) über eine App unterstützt.

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

<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. Im folgenden Beispiel wird gezeigt, wie eine Benachrichtigung mit den folgenden Eigenschaften erstellt wird:

• Ein kleines Symbol, das mit setSmallIcon() festgelegt wird. Dies sind die einzigen für Nutzer sichtbaren Inhalte, die erforderlich sind.

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

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

• Die von setPriority() festgelegte Benachrichtigungspriorität. 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 fest, wie im nächsten Abschnitt beschrieben.

Kotlin

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

Java

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

Für den NotificationCompat.Builder-Konstruktor müssen Sie eine Kanal-ID angeben. Dies ist für die Kompatibilität mit Android 8.0 (API-Ebene 26) und höher erforderlich, wird jedoch von früheren 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 ihrer minimierten und maximierten 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ößerer Textbereich erstellt:

Kotlin

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

Java

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

Weitere Informationen zu anderen großen Benachrichtigungsstilen, einschließlich des Hinzufügens eines Bildes und von Steuerelementen für die Medienwiedergabe, finden Sie unter Maximierbare Benachrichtigungen erstellen.

Channel 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 den Benachrichtigungskanal erstellen müssen, bevor Sie Benachrichtigungen unter Android 8.0 und höher senden, sollten Sie diesen Code ausführen, sobald Ihre App gestartet wird. Dieser Aufruf kann wiederholt erfolgen, da beim Erstellen eines vorhandenen Benachrichtigungschannels keine Aktion ausgeführt wird.

Für den NotificationChannel-Konstruktor ist ein importance erforderlich, das eine der Konstanten aus der Klasse NotificationManager verwendet. Mit diesem Parameter wird festgelegt, wie der Nutzer bei Benachrichtigungen dieses Channels unterbrochen werden soll. Legen Sie die priority mit setPriority() fest, um Android 7.1 und früher zu unterstützen, wie im vorherigen Beispiel gezeigt.

Sie müssen zwar die Wichtigkeit oder Priorität der Benachrichtigung wie im folgenden Beispiel gezeigt festlegen, das System garantiert jedoch nicht das angezeigte Verhalten. In einigen Fällen kann das System die Wichtigkeitsstufe basierend auf anderen Faktoren ändern. Nutzer können die Wichtigkeitsstufe für einen bestimmten Channel aber jederzeit neu festlegen.

Weitere Informationen zu den verschiedenen Stufen

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

Das folgende Snippet zeigt, wie Sie einen einfachen 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);

Mit diesem Code wird setAutoCancel() aufgerufen, wodurch die Benachrichtigung automatisch entfernt wird, wenn der Nutzer darauf tippt.

Die Intent-Flags im vorherigen Beispiel sorgen dafür, dass die erwartete Navigation des Nutzers beibehalten wird, 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. Folgende Aktivitäten sind möglich:

• Eine Aktivität, die ausschließlich für Antworten auf die Benachrichtigung vorhanden ist. Es gibt keinen Grund, warum der Nutzer während der normalen App-Nutzung zu dieser Aktivität navigiert. Daher wird mit der Aktivität eine neue Aufgabe gestartet, anstatt sie der vorhandenen Aufgabe und dem Backstack Ihrer App hinzuzufügen. Dies ist der Intent-Typ, der im vorherigen Beispiel erstellt wurde.

• Eine Aktivität, die im regulären App-Ablauf Ihrer App vorhanden ist. In diesem Fall wird beim Starten der Aktivität ein Backstack erstellt, damit die Erwartungen des Nutzers an die Schaltflächen „Zurück“ und „Nach 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

Damit die Benachrichtigung angezeigt wird, rufen Sie 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, 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 erstellen, um Benachrichtigungen anzufordern.

Hinweis :Ab Android 8.1 (API-Ebene 27) können Apps nicht mehr als einmal pro Sekunde einen Benachrichtigungston ausgeben lassen. Wenn deine App in einer Sekunde mehrere Benachrichtigungen sendet, werden alle erwartungsgemäß zugestellt, es wird aber nur für die erste Benachrichtigung 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 zu verschieben 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 ein PendingIntent an die Methode addAction(). Das ist so, als würden Sie die Standard-Tippaktion der Benachrichtigung einrichten. Anstatt eine Aktivität zu starten, können Sie jedoch andere Aktionen ausführen, z. B. einen BroadcastReceiver starten, der einen Job im Hintergrund ausführt, damit die Aktion die bereits geöffnete App nicht unterbricht.

Der folgende Code zeigt beispielsweise, wie eine Broadcast-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 zum Ausführen von Hintergrundaufgaben 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, erfahren Sie hier, wie Sie eine Benachrichtigung mit Mediensteuerelementen erstellen.

Hinweis :In Android 10 (API-Level 29) und höher generiert die Plattform automatisch Schaltflächen für Benachrichtigungsaktionen, wenn eine App keine eigenen bereitstellt. Wenn Sie nicht möchten, dass in den Benachrichtigungen Ihrer App vorgeschlagene Antworten oder Aktionen angezeigt werden, können Sie die systemgenerierten Antworten und Aktionen mit setAllowGeneratedReplies() und setAllowSystemGeneratedContextualActions() deaktivieren.

Direktantwortaktion hinzufügen

Mit der in Android 7.0 (API-Ebene 24) eingeführten Aktion für die Direktantwort 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 Aktion für die direkte Antwort können Nutzer beispielsweise direkt in der Benachrichtigung auf SMS antworten oder Aufgabenlisten aktualisieren.

Abbildung 4: Wenn Sie auf die Schaltfläche „Antworten“ tippen, wird die Texteingabe geöffnet.

Die Aktion für die Direktantwort wird als zusätzliche Schaltfläche in der Benachrichtigung angezeigt, über die eine Texteingabe geöffnet wird. Wenn der Nutzer die Eingabe beendet hat, hängt das System die Textantwort an den Intent an, den Sie für die Benachrichtigungsaktion angegeben haben, und sendet den Intent an Ihre App.

Schaltfläche „Antworten“ hinzufügen

So erstellen Sie eine Benachrichtigungsaktion, die die Direktantwort 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);
     

   Achtung:Wenn Sie eine PendingIntent wiederverwenden, antwortet ein Nutzer möglicherweise auf eine andere Unterhaltung als beabsichtigt. Sie müssen für jede Unterhaltung einen anderen Anfragecode angeben oder einen Intent angeben, der bei einem Aufruf von equals() für den Antwort-Intent einer anderen Unterhaltung nicht true zurückgibt. Die Unterhaltungs-ID wird häufig als Teil des Extras-Bundles der Intention übergeben, wird aber ignoriert, wenn Sie equals() aufrufen.
3. Hängen Sie das Objekt RemoteInput 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 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 er die Benachrichtigungsaktion auslöst (siehe Abbildung 4).

Nutzer-Eingabe aus der Antwort abrufen

Wenn Sie Nutzereingaben über die Antwort-UI der Benachrichtigung empfangen möchten, rufen Sie RemoteInput.getResultsFromIntent() auf und übergeben Sie die Intent, die von Ihrem BroadcastReceiver empfangen wurde:

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;
 }

Aktualisieren Sie die Benachrichtigung nach der Verarbeitung des Texts, indem Sie NotificationManagerCompat.notify() mit derselben ID und demselben Tag (falls verwendet) aufrufen. Das ist erforderlich, um die Benutzeroberfläche für direkte Antworten auszublenden und dem Nutzer zu bestätigen, dass seine Antwort korrekt empfangen und verarbeitet wurde.

Kotlin

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

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

Java

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

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

Verwenden Sie beim Arbeiten mit dieser neuen Benachrichtigung den Kontext, der an die onReceive()-Methode des Empfängers übergeben wird.

Hängen Sie die Antwort unten an die Benachrichtigung an, indem Sie setRemoteInputHistory() aufrufen. Wenn Sie jedoch eine Messaging-App entwickeln, erstellen Sie eine Benachrichtigung 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.

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 einen Vollbild-Intent zuordnen.

Achtung :Benachrichtigungen mit Full-Screen-Intents sind sehr aufdringlich. Verwenden Sie diesen Benachrichtigungstyp daher nur für die dringendsten, zeitkritischen Nachrichten.

Wenn die Benachrichtigung ausgelöst wird, sehen Nutzer je nach Sperrstatus des Geräts Folgendes:

• Wenn das Gerät des Nutzers gesperrt ist, wird eine Vollbild-Activity angezeigt, die den Sperrbildschirm abdeckt.
• Wenn das Gerät des Nutzers entsperrt ist, wird die Benachrichtigung in erweiterter Form angezeigt. Sie enthält Optionen zum Bearbeiten oder Schließen der Benachrichtigung.

Hinweis :Wenn Ihre App auf Android 10 (API-Level 29) oder höher ausgerichtet ist, müssen Sie die Berechtigung USE_FULL_SCREEN_INTENT in der Manifestdatei Ihrer App anfordern, damit das System die mit der zeitkritischen Benachrichtigung verknüpfte Vollbildaktivität starten kann.

Das folgende Code-Snippet zeigt, wie Sie Ihre Benachrichtigung mit einem Vollbild-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 den Detaillierungsgrad der Benachrichtigung auf dem Sperrbildschirm festlegen möchten, 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: Auf dem Sperrbildschirm wird kein Teil der Benachrichtigung 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 kann beispielsweise eine Benachrichtigung mit dem Text „Sie haben 3 neue SMS“ anzeigen, aber den Inhalt der Nachrichten und die Absender ausblenden. Um diese alternative Benachrichtigung bereitzustellen, erstellen Sie zuerst die alternative Benachrichtigung mit NotificationCompat.Builder. Hängen Sie dann die alternative Benachrichtigung mit setPublicVersion() an die normale Benachrichtigung an.

Der Nutzer hat immer die volle Kontrolle darüber, ob seine Benachrichtigungen auf dem Sperrbildschirm sichtbar sind, und kann sie anhand der Benachrichtigungschannels Ihrer App verwalten.

Benachrichtigung aktualisieren

Wenn Sie eine Benachrichtigung nach dem Ausstellen aktualisieren möchten, rufen Sie NotificationManagerCompat.notify() noch einmal auf und übergeben Sie dieselbe ID wie zuvor. Wenn die vorherige Benachrichtigung geschlossen wird, wird stattdessen eine neue Benachrichtigung erstellt.

Optional können Sie setOnlyAlertOnce() aufrufen, damit Ihre Benachrichtigung den Nutzer nur beim ersten Erscheinen der Benachrichtigung durch Ton, Vibration oder visuelle Hinweise unterbricht und nicht bei späteren Aktualisierungen.

Achtung :Unter Android wird eine Ratenbegrenzung angewendet, wenn eine Benachrichtigung aktualisiert wird. Wenn du zu einer Benachrichtigung zu häufig Aktualisierungen sendest (mehrere Male in weniger als einer Sekunde), werden einige Aktualisierungen 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 setAutoCancel() aufrufen, wenn Sie die Benachrichtigung erstellen.
• Sie rufen cancel() für eine bestimmte Benachrichtigungs-ID auf. Mit dieser Methode werden auch laufende Benachrichtigungen gelöscht.
• Sie rufen cancelAll() auf, wodurch alle zuvor ausgegebenen Benachrichtigungen entfernt werden.
• Die angegebene Dauer läuft ab, wenn Sie beim Erstellen der Benachrichtigung mit setTimeoutAfter() ein Zeitlimit festlegen. 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-Level 24) bietet Android eine Benachrichtigungsstilvorlage speziell für Messaging-Inhalte. Mit der Klasse NotificationCompat.MessagingStyle können Sie mehrere Labels ändern, die in der Benachrichtigung angezeigt werden, z. B. den Konversationstitel, zusätzliche Nachrichten und die Inhaltsansicht für die Benachrichtigung.

Das folgende Code-Snippet zeigt, wie Sie den Stil einer Benachrichtigung mit 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 es außerdem erforderlich, die Klasse Person zu verwenden, um eine optimale Darstellung der Benachrichtigung und ihrer Avatare zu erhalten.

Gehen Sie bei der Verwendung von NotificationCompat.MessagingStyle so vor:

• Mit dem Befehl „Call“ MessagingStyle.setConversationTitle() können Sie einen Titel für Gruppenchats mit mehr als zwei Personen festlegen. Ein guter Unterhaltungstitel könnte der Name des Gruppenchats oder, falls er keinen Namen hat, eine Liste der Teilnehmer der Unterhaltung sein. Andernfalls könnte die Nachricht fälschlicherweise als Teil einer Einzelunterhaltung mit dem Absender der letzten Nachricht in der Unterhaltung angesehen werden.
• 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 „Direkt antworten“ können Nutzer inline 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 nicht zurück und brechen Sie sie nicht ab. Wenn die Benachrichtigung nicht geschlossen wird, kann der Nutzer mehrere Antworten über die Benachrichtigung senden.
• Damit die Inline-Antwortaktion mit Wear OS kompatibel ist, rufen Sie Action.WearableExtender.setHintDisplayInlineAction(true) auf.
• Verwenden Sie die Methode addHistoricMessage(), um einer Unterhaltung mit direkten Antworten Kontext zu geben, indem Sie der Benachrichtigung frühere Nachrichten hinzufügen.

„Intelligente Antwort“ aktivieren

• Um die Funktion „Intelligente Antwort“ zu aktivieren, rufen Sie setAllowGeneratedResponses(true) für die Antwortaktion auf. Dadurch sind Smart Reply-Antworten für Nutzer verfügbar, wenn die Benachrichtigung auf ein Wear OS-Gerät übertragen wird. Die Antworten der Funktion „Intelligente Antwort“ werden von einem vollständig auf der Smartwatch ausgeführten Modell für maschinelles Lernen generiert. Dabei wird der Kontext der NotificationCompat.MessagingStyle-Benachrichtigung verwendet. Es werden keine Daten ins Internet hochgeladen, um die Antworten zu generieren.

Metadaten für Benachrichtigungen hinzufügen

• Weisen Sie Benachrichtigungsmetadaten zu, um dem System mitzuteilen, wie App-Benachrichtigungen behandelt werden sollen, wenn sich das Gerät im 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.