Tworzenie powiadomienia

Powiadomienia zawierają krótkie i aktualne informacje o zdarzeniach w aplikacji, podczas gdy nie jest używane. Z tego dokumentu dowiesz się, jak utworzyć powiadomienie w aplikacji różne funkcje. Więcej informacji o tym, jak wyglądają powiadomienia na Androidzie, znajdziesz w artykule Omówienie powiadomień. Przykładowy kod, który korzysta z powiadomień, znajdziesz w sekcji People (Osoby) fragment w GitHubie.

Kod na tej stronie korzysta z makra NotificationCompat Interfejsy API z biblioteki AndroidaX. Te interfejsy API umożliwiają dodawanie funkcji dostępnych tylko na nowszych wersjach Androida, przy jednoczesnej zgodności z Androidem. 9 (poziom interfejsu API 28). Niektóre funkcje, takie jak odpowiedź w tekście, skutkuje brakiem działania we wcześniejszych wersjach.

Dodawanie podstawowej biblioteki AndroidaX

Chociaż większość projektów tworzonych w Android Studio zawiera niezbędne do użycia funkcji NotificationCompat, sprawdź, czy na poziomie modułu Plik build.gradle zawiera tę zależność:

Odlotowe

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

Kotlin

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

Tworzenie powiadomienia podstawowego

Powiadomienie w najbardziej podstawowej i zwięzłej formie – nazywane też zwiniętym form – zawiera ikonę, tytuł i niewielką ilość tekstu. Ten pokazuje, jak utworzyć powiadomienie, które użytkownik może kliknąć, aby uruchomić aktywność w aplikacji.

Rysunek 1. Powiadomienie z: ikonę, tytuł i jakiś tekst.

Więcej informacji o poszczególnych częściach powiadomień znajdziesz w sekcji Powiadomienie anatomii.

Deklarowanie uprawnień w czasie działania

Android 13 (poziom interfejsu API 33) i nowsze wersje obsługują uprawnienia do publikowania w czasie działania aplikacji powiadomienia z aplikacji, które nie są zwolnione z obowiązku posiadania licencji (w tym powiadomień usług działających na pierwszym planie).

Pojawią się uprawnienia, które musisz zadeklarować w pliku manifestu aplikacji w tym fragmencie kodu:

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

Więcej informacji o uprawnieniach czasu działania znajdziesz w artykule Uprawnienia w czasie działania powiadomień.

Ustawianie treści powiadomienia

Aby rozpocząć, ustaw treść i kanał powiadomienia za pomocą NotificationCompat.Builder obiektu. Poniższy przykład pokazuje, jak utworzyć powiadomienie z użyciem parametru :

  • Mała ikona, ustawiona przez setSmallIcon() To jedyna wymagana treść widoczna dla użytkowników.

  • Tytuł określony przez setContentTitle()

  • Tekst główny ustawiony przez setContentText()

  • Priorytet powiadomień określony przez setPriority() Priorytet określa, jak inwazyjne jest powiadomienie w systemie Android 7.1 i starszych. W przypadku Androida 8.0 i nowszych ustaw ważność kanału na omówiono w następnej sekcji.

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

Konstruktor NotificationCompat.Builder wymaga podania kanału ID. Jest to wymagane na potrzeby zgodności z Androidem 8.0 (poziom interfejsu API 26) oraz później, ale jest ignorowana przez wcześniejsze wersje.

Domyślnie tekst powiadomienia jest skracany do 1 wiersza. Ty mogą pokazywać dodatkowe informacje, tworząc powiadomienie rozwijane.

Rysunek 2. Rozwijana w zwiniętym i rozwiniętym formacie.

Jeśli chcesz, aby Twoje powiadomienie było dłuższe, możesz włączyć rozwijaną reklamę wideo powiadomienia, dodając szablon stylu z setStyle() Na przykład ten kod tworzy większą powierzchnię tekstową:

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

Więcej informacji o innych stylach powiadomień o dużym rozmiarze, w tym o sposobie ich dodawania elementów sterujących odtwarzaniem obrazów i multimediów znajdziesz w artykule Tworzenie reklam rozwijanych .

Tworzenie kanału i określanie ważności

Aby móc dostarczyć powiadomienie na Androida 8.0 lub nowszego, zarejestruj kanał powiadomień aplikacji przez przekazanie instancji NotificationChannel na createNotificationChannel() Ten kod jest blokowany przez warunek na Wersja SDK_INT:

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

