Tworzenie powiadomienia

Powiadomienia zawierają krótkie, aktualne informacje o zdarzeniach w aplikacji, gdy nie jest ona używana. Z tego dokumentu dowiesz się, jak utworzyć powiadomienie z różnymi funkcjami. Informacje o tym, jak powiadomienia wyświetlają się na Androidzie, znajdziesz w omówieniu powiadomień. Przykładowy kod, który używa powiadomień, znajdziesz w przykładzie SociaLite na GitHubie.

Kod na tej stronie używa interfejsów API NotificationCompat z biblioteki AndroidX. Te interfejsy API umożliwiają dodawanie funkcji dostępnych tylko w nowszych wersjach Androida, zachowując zgodność wsteczną z Androidem 9 (poziom interfejsu API 28). Jednak niektóre funkcje, takie jak działanie odpowiedzi w tekście, nie działają we wcześniejszych wersjach.

Tworzenie podstawowego powiadomienia

Powiadomienie w najbardziej podstawowej i kompaktowej formie, czyli zwiniętej, zawiera ikonę, tytuł i niewielką ilość tekstu. W tej sekcji dowiesz się, jak utworzyć powiadomienie, które użytkownik może kliknąć, aby uruchomić aktywność w aplikacji.

Rysunek 1. Powiadomienie z ikoną, tytułem i tekstem.

Więcej informacji o poszczególnych częściach powiadomienia znajdziesz w artykule o anatomii powiadomienia.

Zadeklaruj uprawnienia w czasie działania aplikacji

Android 13 (poziom API 33) i nowsze obsługują uprawnienia w czasie działania aplikacji do publikowania powiadomień, które nie są objęte zwolnieniem (w tym usług działających na pierwszym planie).

Uprawnienie, które musisz zadeklarować w pliku manifestu aplikacji, pojawia się w tym fragmencie kodu:

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

Więcej informacji o uprawnieniach w czasie działania aplikacji znajdziesz w artykule Uprawnienia do wyświetlania powiadomień w czasie działania aplikacji.

Ustawianie treści powiadomień

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

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

  • Tytuł ustawiony przez setContentTitle().

  • Tekst główny, ustawiany za pomocą parametru setContentText().

  • Priorytet powiadomienia ustawiony przez setPriority(). Priorytet określa, jak natrętne jest powiadomienie na urządzeniach z Androidem 7.1 i starszym. W przypadku Androida 8.0 i nowszych wersji ustaw ważność kanału zgodnie z instrukcjami w następnej sekcji.

val textTitle = "Title"
val textContent = "Content"
val builder = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .setContentTitle(textTitle)
    .setContentText(textContent)
    .setPriority(NotificationCompat.PRIORITY_DEFAULT)

Konstruktor NotificationCompat.Builder wymaga podania identyfikatora kanału. Jest to wymagane do zapewnienia zgodności z Androidem 8.0 (poziom interfejsu API 26) i nowszymi wersjami, ale jest ignorowane przez starsze wersje.

Domyślnie treść powiadomienia jest skracana, aby zmieściła się w jednym wierszu. Możesz wyświetlić dodatkowe informacje, tworząc powiadomienie rozwijane.

Rysunek 2. Rozwijane powiadomienie w formie zwiniętej i rozwiniętej.

Jeśli chcesz, aby powiadomienie było dłuższe, możesz włączyć powiadomienie rozwijane, dodając szablon stylu za pomocą metody setStyle(). Na przykład ten kod tworzy większy obszar tekstowy:

val builder = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .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)

Więcej informacji o innych stylach dużych powiadomień, w tym o dodawaniu obrazu i elementów sterujących odtwarzaniem multimediów, znajdziesz w artykule Tworzenie powiadomienia rozwijanego.

Tworzenie kanału i ustawianie ważności

Zanim będzie można dostarczyć powiadomienie na Androidzie 8.0 lub nowszym, musisz zarejestrować kanał powiadomień aplikacji w systemie, przekazując instancję NotificationChannel do createNotificationChannel(). Następujący kod jest blokowany przez warunek w wersji SDK_INT:

fun createNotificationChannel(context: Context) {
    // 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 = context.getString(R.string.channel_name)
        val descriptionText = context.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 =
            context.getSystemService(NotificationManager::class.java) as NotificationManager
        notificationManager.createNotificationChannel(channel)
    }
}

Kanał powiadomień musisz utworzyć przed opublikowaniem powiadomień w Androidzie 8.0 lub nowszych wersjach, dlatego ten kod należy wykonać po uruchomieniu aplikacji. Możesz wywoływać tę funkcję wielokrotnie, ponieważ utworzenie istniejącego kanału nie powoduje żadnej operacji.

Konstruktor NotificationChannel wymaga poziomu ważności, który jest określany za pomocą stałej NotificationManager. Określa, jak przerwać użytkownikowi. Aby zapewnić obsługę Androida 7.1 i starszych wersji, ustaw też priorytet za pomocą setPriority(), jak pokazano w poprzednim przykładzie.

Chociaż musisz ustawić ważność lub priorytet, system nie gwarantuje działania alertu. System może dostosować go na podstawie innych czynników, a użytkownik może w każdej chwili dostosować poziom ważności kanału.

Więcej informacji o tym, co oznaczają poszczególne poziomy, znajdziesz w artykule o poziomach ważności powiadomień.

Ustawianie działania po kliknięciu powiadomienia

Każde powiadomienie musi reagować na kliknięcie, zwykle otwierając aktywność w aplikacji, która odpowiada powiadomieniu. W tym celu określ intencję treści zdefiniowaną za pomocą obiektu PendingIntent i przekaż ją do setContentIntent().

Poniższy fragment kodu pokazuje, jak utworzyć podstawową intencję, aby otworzyć aktywność, gdy użytkownik kliknie powiadomienie:

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

val builder = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .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 metodę setAutoCancel(), która automatycznie usuwa powiadomienie, gdy użytkownik je kliknie.

Flagi intencji w poprzednim przykładzie zachowują oczekiwane przez użytkownika działanie nawigacji po otwarciu aplikacji za pomocą powiadomienia. Możesz go użyć w zależności od typu aktywności, którą rozpoczynasz. Może to być:

  • Działanie, które istnieje wyłącznie w celu odpowiedzi na powiadomienie. Podczas normalnego korzystania z aplikacji użytkownik nie ma powodu, aby przechodzić do tego działania, więc rozpoczyna ono nowe zadanie, zamiast być dodawane do istniejącego zadania i stosu wstecznego aplikacji. Jest to typ intencji utworzony w poprzednim przykładzie.

  • Aktywność, która występuje w standardowym przepływie aplikacji. W takim przypadku uruchomienie aktywności powoduje utworzenie stosu wstecznego, dzięki czemu oczekiwania użytkownika dotyczące przycisków Wstecz i W górę zostają spełnione.

Wyświetlanie powiadomienia

Aby powiadomienie się pojawiło, wywołaj NotificationManagerCompat.notify(), przekazując unikalny identyfikator powiadomienia i wynik NotificationCompat.Builder.build(). Zostało to przedstawione w poniższym przykładzie:

with(NotificationManagerCompat.from(context)) {
    if (ActivityCompat.checkSelfPermission(
            context,
            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(notificationId, builder.build())

Zapisz identyfikator powiadomienia, który przekazujesz do NotificationManagerCompat.notify(), ponieważ będzie on potrzebny, gdy będziesz chcieć zaktualizować lub usunąć powiadomienie.

Aby przetestować podstawowe powiadomienia na urządzeniach z Androidem 13 lub nowszym, włącz powiadomienia ręcznie lub utwórz okno z prośbą o powiadomienia.

Dodawanie przycisków poleceń

Powiadomienie może zawierać maksymalnie 3 przyciski poleceń, które umożliwiają użytkownikowi szybką reakcję, np. odłożenie przypomnienia lub odpowiedź na SMS-a. Te przyciski poleceń nie mogą jednak powielać działania wykonywanego, gdy użytkownik kliknie powiadomienie.

Rysunek 3. Powiadomienie z jednym przyciskiem polecenia.

Aby dodać przycisk polecenia, przekaż PendingIntent do metody addAction(). Jest to podobne do konfigurowania domyślnego działania powiadomienia po kliknięciu, ale zamiast uruchamiać aktywność, możesz wykonywać inne czynności, takie jak uruchamianie BroadcastReceiver, który wykonuje zadanie w tle, dzięki czemu działanie nie przerywa działania już otwartej aplikacji.

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

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

Więcej informacji o tworzeniu komponentu BroadcastReceiver do wykonywania zadań w tle znajdziesz w omówieniu transmisji.

Jeśli chcesz utworzyć powiadomienie z przyciskami odtwarzania multimediów, np. do wstrzymywania i pomijania utworów, dowiedz się, jak utworzyć powiadomienie z opcjami sterowania multimediami.

Dodawanie działania bezpośredniej odpowiedzi

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

Rysunek 4. Kliknięcie przycisku „Odpowiedz” otwiera pole wprowadzania tekstu.

Działanie bezpośredniej odpowiedzi pojawia się jako dodatkowy przycisk w powiadomieniu, który otwiera pole do wprowadzania tekstu. Gdy użytkownik skończy pisać, system dołącza odpowiedź tekstową do intencji określonej dla działania powiadomienia i wysyła intencję do aplikacji.

Dodaj przycisk odpowiedzi

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

Utwórz instancję RemoteInput.Builder, którą możesz dodać do działania powiadomienia. Konstruktor tej klasy akceptuje ciąg znaków, który system wykorzystuje jako klucz do wprowadzania tekstu. Aplikacja używa później tego klucza do pobrania tekstu wejściowego.

// Key for the string that's delivered in the action's intent.
val replyLabel: String = context.resources.getString(R.string.reply_label)
val remoteInput: RemoteInput = RemoteInput.Builder(KEY_TEXT_REPLY).run {
    setLabel(replyLabel)
    build()
}

Utwórz PendingIntent dla działania związanego z odpowiedzią.

// Build a PendingIntent for the reply action to trigger.
val replyPendingIntent: PendingIntent =
    PendingIntent.getBroadcast(context,
        conversationId,
        getMessageReplyIntent(conversationId),
        PendingIntent.FLAG_MUTABLE)

Dołącz obiekt RemoteInput do działania za pomocą addRemoteInput().

// Create the reply action and add the remote input.
val action: NotificationCompat.Action =
    NotificationCompat.Action.Builder(R.drawable.reply,
        context.getString(R.string.reply_label), replyPendingIntent)
        .addRemoteInput(remoteInput)
        .build()

Zastosuj działanie do powiadomienia i wyślij powiadomienie.

// Build the notification and add the action.
val newMessageNotification = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_message)
    .setContentTitle(context.getString(R.string.title))
    .setContentText(context.getString(R.string.content))
    .addAction(action)
    .build()

// Issue the notification.
NotificationManagerCompat.from(context).notify(notificationId, newMessageNotification)

System prosi użytkownika o wpisanie odpowiedzi, gdy wywoła on działanie powiadomienia, jak pokazano na rysunku 4.

Pobieranie danych wpisanych przez użytkownika z odpowiedzi

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

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

Po przetworzeniu tekstu zaktualizuj powiadomienie, wywołując metodę NotificationManagerCompat.notify() z tym samym identyfikatorem i tagiem (jeśli jest używany). Jest to konieczne, aby ukryć interfejs bezpośredniej odpowiedzi i potwierdzić użytkownikowi, że jego odpowiedź została odebrana i prawidłowo przetworzona.

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

// Issue the new notification.
NotificationManagerCompat.from(context).notify(notificationId, repliedNotification)

Pobieranie innych danych

Obsługa innych typów danych działa podobnie w przypadku RemoteInput. W tym przykładzie jako dane wejściowe używany jest obraz.

val replyLabel: String = context.resources.getString(R.string.reply_label)
val 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()
}

Wywołaj RemoteInput#getDataResultsFromIntent i wyodrębnij odpowiednie dane.

class ReplyReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        val dataResults = RemoteInput.getDataResultsFromIntent(intent, KEY_REPLY)
        val imageUri: Uri? = dataResults?.get("image/*") as? Uri

        if (imageUri != null) {
            // Extract the image
            context.contentResolver.openInputStream(imageUri)?.use { inputStream ->
                val bitmap = BitmapFactory.decodeStream(inputStream)
                // Display the image
                // ...
            }
        }
    }

    companion object {
        const val KEY_REPLY = "key_reply"
        const val KEY_TEXT_REPLY = "key_text_reply"
    }
}

