Benachrichtigung erstellen

Benachrichtigungen liefern kurze, zeitnahe Informationen zu Ereignissen in Ihrer App, wenn sie nicht verwendet wird. In diesem Dokument wird gezeigt, wie Sie eine Benachrichtigung mit verschiedenen Funktionen erstellen. Eine Einführung in die Darstellung von Benachrichtigungen unter Android, finden Sie in der Übersicht zu Benachrichtigungen. Beispielcode, der Benachrichtigungen verwendet, finden Sie im SociaLite-Beispiel auf GitHub.

Der Code auf dieser Seite verwendet die NotificationCompat-APIs aus der AndroidX -Bibliothek. 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-Level 28) gewährleisten. Einige Funktionen wie die Inline-Antwortaktion führen jedoch in früheren Versionen zu einer No-Op.

Einfache Benachrichtigung erstellen

Eine Benachrichtigung in ihrer einfachsten und kompaktesten Form – auch minimierte Form genannt – zeigt ein Symbol, einen Titel und einen kurzen Text an. In diesem Abschnitt wird gezeigt, wie Sie eine Benachrichtigung erstellen, über die der Nutzer eine Aktivität in Ihrer App starten kann.

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

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

Laufzeitberechtigung deklarieren

Android 13 (API-Level 33) und höher unterstützt eine Laufzeitberechtigung zum Posten von Benachrichtigungen aus einer App, die nicht ausgenommen sind (einschließlich Diensten im Vordergrund (FGS)).

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 Sie eine Benachrichtigung mit den folgenden Elementen erstellen:

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

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

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

• Die Benachrichtigungspriorität, die mit setPriority() festgelegt wird. Die Priorität bestimmt, wie aufdringlich die Benachrichtigung unter Android 7.1 und früher ist. Unter Android 8.0 und höher legen Sie stattdessen die Kanalwichtigkeit fest, wie im nächsten Abschnitt gezeigt.

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

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

Für den NotificationCompat.Builder-Konstruktor müssen Sie eine Kanal-ID angeben. Dies ist für die Kompatibilität mit Android 8.0 (API-Level 26) und höher erforderlich, wird aber 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 Sie möchten, dass mehr Text in Ihrer Benachrichtigung angezeigt wird, können Sie eine maximierbare Benachrichtigung aktivieren, indem Sie mit setStyle() eine Stilvorlage hinzufügen. Mit dem folgenden Code wird beispielsweise ein größerer Textbereich erstellt:

var builder = NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Much longer text that cannot fit one line...")
        <b>.setStyle(NotificationCompat.BigTextStyle()
                .bigText("Much longer text that cannot fit one line..."))</b>
        .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...")
        <b>.setStyle(new NotificationCompat.BigTextStyle()
                .bigText("Much longer text that cannot fit one line..."))</b>
        .setPriority(NotificationCompat.PRIORITY_DEFAULT);

Weitere Informationen zu anderen Stilen für große Benachrichtigungen, einschließlich des Hinzufügens eines Bildes und der Steuerelemente für die Medienwiedergabe, finden Sie unter Maximierbare Benachrichtigung erstellen.

Kanal erstellen und Wichtigkeit festlegen

Bevor Sie die Benachrichtigung unter Android 8.0 und höher senden können, müssen Sie den Benachrichtigungskanal Ihrer App beim System registrieren. Dazu übergeben Sie eine Instanz von NotificationChannel an createNotificationChannel(). Der folgende Code wird durch eine Bedingung für die SDK_INT Version 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 senden können, führen Sie diesen Code aus, sobald Ihre App gestartet wird. Sie können ihn bedenkenlos wiederholt aufrufen, da beim Erstellen eines vorhandenen Benachrichtigungskanals keine Aktion ausgeführt wird.

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

Obwohl Sie die Wichtigkeit oder Priorität der Benachrichtigung wie im folgenden Beispiel gezeigt festlegen müssen, garantiert das System nicht das gewünschte Benachrichtigungsverhalten. In einigen Fällen ändert das System die Wichtigkeitsstufe möglicherweise basierend auf anderen Faktoren. Der Nutzer kann die Wichtigkeitsstufe für einen bestimmten Kanal jederzeit neu definieren.