Ponieważ musisz utworzyć kanał powiadomień przed opublikowaniem jakiejkolwiek na urządzeniach z Androidem 8.0 i nowszymi wersjami, wykonaj ten kod, gdy tylko aplikacja zaczyna się. Możesz robić to wielokrotnie, bo utworzenie kanał powiadomień nie wykonuje żadnej operacji.

Konstruktor NotificationChannel wymaga parametru importance, który jest jedną z konstant z klasy NotificationManager. Ten decyduje o tym, jak przerywać działanie użytkownika w przypadku dowolnego powiadomienia, które do niego należy. do tego kanału. Ustaw priorytet za pomocą ustawienia setPriority(), aby zapewnić obsługę Androida 7.1 jak w poprzednim przykładzie.

Mimo że musisz ustawić ważność lub priorytet powiadomienia zgodnie z z poniższego przykładu, system nie gwarantuje wybranego działania alertu. W w niektórych przypadkach system może zmienić poziom ważności na podstawie innych czynników, a użytkownik może zawsze na nowo zdefiniować poziom ważności danego kanał.

Więcej informacji o znaczeniu poszczególnych poziomów znajdziesz w sekcji znaczenie powiadomień .

Ustawianie działania kliknięcia powiadomienia

Każde powiadomienie musi reagować na kliknięcie, zwykle otwierając w aplikacji odpowiednią aktywność. Aby to zrobić, określ intencję dotyczącą treści zdefiniowane za pomocą parametru PendingIntent i przekazać go do setContentIntent()

Ten fragment kodu pokazuje, jak utworzyć podstawową intencję otwierającą aktywność gdy użytkownik kliknie powiadomienie:

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

Ten kod wywołuje funkcję setAutoCancel(), która automatycznie usuwa powiadomienie, gdy użytkownik kliknie je.

Metoda setFlags() pokazane w poprzednim przykładzie zachowuje oczekiwaną przez użytkownika nawigację po tym, jak uruchomią Twoją aplikację, korzystając z powiadomienia. Możesz go użyć w zależności od typu aktywności, którą chcesz rozpocząć. Może to być jedna z tych czynności:

  • Działanie, które istnieje wyłącznie w odniesieniu do odpowiedzi na powiadomienie. Nie ma powodu, dla którego użytkownik przechodzi do tego działania podczas normalnego korzystania z aplikacji. więc aktywność rozpocznie nowe zadanie, a nie zostanie istniejące zadanie i powrót . To jest typu intencji utworzonej w poprzednim przykładzie.

  • Aktywność występująca w zwykłym przepływie aplikacji. W tym przypadku rozpoczęcie działania tworzy tylny stos, aby użytkownik oczekiwał, dla przycisków Kopia zapasowa i W górę są i ochrony danych.

Więcej informacji o różnych sposobach konfigurowania intencji powiadomienia znajdziesz w artykule Rozpoczynanie aktywności z powiadomienia.

Wyświetlanie powiadomienia

Aby wyświetlić powiadomienie, zadzwoń pod numer NotificationManagerCompat.notify() i przekazuje mu unikalny identyfikator powiadomienia oraz wynik NotificationCompat.Builder.build() Widać to w tym przykładzie:

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

Zapisz identyfikator powiadomienia przekazywany aplikacji NotificationManagerCompat.notify(). ponieważ jest potrzebna podczas aktualizacji lub usunięcia powiadomienia.

Dodatkowo w celu przetestowania podstawowych powiadomień na urządzeniach z Androida 13 lub nowszego; włącz powiadomienia ręcznie lub utwórz okno, aby powiadomienia o żądaniach.

Dodaj przyciski poleceń

Powiadomienie może zawierać maksymalnie 3 przyciski polecenia, dzięki którym użytkownik może odpowiedzieć , na przykład odłożyć przypomnienie lub odpowiedzieć na SMS-a. Ale te Przyciski poleceń nie mogą powielać czynności wykonywanej po kliknięciu przez użytkownika przycisku .

Rysunek 3. Powiadomienie z wyłączonym przyciskiem działania

Aby dodać przycisk polecenia, przekaż PendingIntent do addAction(). . Przypomina to konfigurowanie domyślnego kliknięcia powiadomienia, z tą różnicą Zamiast wykonywać działanie, możesz wykonać inne czynności, na przykład rozpocząć BroadcastReceiver wykonuje zadanie w tle, aby nie przerywało aplikacji; który jest już otwarty.

Na przykład ten kod pokazuje, jak wysłać transmisję do konkretnego odbiorcy:

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

Więcej informacji o tworzeniu BroadcastReceiver do działania w tle pracy: zobacz Omówienie transmisji.

