Benachrichtigung erstellen

Benachrichtigungen bieten kurze, zeitnahe Informationen über Ereignisse in Ihrer App, während das Gerät nicht verwendet wird. In diesem Dokument erfahren Sie, wie Sie eine Benachrichtigung mit verschiedene Funktionen. Eine Einführung dazu, wie Benachrichtigungen auf Android-Geräten angezeigt werden, finden Sie unter Benachrichtigungen. Beispielcode, der Benachrichtigungen verwendet, finden Sie im Artikel Personen mit Beispiel auf GitHub.

Für den Code auf dieser Seite wird die Methode NotificationCompat APIs aus der AndroidX-Bibliothek Mit diesen APIs können Sie Funktionen hinzufügen, die nur auf neueren Versionen von Android und bieten gleichzeitig weiterhin Kompatibilität mit Android 9 (API-Level 28). Einige Funktionen, wie die Inline-Antwort, führen bei früheren Versionen keine Vorgänge mehr.

AndroidX Core-Bibliothek hinzufügen

Die meisten mit Android Studio erstellten Projekte enthalten die erforderlichen für die Verwendung von NotificationCompat, prüfen Sie, ob Ihre Modulebene Die Datei build.gradle enthält die folgende Abhängigkeit:

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

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

Grundlegende Benachrichtigung erstellen

Eine Benachrichtigung in ihrer einfachsten und kompaktsten Form – auch als minimierte Benachrichtigung bezeichnet Formular: Es werden ein Symbol, ein Titel und ein wenig Text angezeigt. Dieses Abschnitt zeigt, wie eine Benachrichtigung erstellt wird, auf die der Nutzer tippen kann, um eine Aktivitäten in Ihrer App.

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

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

Laufzeitberechtigung deklarieren

Android 13 (API-Level 33) und höher unterstützt eine Laufzeitberechtigung zum Posten nicht ausgenommene Benachrichtigungen (einschließlich Dienste im Vordergrund) von einer App.

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

<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

Lege zuerst den Inhalt und den Kanal der Benachrichtigung mit einem NotificationCompat.Builder -Objekt enthält. Das folgende Beispiel zeigt, wie Sie eine Benachrichtigung mit der Folgendes:

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

• Ein Titel, der von setContentTitle()

• Der Textkörper, der von setContentText()

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

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 einen Kanal angeben ID. Dies ist aus Gründen der Kompatibilität mit Android 8.0 (API-Level 26) und später, wird aber in früheren Versionen ignoriert.

Standardmäßig wird der Textinhalt der Benachrichtigung auf eine Zeile gekürzt. Ich können durch Erstellen einer maximierbaren Benachrichtigung zusätzliche Informationen angezeigt werden.

Abbildung 2: Expandable-Anzeige in den minimierten und maximierten Formularen anzuzeigen.

Wenn die Benachrichtigung länger sein soll, können Sie ein erweiterbares indem Sie eine Stilvorlage mit setStyle() 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...")
        .setStyle(NotificationCompat.BigTextStyle()
                .bigText("Much longer text that cannot fit one line..."))
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)

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

Weitere Informationen zu anderen großen Benachrichtigungsstilen, z. B. zum Hinzufügen ein Bild und eine Medienwiedergabesteuerung, erhalten Sie unter Erweiterbare Benachrichtigung.

Kanal erstellen und Wichtigkeit festlegen

Bevor Sie die Benachrichtigung unter Android 8.0 und höher senden können, registrieren Sie Ihr Benachrichtigungskanal der App mit dem indem Sie eine Instanz von NotificationChannel bis createNotificationChannel() Der folgende Code wird durch eine Bedingung im SDK_INT-Version:

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 etwas posten Benachrichtigungen unter Android 8.0 und höher, führen Sie diesen Code aus, beginnt. Sie können diesen Aufruf wiederholen, da das Erstellen einer vorhandenen keine Operation durchführt.

Für den NotificationChannel-Konstruktor ist ein importance erforderlich, wobei eine der folgenden Methoden verwendet wird: Konstanten aus der NotificationManager-Kurs. Dieses legt fest, wie der Nutzer bei entsprechenden Benachrichtigungen unterbrochen wird. diesem Kanal hinzugefügt. Legen Sie die Priorität mit setPriority() fest, um Android 7.1 zu unterstützen. und früher, wie im vorherigen Beispiel gezeigt.