Weitere Informationen zu den verschiedenen Stufen finden Sie unter Wichtigkeitsstufen von Benachrichtigungen.

Tippaktion für die Benachrichtigung festlegen

Jede Benachrichtigung muss auf ein Tippen reagieren, in der Regel durch Öffnen einer Aktivität in Ihrer App, die der Benachrichtigung entspricht. Geben Sie dazu einen Content-Intent an, der mit einem PendingIntent-Objekt definiert ist, und übergeben Sie ihn 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:

// Create an explicit intent for an Activity in your app.
<b>val intent = Intent(this, AlertDetails::class.java).apply {
    flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
}</b>
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.
        <b>.setContentIntent(pendingIntent)</b>
        .setAutoCancel(true)

// Create an explicit intent for an Activity in your app.
<b>Intent intent = new Intent(this, AlertDetails.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);</b>
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.
        <b>.setContentIntent(pendingIntent)</b>
        .setAutoCancel(true);

Dieser Code ruft setAutoCancel() auf, 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 erhalten bleibt, 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 Möglichkeiten gibt es:

• 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 startet die Aktivität eine neue Aufgabe, anstatt der vorhandenen Aufgabe und dem Back-Stack Ihrer App hinzugefügt zu werden. Dies ist der Typ von Intent, 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 Back-Stack erstellt, sodass 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 eine Benachrichtigung starten.

Benachrichtigung anzeigen

Rufen Sie NotificationManagerCompat.notify() auf, um die Benachrichtigung anzuzeigen. Übergeben Sie eine eindeutige ID für die Benachrichtigung und das Ergebnis von NotificationCompat.Builder.build(). Dies ist im folgenden Beispiel dargestellt:

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

if (ActivityCompat.checkSelfPermission(this, android.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;
}
NotificationManagerCompat.from(this).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 außerdem einfache Benachrichtigungen auf Geräten mit Android 13 und höher testen möchten, aktivieren Sie Benachrichtigungen manuell oder erstellen Sie ein Dialogfeld, um Benachrichtigungen anzufordern.

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 Nachricht zu antworten. Diese Aktionsschaltflächen dürfen jedoch die Aktion nicht 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 addAction() Methode. 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 eine Aufgabe im Hintergrund ausführt, sodass die Aktion die bereits geöffnete App nicht unterbricht.

Der folgende Code zeigt beispielsweise, wie Sie eine Broadcast-Nachricht an einen bestimmten Empfänger senden:

val ACTION_SNOOZE = "snooze"

<b>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)</b>
val builder = NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        .setContentIntent(pendingIntent)
        <b>.addAction(R.drawable.ic_snooze, getString(R.string.snooze),
                snoozePendingIntent)</b>

String ACTION_SNOOZE = "snooze"

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

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)
        <b>.addAction(R.drawable.ic_snooze, getString(R.string.snooze),
                snoozePendingIntent);</b>

Weitere Informationen zum Erstellen eines BroadcastReceiver zum Ausführen von Hintergrund aufgaben 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 Anhalten und Überspringen von Titeln, finden Sie hier Informationen zum Erstellen einer Benachrichtigung mit Medien steuerelementen.

Direktantwortaktion hinzufügen

Mit der Direktantwortaktion, die in Android 7.0 (API-Level 24) eingeführt wurde, können Nutzer Text direkt in die Benachrichtigung eingeben. Der Text wird dann an Ihre App gesendet, ohne dass eine Aktivität geöffnet wird. Sie können beispielsweise eine Direktantwortaktion verwenden, damit Nutzer direkt über die Benachrichtigung auf SMS antworten oder Aufgabenlisten aktualisieren können.

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

Die Direktantwortaktion wird als zusätzliche Schaltfläche in der Benachrichtigung angezeigt, über die eine Texteingabe geöffnet wird. Wenn der Nutzer die Eingabe beendet hat, fügt 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 Direktantworten 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, der vom System als Schlüssel für die Texteingabe verwendet wird. Ihre App verwendet diesen Schlüssel später , um den Text der Eingabe abzurufen. * {Kotlin} ```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} ```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 ein PendingIntent für die Antwortaktion. * {Kotlin} ```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} ```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} ```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} ```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} ```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} ```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 aus der Antwort-UI der Benachrichtigung erhalten möchten, rufen Sie RemoteInput.getResultsFromIntent() auf und übergeben Sie den Intent, der von Ihrem 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;
 }