Jeśli zamiast tego próbujesz utworzyć powiadomienie za pomocą przycisków odtwarzania multimediów, np. do wstrzymywania i pomijania utworów, zobacz, jak utworzyć powiadomienie z multimediami .

Dodawanie bezpośredniej odpowiedzi

Akcja bezpośredniej odpowiedzi, wprowadzona w Androidzie 7.0 (interfejs API na poziomie 24), umożliwia użytkownikom wpisywanie tekstu bezpośrednio w powiadomieniu. Tekst jest następnie wysyłany do aplikacji bez otwierania aktywności. Możesz na przykład użyć bezpośredniej odpowiedzi aby umożliwić użytkownikom odpowiadanie na SMS-y lub aktualizowanie list zadań z poziomu powiadomienia.

Rysunek 4. Kliknij „Odpowiedz”. otwiera pole tekstowe.

Bezpośrednia odpowiedź pojawia się w powiadomieniu jako dodatkowy przycisk, który otwiera pole tekstowe. Gdy użytkownik skończy pisać, system dołączy tekst. na określoną przez Ciebie intencję dla działania związanego z powiadomieniem i wysyła do Twojej aplikacji.

Dodawanie przycisku odpowiedzi

Aby utworzyć działanie powiadomienia, które obsługuje odpowiedź bezpośrednią, wykonaj te czynności:

  1. Utwórz instancję RemoteInput.Builder który możesz dodać do działania powiadomień. Konstruktor tej klasy akceptuje ciąg znaków, którego system używa jako klucza do danych wejściowych tekstowych. Aplikacja później używa go do pobierania tekstu z danych wejściowych.

    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. Utwórz PendingIntent dla działania dotyczącego odpowiedzi.

    Kotlin

      // Build a PendingIntent for the reply action to trigger.
  var replyPendingIntent: PendingIntent =
      PendingIntent.getBroadcast(applicationContext,
          conversation.getConversationId(),
          getMessageReplyIntent(conversation.getConversationId()),
          PendingIntent.FLAG_UPDATE_CURRENT)

    Java

      // Build a PendingIntent for the reply action to trigger.
  PendingIntent replyPendingIntent =
          PendingIntent.getBroadcast(getApplicationContext(),
                  conversation.getConversationId(),
                  getMessageReplyIntent(conversation.getConversationId()),
                  PendingIntent.FLAG_UPDATE_CURRENT);
  3. Załącz RemoteInput do działania za pomocą 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. Zastosuj działanie do powiadomienia i wyślij powiadomienie.

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

System prosi użytkownika o wpisanie odpowiedzi, gdy aktywuje on zgodnie z rys. 4.

Pobierz dane wejściowe użytkownika z odpowiedzi

Aby otrzymać dane wejściowe użytkownika z interfejsu odpowiedzi powiadomienia, wywołaj RemoteInput.getResultsFromIntent() przekazując ją Intent otrzymaną przez BroadcastReceiver:

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

Po przetworzeniu SMS-a zaktualizuj powiadomienie, dzwoniąc NotificationManagerCompat.notify() z tym samym identyfikatorem i tagiem, jeśli jest używany. To jest konieczne jest ukrycie interfejsu bezpośredniej odpowiedzi i potwierdzenie użytkownikowi, zostanie prawidłowo odebrany i przetworzony.

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

Pracując z nowym powiadomieniem, korzystaj z kontekstu przekazanego do odbiorcy onReceive() .

Dołącz odpowiedź na dole powiadomienia, dzwoniąc setRemoteInputHistory() Jeśli jednak tworzysz aplikację do obsługi wiadomości, stwórz styl wiadomości powiadomienie i dołącz kod nową wiadomość w rozmowie.

Więcej wskazówek dotyczących powiadomień z aplikacji do obsługi wiadomości znajdziesz w sekcji o sprawdzonych metodach dotyczących aplikacji do obsługi wiadomości.

Dodaj pasek postępu

Powiadomienia mogą zawierać animowany wskaźnik postępu, lub trwającej operacji.

Rysunek 5. Pasek postępu w trakcie operacji.

Jeśli w dowolnym momencie możesz oszacować, jak dużo operacji zostało już wykonanych, użyj formy „determinate” wskaźnika (jak na rysunku 5) przez wywołanie funkcji setProgress(max, progress, false). Pierwszym z nich jest parametr „complete”, wynosi np. 100. Drugim jest to, ile zostało do zrobienia. Ostatnia wskazuje, że jest to postęp w budowaniu przeglądarki.