Auch wenn Sie die Wichtigkeit oder Priorität der Benachrichtigungen selbst festlegen müssen, folgenden Beispiels nicht garantiert, dass das Warnverhalten nicht garantiert wird. In In einigen Fällen ändert das System die Wichtigkeit basierend auf anderen Faktoren, Die Nutzenden können die Wichtigkeitsstufe für eine bestimmte Kanal.

Weitere Informationen zur Bedeutung der verschiedenen Ebenen finden Sie in den Wichtigkeit der Benachrichtigung Stufen.

Tippaktion der Benachrichtigung festlegen

Jede Benachrichtigung muss auf ein Tippen reagieren. Dies geschieht normalerweise, um eine Aktivität in Ihrem die der Benachrichtigung entspricht. Geben Sie dazu einen Inhalts-Intent an. definiert mit PendingIntent und übergeben es an setContentIntent()

Das folgende Snippet zeigt, wie Sie einen einfachen Intent zum Öffnen einer Aktivität erstellen wenn der Nutzer auf die Benachrichtigung tippt:

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

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

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

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

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

Methode setFlags() wie im vorherigen Beispiel gezeigt, behält die erwartete Navigation des Nutzers nachdem sie Ihre App über die Benachrichtigung geöffnet haben. Vielleicht möchten Sie je nach Art der Aktivität, die Sie beginnen, Folgendes:

• Eine Aktivität, die ausschließlich für Antworten auf die Benachrichtigung dient. Der Nutzer wechselt bei normaler App-Nutzung nicht zu dieser Aktivität, sodass die Aktivität eine neue Aufgabe startet und nicht der vorhandene Aufgabe und zurück Stacks. Dies ist die Art des Intents, der im vorherigen Beispiel erstellt wurde.

• Eine Aktivität, die im regulären App-Ablauf Ihrer App vorhanden ist. In diesem Fall Durch das Starten der Aktivität wird ein Back-Stack erstellt, damit die Erwartungen der Nutzenden für die Schaltflächen „Zurück“ und „Nach oben“ sind beibehalten werden.

Weitere Informationen zu den verschiedenen Möglichkeiten zum Konfigurieren des Benachrichtigungs-Intents findest du unter Aktivität über eine Benachrichtigung starten

Benachrichtigung anzeigen

Um die Benachrichtigung anzuzeigen, rufen Sie NotificationManagerCompat.notify(), und ihm eine eindeutige ID für die Benachrichtigung und das Ergebnis NotificationCompat.Builder.build() Dies wird im folgenden Beispiel gezeigt:

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

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

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

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

Speichern Sie die Benachrichtigungs-ID, die Sie übergeben, in NotificationManagerCompat.notify(). da Sie sie benötigen, wenn Sie die Einstellungen aktualisieren oder entfernen möchten, Benachrichtigung.

Um grundlegende Benachrichtigungen auf Geräten mit Android 13 und höher können Sie Benachrichtigungen manuell aktivieren oder ein Dialogfeld Benachrichtigungen zu Anfragen.

Aktionsschaltflächen hinzufügen

Eine Benachrichtigung kann bis zu drei Aktionsschaltflächen enthalten, über die der Nutzer antworten kann. z. B. um eine Erinnerung zurückzustellen oder auf eine SMS zu antworten. Aber diese Aktionsschaltflächen dürfen nicht die Aktion duplizieren, die ausgeführt wird, wenn der Nutzer auf die Benachrichtigung.

Abbildung 3: Eine Benachrichtigung mit eine Aktionsschaltfläche.

Wenn Sie eine Aktionsschaltfläche hinzufügen möchten, übergeben Sie eine PendingIntent an den addAction() . Dies entspricht der Einrichtung der standardmäßigen Tippaktion für Benachrichtigungen, mit Ausnahme von können Sie auch andere Dinge tun, z. B. eine BroadcastReceiver, die einen Job im Hintergrund ausführen, damit die App nicht unterbrochen wird die bereits offen ist.

Der folgende Code zeigt beispielsweise, wie ein Broadcast an eine bestimmte Empfänger:

val ACTION_SNOOZE = "snooze"

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

String ACTION_SNOOZE = "snooze"

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

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