Nachdem Sie den Text verarbeitet haben, aktualisieren Sie die Benachrichtigung, indem Sie NotificationManagerCompat.notify() mit derselben ID und demselben Tag aufrufen, falls verwendet. Dies ist erforderlich, um die Direktantwort-UI auszublenden und dem Nutzer zu bestätigen, dass seine Antwort korrekt empfangen und 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);

Andere Daten abrufen

Die Verarbeitung anderer Datentypen funktioniert ähnlich mit RemoteInput. Im folgenden Beispiel wird ein Bild als Eingabe verwendet.

  // Key for the data that's delivered in the action's intent.
  private val KEY_REPLY = "key_reply"
  var replyLabel: String = resources.getString(R.string.reply_label)
  var remoteInput: RemoteInput = RemoteInput.Builder(KEY_REPLY).run {
      setLabel(replyLabel)
      // Allow for image data types in the input
  // This method can be used again to
  // allow for other data types
      setAllowDataType("image/*", true)
      build()
}

Rufen Sie RemoteInput#getDataResultsFromIntent auf und extrahieren Sie die entsprechenden Daten.

  import android.app.RemoteInput;
  import android.content.Intent;
  import android.os.Bundle;

  class ReplyReceiver: BroadcastReceiver()  {

      public static final String KEY_DATA = "key_data";

      public static void handleRemoteInput(Intent intent) {
          Bundle dataResults = RemoteInput.getDataResultsFromIntent(intent, KEY_DATA);
          val imageUri: Uri? = dataResults.values.firstOrNull()
          if (imageUri != null) {
              // Extract the image
          try {
                  val inputStream = context.contentResolver.openInputStream(imageUri)
                  val bitmap = BitmapFactory.decodeStream(inputStream)
                  // Display the image
                  // ...
              } catch (e: Exception) {
                  Log.e("ReplyReceiver", "Failed to process image URI", e)
              }
      }
  }

Verwenden Sie bei dieser neuen Benachrichtigung den Kontext, der an die receiver's onReceive() Methode übergeben wird.

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

Wenn die Benachrichtigung aufgerufen wird, sieht der 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 einer maximierten Form angezeigt, die Optionen zum Verarbeiten oder Schließen der Benachrichtigung enthält.

Das folgende Code-Snippet zeigt, wie Sie Ihre Benachrichtigung mit einem Full-Screen Intent 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)
        <b>.setFullScreenIntent(fullScreenPendingIntent, true)</b>

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)
        <b>.setFullScreenIntent(fullScreenPendingIntent, true);</b>

Sichtbarkeit auf dem Sperrbildschirm festlegen

Wenn Sie den Detaillierungsgrad steuern möchten, der in der Benachrichtigung auf dem Sperrbildschirm sichtbar ist, 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 Titel des Inhalts angezeigt. Der vollständige Inhalt der Benachrichtigung wird nicht angezeigt.

Wenn Sie VISIBILITY_PRIVATE festlegen, können Sie auch eine alternative Version des Benachrichtigungsinhalts bereitstellen, in der bestimmte Details ausgeblendet sind. Eine SMS-App kann beispielsweise eine Benachrichtigung anzeigen, die „Sie haben 3 neue SMS“ enthält, aber den Inhalt der Nachrichten und die Absender ausblendet. Wenn Sie diese alternative Benachrichtigung bereitstellen möchten, erstellen Sie sie zuerst wie gewohnt mit NotificationCompat.Builder. Hängen Sie dann die alternative Benachrichtigung mit setPublicVersion() an die normale Benachrichtigung an.

Beachten Sie, dass der Nutzer immer die volle Kontrolle darüber hat, ob seine Benachrichtigungen auf dem Sperrbildschirm sichtbar sind, und sie anhand der Benachrichtigungskanäle Ihrer App steuern kann.

Benachrichtigung aktualisieren

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

Optional können Sie setOnlyAlertOnce() aufrufen, damit Ihre Benachrichtigung den Nutzer nur beim ersten Erscheinen unterbricht – mit Ton, Vibration oder visuellen Hinweisen – und nicht bei späteren Aktualisierungen.