W miarę postępu operacji stale wywołuj funkcję setProgress(max, progress, false) z aktualną wartością parametru progress i wydawaj ponownie powiadomienie, jak pokazano w tym przykładzie.

Kotlin

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

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

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

Java

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

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

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

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

Na końcu operacji progress musi być równa max. Możesz zostawić pasek postępu, aby pokazać, że operacja została zakończona, lub usunąć go. W obu przypadkach zaktualizuj tekst powiadomienia, aby pokazać, że operacja została zakończona. Aby usunąć pasek postępu wywołaj setProgress(0, 0, false).

wyświetlanie nieokreślonego paska postępu (słupka nieoznaczącego ukończenia), procent), wywołaj setProgress(0, 0, true). Wynik to wskaźnik, który zawiera ma taki sam styl jak poprzedni pasek postępu, ale jest to ciągły które nie wskazują zakończenia. Animacja postępu trwa, dopóki nie wywołasz setProgress(0, 0, false), a następnie zaktualizujesz powiadomienie, aby usunąć wskaźnik aktywności.

Pamiętaj, aby zmienić tekst powiadomienia, aby wskazać, że operacja jest gotowe.

Ustawianie kategorii systemowej

Android używa zdefiniowanych wstępnie kategorii systemowych w celu określenia, czy nie przeszkadzać użytkownik, który ma otrzymać powiadomienie, gdy włączy tryb Nie przeszkadzać .

Jeśli powiadomienie należy do jednej z kategorii powiadomień zdefiniowanych w NotificationCompat, takich jak CATEGORY_ALARM, CATEGORY_REMINDER, CATEGORY_EVENT lub CATEGORY_CALL, oznacz je jako takie, przekazując odpowiednią kategorię do setCategory():

Kotlin

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

Java

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

System używa tych informacji o kategorii powiadomienia, aby podejmować decyzje dotyczące wyświetlania powiadomienia, gdy urządzenie jest w trybie Nie przeszkadzać. Nie musisz jednak tego robić. Tylko tak jeśli powiadomienia pasują do jednej z kategorii zdefiniowanych w NotificationCompat

Wyświetlanie pilnego komunikatu

W Twojej aplikacji może być konieczne wyświetlenie pilnej, pilnej wiadomości, takiej jak przychodzące połączenie telefoniczne lub alarm. W takiej sytuacji możesz powiązać intencji pełnoekranowej z powiadomieniem.

Po wywołaniu powiadomienia użytkownik zobaczy jedną z tych opcji w zależności od stan blokady urządzenia:

  • Jeśli urządzenie użytkownika jest zablokowane, pojawia się aktywność na pełnym ekranie obejmująca ekranu blokady.
  • Jeśli urządzenie użytkownika jest odblokowane, powiadomienie pojawia się w rozwiniętym który zawiera opcje dotyczące zajęcia się lub odrzucenia powiadomienia.

Ten fragment kodu pokazuje, jak powiązać powiadomienie z: intencję pełnoekranową:

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

Ustawianie widoczności blokady ekranu

Aby dostosować poziom szczegółów powiadomienia na ekranie blokady: zadzwoń setVisibility() i określ jedną z tych wartości:

  • VISIBILITY_PUBLIC: Pełna treść powiadomienia jest widoczna na ekranie blokady.

  • VISIBILITY_SECRET: żadna część powiadomienia nie jest widoczna na ekranie blokady.

  • VISIBILITY_PRIVATE: tylko podstawowe informacje, takie jak ikona i treść powiadomienia tytuł, który wyświetla się na ekranie blokady. Nie wyświetla się pełna treść powiadomienia.

Po ustawieniu VISIBILITY_PRIVATE możesz też podać alternatywną wersję komponentu treść powiadomienia ukrywającą określone szczegóły. Na przykład aplikacja do SMS-ów może wyświetlić się powiadomienie „Masz 3 nowe SMS-y”, ale ukrywa treść i nadawców wiadomości. Aby udostępnić tę opcję alternatywną, powiadomienia, najpierw utwórz alternatywne powiadomienie z NotificationCompat.Builder. Następnie dołącz powiadomienie alternatywne do zwykłego powiadomienia, setPublicVersion()

Pamiętaj, że użytkownik zawsze ma pełną kontrolę nad tym, czy są widoczne na ekranie blokady i mogą je kontrolować w oparciu o kanały powiadomień aplikacji.

Aktualizowanie powiadomienia