Weitere Informationen zum Erstellen einer BroadcastReceiver für die Hintergrundausführung findest du in der Übersicht zu Übertragungen.

Wenn Sie stattdessen eine Benachrichtigung mit Wiedergabeschaltflächen für Medien erstellen möchten, wie z. B. zum Pausieren oder Überspringen von Titeln, erfahren Sie, wie Sie eine Benachrichtigung mit Medien erstellen .

Direktantwort-Aktion hinzufügen

Mit der Direct-Response-Aktion, 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 Ihr ohne eine Aktivität zu öffnen. Sie können z. B. eine Direktantwort-Aktion damit Nutzer auf SMS antworten oder Aufgabenlisten aktualisieren können – direkt im Benachrichtigung.

Abbildung 4: Tippe auf „Antworten“ öffnet die Texteingabe.

Die Direktantwort-Aktion erscheint als zusätzliche Schaltfläche in der Benachrichtigung, die öffnet eine Texteingabe. Wenn der Nutzer mit der Eingabe fertig ist, hängt das System den Text an. Antwort an den Intent, den Sie für die Benachrichtigungsaktion angeben, und sendet den auf Ihre App aufmerksam machen.

Schaltfläche „Antworten“ hinzufügen

So erstellen Sie eine Benachrichtigungsaktion, die Direktantworten unterstützt:

1. Instanz von erstellen RemoteInput.Builder die Sie Ihrer Benachrichtigungsaktion hinzufügen können. Der Konstruktor dieser Klasse akzeptiert Eine Zeichenfolge, die das System als Schlüssel für die Texteingabe verwendet. Meine App später verwendet diesen Schlüssel, um den Eingabetext 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);
     

   <ph type="x-smartling-placeholder">
3. Hängen Sie RemoteInput einer Aktion mithilfe von addRemoteInput().

   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 geben Sie die Benachrichtigung aus.

   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 zur Eingabe einer Antwort auf, wenn er die wie in Abbildung 4 dargestellt.

Nutzereingabe aus Antwort abrufen

Um Nutzereingaben über die Antwort-UI zu erhalten, rufen Sie RemoteInput.getResultsFromIntent(), Übergeben Sie die Intent, die Ihr BroadcastReceiver erhalten hat:

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

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

Nachdem Sie die SMS verarbeitet haben, aktualisieren Sie die Benachrichtigung, indem Sie NotificationManagerCompat.notify() mit derselben ID und demselben Tag, falls verwendet. Dies ist erforderlich, um die Direktantwort-Benutzeroberfläche auszublenden und dem Nutzer zu bestätigen, dass seine Antwort korrekt empfangen und verarbeitet wird.

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

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

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

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

Verwenden Sie beim Arbeiten mit dieser neuen Benachrichtigung den Kontext, der an die Empfänger onReceive() .

Hängen Sie die Antwort unten in der Benachrichtigung an, indem Sie setRemoteInputHistory() Wenn Sie jedoch eine Messaging-App erstellen, erstellen Sie eine Messaging-App Benachrichtigung und fügen Sie den neue Nachricht zur Konversation.

Weitere Tipps zu Benachrichtigungen von Messaging-Apps findest du im Abschnitt zu Best Practices für Messaging-Apps

Fortschrittsanzeige hinzufügen

Benachrichtigungen können eine animierte Fortschrittsanzeige enthalten, Status eines laufenden Vorgangs.

Abbildung 5: Die Fortschrittsanzeige während eine Operation.

Wenn Sie jederzeit schätzen können, wie viele Vorgänge abgeschlossen sind, verwenden Sie die Methode „determiniert“ wie in Abbildung 5 dargestellt, indem Sie die setProgress(max, progress, false) Der erste Parameter gibt an, Wert ist, wie 100. Das zweite ist wie viel abgeschlossen ist. Der letzte gibt an, dass dies ein definitiver Fortschritt ist. .

Rufen Sie während des Vorgangs kontinuierlich setProgress(max, progress, false) mit einem aktualisierten Wert für progress auf und senden Sie die Benachrichtigung noch einmal. wie im folgenden Beispiel dargestellt.

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

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

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

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

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

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

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