Podczas pracy z tym nowym powiadomieniem używaj kontekstu przekazywanego do metody onReceive() odbiorcy.

Dołącz odpowiedź na dole powiadomienia, wywołując metodę setRemoteInputHistory(). Jeśli jednak tworzysz aplikację do obsługi wiadomości, utwórz powiadomienie w stylu wiadomości i dołącz nową wiadomość do rozmowy.

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.

Wyświetlanie pilnej wiadomości

Aplikacja może wymagać wyświetlenia pilnej, ważnej wiadomości, takiej jak połączenie przychodzące lub dzwoniący alarm. W takich sytuacjach możesz powiązać z powiadomieniem intencję pełnoekranową.

Gdy powiadomienie zostanie wywołane, użytkownicy zobaczą jeden z tych komunikatów, w zależności od stanu blokady urządzenia:

  • Jeśli urządzenie użytkownika jest zablokowane, pojawi się aktywność na pełnym ekranie, która zasłoni ekran blokady.
  • Jeśli urządzenie użytkownika jest odblokowane, powiadomienie pojawia się w rozwiniętej formie, która zawiera opcje obsługi lub odrzucenia powiadomienia.

Poniższy fragment kodu pokazuje, jak powiązać powiadomienie z intencją pełnoekranową:

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

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

Ustawianie widoczności ekranu blokady

Aby określić poziom szczegółowości powiadomienia na ekranie blokady, wywołaj metodę setVisibility() i podaj jedną z tych wartości:

  • VISIBILITY_PUBLIC: na ekranie blokady wyświetla się pełna treść powiadomienia.

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

  • VISIBILITY_PRIVATE: na ekranie blokady wyświetlane są tylko podstawowe informacje, takie jak ikona powiadomienia i tytuł treści. Pełna treść powiadomienia nie jest widoczna.

Gdy ustawisz VISIBILITY_PRIVATE, możesz też podać alternatywną wersję treści powiadomienia, która ukrywa niektóre szczegóły. Na przykład aplikacja do SMS-ów może wyświetlić powiadomienie „Masz 3 nowe SMS-y”, ale ukryć treść wiadomości i nadawców. Aby udostępnić to powiadomienie alternatywne, najpierw utwórz je w NotificationCompat.Builder w zwykły sposób. Następnie dołącz powiadomienie alternatywne do powiadomienia normalnego za pomocą setPublicVersion().

Pamiętaj, że użytkownik zawsze ma ostateczną kontrolę nad tym, czy powiadomienia są widoczne na ekranie blokady, i może nimi zarządzać na podstawie kanałów powiadomień aplikacji.

Aktualizowanie powiadomienia

Aby zaktualizować powiadomienie po jego wysłaniu, ponownie wywołaj metodę NotificationManagerCompat.notify(), przekazując jej ten sam identyfikator, którego użyto wcześniej. Jeśli poprzednie powiadomienie zostanie odrzucone, zostanie utworzone nowe powiadomienie.

Możesz opcjonalnie wywołać metodę setOnlyAlertOnce(), aby powiadomienie przeszkodziło użytkownikowi (za pomocą dźwięku, wibracji lub wskazówek wizualnych) tylko wtedy, gdy pojawi się po raz pierwszy, a nie przy kolejnych aktualizacjach.

Usuwanie powiadomienia