Aby zaktualizować powiadomienie po jego wysłaniu, zadzwoń pod numer NotificationManagerCompat.notify() ponownie, przekazując ten sam identyfikator, który został użyty przez Ciebie wcześniej. Jeśli poprzednie powiadomienie zostanie odrzucone, zostanie utworzone nowe .

Opcjonalnie możesz wywołać funkcję setOnlyAlertOnce() aby powiadomienie przeszkadzało użytkownikowi – dźwiękiem, wibracjami podpowiedzi – tylko przy pierwszym wyświetleniu powiadomienia, a nie przy pierwszym wyświetleniu. aktualizacje.

Usuwanie powiadomienia

Powiadomienia pozostają widoczne, dopóki nie wystąpi jedna z tych sytuacji:

  • Użytkownik odrzuci powiadomienie.
  • Użytkownik kliknie powiadomienie, jeśli zadzwonisz do: setAutoCancel(), gdy: podczas tworzenia powiadomienia.
  • Ty dzwonisz cancel() dla konkretnego identyfikatora powiadomienia. Ta metoda usuwa też trwające powiadomienia.
  • Wywołaj funkcję cancelAll(), która usuwa wszystkie wcześniej wysłane powiadomienia.
  • W określonym czasie upłynie czas, jeśli podczas tworzenia powiadomienia, przy użyciu setTimeoutAfter() W razie potrzeby możesz anulować powiadomienie przed upływem określonego czasu. gdy minie czas ich trwania.

Sprawdzone metody dotyczące aplikacji do obsługi wiadomości

Tworząc powiadomienia na temat swojej witryny, weź pod uwagę wymienione tutaj sprawdzone metody. do obsługi wiadomości i czatu.

Używaj MessagingStyle

Począwszy od wersji Androida 7.0 (poziom interfejsu API 24) Android udostępnia styl powiadomień przeznaczony specjalnie do treści wiadomości. Za pomocą klasy NotificationCompat.MessagingStyle możesz zmienić kilka etykiet wyświetlanych w powiadomieniu, w tym tytuł rozmowy, dodatkowe wiadomości i widok treści powiadomienia.

Ten fragment kodu pokazuje, jak dostosować styl powiadomienia za pomocą klasy MessagingStyle.

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

Począwszy od Androida 9.0 (interfejs API 28) konieczne jest też użycie klasy Person, aby zapewnić optymalne renderowanie powiadomienia i jego awatara.

Podczas korzystania z NotificationCompat.MessagingStyle:

  • Wybierz opcję Zadzwoń MessagingStyle.setConversationTitle(), aby ustawić tytuł czatu grupowego z więcej niż 2 osobami. Dobrym tytułem rozmowy może być nazwa czatu grupowego lub, jeśli nie ma nazwy, lista uczestników rozmowy. Bez tego wiadomość może zostać pomylona jako należąca do rozmowy jeden do jednego z nadawca najnowszej wiadomości w wątku.
  • Użyj MessagingStyle.setData() , by dołączyć komunikaty multimedialne, takie jak obrazy. Typy MIME wzorca obraz/* jest obsługiwany.

Używaj odpowiedzi bezpośredniej

Odpowiedź bezpośrednia umożliwia użytkownikowi odpowiadanie w tekście wiadomości.

  • Jeśli użytkownik odpowie w treści wiadomości z wykorzystaniem funkcji odpowiedzi w tekście, MessagingStyle.addMessage() aby zaktualizować powiadomienie MessagingStyle, a nie wycofywać ani anulować powiadomienia. Jeśli nie anulujesz powiadomienia, użytkownik będzie mógł wysłać kilka odpowiedzi z powiadomienia.
  • Aby odpowiedź w tekście była zgodna z Wear OS, wywołaj Action.WearableExtender.setHintDisplayInlineAction(true)
  • Aby dodać kontekst do konwersacji z bezpośrednimi odpowiedziami, dodaj do powiadomienia wcześniejsze wiadomości, korzystając z metody addHistoricMessage().

Włącz Inteligentną odpowiedź

  • Aby włączyć Inteligentną odpowiedź, zadzwoń pod numer setAllowGeneratedResponses(true) dla działania związanego z odpowiedzią. Dzięki temu odpowiedzi Inteligentnej odpowiedzi będą dostępne dla: dla użytkowników, gdy powiadomienie jest połączone z urządzeniem z Wear OS. Inteligentna odpowiedź odpowiedzi są generowane przez model uczenia maszynowego używany wyłącznie na zegarku kontekst dostarczony przez NotificationCompat.MessagingStyle powiadomienia i żadne dane nie są przesyłane do internetu w celu wygenerowania odpowiedzi.

Dodaj metadane powiadomień