Am Ende des Vorgangs muss progress gleich max sein. Sie können das Feld um anzuzeigen, dass der Vorgang abgeschlossen ist, oder ihn zu entfernen. In beiden Fällen Benachrichtigungstext aktualisieren, um anzuzeigen, dass der Vorgang abgeschlossen ist. Entfernen die Fortschrittsanzeige, setProgress(0, 0, false) aufrufen.

Zum Anzeigen einer unbestimmten Fortschrittsanzeige (eine Leiste, die nicht auf den Abschluss hinweist) Prozentsatz) angezeigt wird, rufen Sie setProgress(0, 0, true) auf. Das Ergebnis ist ein Indikator, Den gleichen Stil wie die vorherige Fortschrittsanzeige, außer dass es sich um eine fortlaufende Animation, die nicht auf den Abschluss hinweist. Die Fortschrittsanimation läuft bis rufen Sie setProgress(0, 0, false) auf und aktualisieren Sie dann die Benachrichtigung, um die Aktivitätsanzeige.

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

Systemweite Kategorie festlegen

Android verwendet vordefinierte systemweite Kategorien, um zu bestimmen, ob du stören möchtest Der Nutzer erhält eine Benachrichtigung, wenn er Bitte nicht stören aktiviert hat. Modus an.

Wenn Ihre Benachrichtigung in eine der Benachrichtigungskategorien fällt, die in NotificationCompat, z. B. CATEGORY_ALARM, CATEGORY_REMINDER, CATEGORY_EVENT oder CATEGORY_CALL – Erklärung indem Sie die entsprechende Kategorie an setCategory():

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

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

Anhand dieser Informationen zu Ihrer Benachrichtigungskategorie Entscheidungen zum Anzeigen von Benachrichtigungen, wenn sich das Gerät im Modus „Bitte nicht“ befindet stören. Sie müssen jedoch keine systemweite Kategorie festlegen. Tun Sie dies nur wenn Ihre Benachrichtigungen mit einer der in den NotificationCompat

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 einem Full-Screen Intent mit Ihrer Benachrichtigung.

Wenn die Benachrichtigung aufgerufen wird, sehen Nutzer je nach Sperrstatus des Geräts:

• Ist das Gerät des Nutzers gesperrt, wird eine Aktivität im Vollbildmodus angezeigt, die das gesamte Sperrbildschirm.
• Wenn das Gerät des Nutzers entsperrt ist, wird die Benachrichtigung in einem maximierten das Optionen zum Bearbeiten oder Schließen der Benachrichtigung enthält.

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

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

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

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

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

Sichtbarkeit des Sperrbildschirms festlegen

So legen Sie fest, wie detailliert die Benachrichtigung auf dem Sperrbildschirm ist: Anruf setVisibility() und geben Sie einen der folgenden Werte an:

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

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

• VISIBILITY_PRIVATE: allgemeine Informationen wie das Benachrichtigungssymbol und den Inhalt wird auf dem Sperrbildschirm angezeigt. Der vollständige Inhalt der Benachrichtigung wird nicht anzeigen.

Wenn Sie VISIBILITY_PRIVATE festlegen, können Sie auch eine alternative Version von bereitstellen der Benachrichtigungsinhalt, durch den bestimmte Details verdeckt werden. Beispiel: eine SMS-App zeigt möglicherweise eine Benachrichtigung „Du hast drei neue SMS“ an, aber blendet den Nachrichteninhalt und die Absender aus. Um diese Alternative bereitzustellen, Erstellen Sie zunächst die alternative Benachrichtigung mit NotificationCompat.Builder wie gewohnt. Fügen Sie dann die alternative Benachrichtigung zur normalen Benachrichtigung mit setPublicVersion()

Denken Sie daran, dass die Nutzenden immer die ultimative Kontrolle darüber haben, ob ihre werden auf dem Sperrbildschirm angezeigt und können Benachrichtigungskanäle der App.

Benachrichtigung aktualisieren

Um eine Benachrichtigung nach dem Senden zu aktualisieren, rufen Sie NotificationManagerCompat.notify() und übergeben Sie die gleiche ID, die Sie verwendet haben. vorher. Wenn die vorherige Benachrichtigung geschlossen wird, wird eine neue erstellt .

Sie können optional setOnlyAlertOnce() sodass der Nutzer durch Töne, Vibrationen oder visuelle Elemente Hinweise: nur beim ersten Erscheinen der Benachrichtigung Aktualisierungen.