Benachrichtigung entfernen

Benachrichtigungen bleiben sichtbar, bis eine der folgenden Bedingungen erfüllt ist:

• Der Nutzer schließt die Benachrichtigung.
• Der Nutzer tippt auf die Benachrichtigung, wenn Sie beim Erstellen der Benachrichtigung setAutoCancel() aufrufen.
• Sie rufen cancel() für eine bestimmte Benachrichtigungs-ID auf. Mit dieser Methode werden auch laufende Benachrichtigungen gelöscht.
• Sie rufen cancelAll() auf, wodurch alle zuvor gesendeten Benachrichtigungen entfernt werden.
• Die angegebene Dauer ist abgelaufen, wenn Sie beim Erstellen der Benachrichtigung mit setTimeoutAfter() ein Zeitlimit festgelegt haben. Bei Bedarf können Sie eine Benachrichtigung abbrechen, bevor das angegebene Zeitlimit abläuft.

Best Practices für Messaging-Apps

Beachten Sie beim Erstellen von Benachrichtigungen für Ihre Messaging- und Chat-Apps die hier aufgeführten Best Practices.

MessagingStyle verwenden

Ab Android 7.0 (API-Level 24) bietet Android eine Benachrichtigungsstilvorlage speziell für Messaging-Inhalte. Mit der NotificationCompat.MessagingStyle Klasse können Sie mehrere der Labels ändern, die in der Benachrichtigung angezeigt werden, einschließlich des Unterhaltungstitels, zusätzlicher Nachrichten und der Inhaltsansicht für die Benachrichtigung.

Das folgende Code-Snippet zeigt, wie Sie den Stil einer Benachrichtigung mit der Klasse MessagingStyle anpassen.

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

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

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

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

Ab Android 9.0 (API-Level 28) ist es auch erforderlich, die Person Klasse zu verwenden, um eine optimale Darstellung der Benachrichtigung und ihrer Avatare zu erhalten.

Beachten Sie bei der Verwendung von NotificationCompat.MessagingStyle Folgendes:

• Rufen Sie MessagingStyle.setConversationTitle() auf, um einen Titel für Gruppen chats mit mehr als zwei Personen festzulegen. Ein guter Unterhaltungstitel kann der Name des Gruppenchats sein oder, wenn er keinen Namen hat, eine Liste der Teilnehmer an der Unterhaltung. Andernfalls wird die Nachricht möglicherweise fälschlicherweise einer Einzelunterhaltung mit dem Absender der letzten Nachricht in der Unterhaltung zugeordnet.
• Verwenden Sie die MessagingStyle.setData() Methode, um Mediennachrichten wie Bilder einzufügen. MIME-Typen des Musters image/* werden unterstützt.

Direktantwort verwenden

Mit der Direktantwort kann ein 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, und ziehen Sie die Benachrichtigung nicht zurück oder brechen Sie sie nicht ab. Wenn Sie die Benachrichtigung nicht abbrechen, 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 addHistoricMessage() Methode, um einer Direktantwortunterhaltung Kontext zu geben, indem Sie der Benachrichtigung frühere Nachrichten hinzufügen.

Intelligente Antworten aktivieren

• Wenn Sie intelligente Antworten aktivieren möchten, rufen Sie für die Antwortaktion setAllowGeneratedResponses(true) auf. Dadurch sind intelligente Antworten für Nutzer verfügbar, wenn die Benachrichtigung an ein Wear OS-Gerät weitergeleitet wird. Intelligente Antworten werden von einem vollständig auf der Smartwatch ausgeführten Modell für maschinelles Lernen generiert, das den Kontext verwendet, der von der NotificationCompat.MessagingStyle-Benachrichtigung bereitgestellt wird. Es werden keine Daten ins Internet hochgeladen, um die Antworten zu generieren.

Benachrichtigungsmetadaten hinzufügen

• Weisen Sie Benachrichtigungsmetadaten zu, um dem System mitzuteilen, wie Benachrichtigungen Ihrer App verarbeitet werden sollen, wenn sich das Gerät im Modus Do Not Disturb modebefindet. Verwenden Sie beispielsweise die addPerson() oder setCategory(Notification.CATEGORY_MESSAGE) Methode, um „Bitte nicht stören“ zu überschreiben.