Powiadomienia pozostają widoczne, dopóki nie nastąpi jedno z tych zdarzeń:

  • Użytkownik odrzuca powiadomienie.
  • Użytkownik klika powiadomienie, jeśli wywołasz funkcję setAutoCancel() podczas tworzenia powiadomienia.
  • Wywołujesz cancel() dla konkretnego identyfikatora powiadomienia. Ta metoda usuwa też powiadomienia o trwającej aktywności.
  • Wywołujesz metodę cancelAll(), która usuwa wszystkie wcześniej wysłane powiadomienia.
  • Upłynie określony czas, jeśli podczas tworzenia powiadomienia ustawisz limit czasu za pomocą setTimeoutAfter(). W razie potrzeby możesz anulować powiadomienie przed upływem określonego czasu oczekiwania.

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

Podczas tworzenia powiadomień dla aplikacji do obsługi wiadomości i komunikatorów weź pod uwagę sprawdzone metody wymienione tutaj.

Używanie MessagingStyle

Od Androida 7.0 (interfejs API na poziomie 24) Android udostępnia szablon stylu powiadomień przeznaczony specjalnie do 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.

Poniższy fragment kodu pokazuje, jak dostosować styl powiadomienia za pomocą klasy MessagingStyle.

val message1 = NotificationCompat.MessagingStyle.Message(
    messages[0].text,
    messages[0].time,
    messages[0].sender
)
val message2 = NotificationCompat.MessagingStyle.Message(
    messages[1].text,
    messages[1].time,
    messages[1].sender
)
notification = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_logo)
    .setStyle(
        NotificationCompat.MessagingStyle(Person.Builder().setName("Me").build())
            .addMessage(message1)
            .addMessage(message2)
    )
    .build()

Na Androidzie 9.0 (interfejs API na poziomie 28) i nowszych wersjach, aby uzyskać optymalne renderowanie powiadomienia i jego awatarów, musisz też używać klasy Person.

Jeśli używasz NotificationCompat.MessagingStyle, wykonaj te czynności:

  • Zadzwoń do MessagingStyle.setConversationTitle(), aby ustawić tytuł czatów grupowych z co najmniej 2 osobami. Dobrym tytułem rozmowy może być nazwa czatu grupowego lub, jeśli nie ma on nazwy, lista uczestników rozmowy. Bez tego wiadomość może zostać błędnie uznana za należącą do rozmowy 1:1 z nadawcą ostatniej wiadomości w rozmowie.
  • Użyj metody MessagingStyle.setData(), aby dołączyć wiadomości multimedialne, takie jak obrazy. Obsługiwane są typy MIME o wzorcu image/*.

Korzystanie z bezpośredniej odpowiedzi

Bezpośrednia odpowiedź umożliwia użytkownikowi odpowiadanie w tekście na wiadomość.

  • Gdy użytkownik odpowie za pomocą działania odpowiedzi w wierszu, użyj MessagingStyle.addMessage(), aby zaktualizować powiadomienie MessagingStyle. Nie wycofuj ani nie anuluj powiadomienia. Jeśli nie anulujesz powiadomienia, użytkownik będzie mógł wysłać z niego kilka odpowiedzi.
  • Aby działanie odpowiedzi wbudowanej było zgodne z Wear OS, wywołaj Action.WearableExtender.setHintDisplayInlineAction(true).
  • Użyj metody addHistoricMessage(), aby zapewnić kontekst rozmowy z bezpośrednią odpowiedzią, dodając do powiadomienia wcześniejsze wiadomości.

Włączanie Inteligentnej odpowiedzi

  • Aby włączyć Inteligentną odpowiedź, wywołaj setAllowGeneratedResponses(true) w odpowiedzi. Dzięki temu użytkownicy mogą korzystać z inteligentnych odpowiedzi, gdy powiadomienie jest przekazywane na urządzenie z Wear OS. Odpowiedzi w ramach funkcji Inteligentna odpowiedź są generowane przez model uczenia maszynowego działający w całości na zegarku, który wykorzystuje kontekst dostarczony przez powiadomienie NotificationCompat.MessagingStyle. Żadne dane nie są przesyłane do internetu w celu wygenerowania odpowiedzi.

Dodawanie metadanych powiadomień