Benachrichtigung entfernen

Benachrichtigungen bleiben sichtbar, bis eines der folgenden Ereignisse eintritt:

• Der Nutzer schließt die Benachrichtigung.
• Der Nutzer tippt auf die Benachrichtigung, wenn du setAutoCancel() anrufst und erstellen Sie die Benachrichtigung.
• Sie rufen cancel() für eine bestimmte Benachrichtigungs-ID. Bei dieser Methode werden auch laufende Benachrichtigungen.
• Sie rufen cancelAll(), Dadurch werden alle zuvor gesendeten Benachrichtigungen entfernt.
• Die angegebene Dauer läuft ab, wenn Sie beim Erstellen des Benachrichtigung, mit setTimeoutAfter() Bei Bedarf können Sie eine Benachrichtigung vor dem angegebenen Zeitlimit abbrechen. Dauer des Projekts.

Best Practices für Messaging-Apps

Beachten Sie beim Erstellen von Benachrichtigungen für Ihr Messaging- und Chat-Apps.

MessagingStyle verwenden

Ab Android 7.0 (API-Level 24) bietet Android einen Benachrichtigungsstil für Messaging-Inhalte. Mit der NotificationCompat.MessagingStyle können Sie einige der in der Benachrichtigung angezeigten Labels ändern. einschließlich des Titels der Unterhaltung, zusätzlicher Nachrichten und der Inhaltsansicht für die Benachrichtigung.

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

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 außerdem die Verwendung des Person, um ein optimale Darstellung der Benachrichtigung und ihrer Avatare.

Wenn Sie NotificationCompat.MessagingStyle verwenden, gehen Sie so vor:

• Anruf MessagingStyle.setConversationTitle() , um einen Titel für Gruppenchats mit mehr als zwei Personen festzulegen. Eine gute Der Titel der Unterhaltung kann der Name des Gruppenchats sein oder, falls nicht, einen Namen, eine Liste der Gesprächsteilnehmer. Andernfalls kann es vorkommen, dass die Nachricht fälschlicherweise zu einer Einzelunterhaltung mit Der Absender der neuesten Nachricht in der Konversation
• Verwenden Sie die Methode MessagingStyle.setData() um Mediennachrichten wie Bilder einzubeziehen. MIME-Typen des Musters image/* unterstützt.

Direktantwort verwenden

Mit Direktantworten können Nutzer direkt auf eine Nachricht antworten.

• Nachdem ein Nutzer mit der Inline-Antwort geantwortet hat, verwenden Sie MessagingStyle.addMessage() um die MessagingStyle-Benachrichtigung zu aktualisieren, und brechen Sie den Vorgang nicht zurück Benachrichtigung. Wenn die Benachrichtigung nicht abgebrochen wird, kann der Nutzer mehrere auf die Benachrichtigung.
• Um die Inline-Antwort-Aktion mit Wear OS kompatibel zu machen, rufen Sie Action.WearableExtender.setHintDisplayInlineAction(true)
• Verwenden Sie die Methode addHistoricMessage() Methode, um Kontext zu einer Direct-Response-Unterhaltung bereitzustellen, indem Verlaufsdaten Benachrichtigungen zu ändern.

„Intelligente Antwort“ aktivieren

• Um die Funktion „Intelligente Antwort“ zu aktivieren, ruf setAllowGeneratedResponses(true) für die Antwortaktion. Dadurch sind Antworten der Funktion „Intelligente Antwort“ für alle wenn die Benachrichtigung mit einem Wear OS-Gerät verknüpft ist. Intelligente Antwort werden die Antworten von einem ML-Modell für maschinelles Lernen ausschließlich auf der Uhr generiert. den von NotificationCompat.MessagingStyle bereitgestellten Kontext und es werden keine Daten ins Internet hochgeladen, Antworten.

Benachrichtigungsmetadaten hinzufügen

• Weisen Sie Benachrichtigungsmetadaten zu, um dem System mitzuteilen, wie Ihre App behandelt werden soll Benachrichtigungen erhalten, wenn sich das Gerät im Do Not Disturb mode befindet. Beispiel: verwenden Sie die addPerson() oder setCategory(Notification.CATEGORY_MESSAGE) um den Modus „Bitte nicht stören“ außer Kraft zu setzen.