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. Więcej informacji o tym, jak powiadomienia wyświetlają się w Androidzie, znajdziesz w artykule Omówienie powiadomień. Przykładowy kod, który korzysta z powiadomień, znajdziesz w przykładzie SociaLite na GitHubie.

Kod na tej stronie korzysta z interfejsów API NotificationCompat z biblioteki AndroidX. Te interfejsy API umożliwiają dodawanie funkcji dostępnych tylko w nowszych wersjach Androida, a jednocześnie zapewniają zgodność z Androidem 9 (interfejs API na poziomie 28). Niektóre funkcje, takie jak działanie związane z odpowiedzią w tekście, w starszych wersjach nie działają.

Tworzenie podstawowego powiadomienia

Powiadomienie w najbardziej podstawowej i kompaktowej postaci – zwanej też zwiniętą postacią – wyświetla ikonę, tytuł i niewielką ilość tekstu. W tej sekcji dowiesz się, jak utworzyć powiadomienie, które użytkownik może kliknąć, aby uruchomić działanie w aplikacji.

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

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

Deklarowanie uprawnienia w czasie działania

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

Uprawnienie, które musisz zadeklarować w pliku manifestu aplikacji, znajdziesz 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 znajdziesz w artykule Uprawnienia w czasie działania dotyczące powiadomień.

Ustawianie treści powiadomienia

Na początek ustaw treść i kanał powiadomienia za pomocą obiektu NotificationCompat.Builder. Ten przykład pokazuje, jak utworzyć powiadomienie z tymi elementami:

  • Mała ikona ustawiona za pomocą setSmallIcon(). Jest to jedyna wymagana treść widoczna dla użytkownika.

  • Tytuł ustawiony za pomocą setContentTitle().

  • Tekst główny ustawiony za pomocą setContentText().

  • Priorytet powiadomienia ustawiony za pomocą setPriority(). Priorytet określa, jak natrętne jest powiadomienie w Androidzie 7.1 i starszych wersjach. 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 w przypadku zgodności z Androidem 8.0 (interfejs API na poziomie 26) i nowszymi wersjami, ale starsze wersje ignorują tę wartość.

Domyślnie tekst powiadomienia jest skracany, aby zmieścił się w jednym wierszu. Dodatkowe informacje możesz wyświetlić, tworząc powiadomienie rozwijane.

Rysunek 2. Rozwijane powiadomienie w postaci 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ą 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 tym, jak dodać obraz i elementy sterujące odtwarzaniem multimediów, znajdziesz w artykule Tworzenie powiadomienia rozwijanego.

Tworzenie kanału i ustawianie ważności

Zanim będziesz mieć możliwość dostarczania powiadomień w Androidzie 8.0 i nowszych wersjach, zarejestruj kanał powiadomień aplikacji w systemie, przekazując instancję NotificationChannel do createNotificationChannel(). Ten 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ć natychmiast po uruchomieniu aplikacji. Możesz go wywoływać wielokrotnie, ponieważ utworzenie istniejącego kanału nie powoduje żadnych zmian.

Konstruktor NotificationChannel wymaga poziomu ważności, który jest stałą NotificationManager. Określa on, jak przerywać użytkownikowi. Aby obsługiwać Androida 7.1 i starsze wersje, ustaw też priorytet za pomocą setPriority(), jak pokazano w poprzednim przykładzie.

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

Więcej informacji o znaczeniu poszczególnych poziomów znajdziesz w artykule Poziomy ważności powiadomień.

Ustawianie działania po kliknięciu powiadomienia

Każde powiadomienie musi reagować na kliknięcie, zwykle przez otwarcie działania w aplikacji, które odpowiada powiadomieniu. Aby to zrobić, określ intencję treści zdefiniowaną za pomocą obiektu PendingIntent i przekaż ją do setContentIntent().

Ten fragment kodu pokazuje, jak utworzyć podstawową intencję otwierania działania, 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 setAutoCancel(), które 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 ich użyć w zależności od typu uruchamianego działania, które może być jednym z tych typów:

Wyświetlanie powiadomienia

Aby wyświetlić powiadomienie, wywołaj NotificationManagerCompat.notify(), przekazując mu unikalny identyfikator powiadomienia i wynik NotificationCompat.Builder.build(). Pokazuje to ten przykład:

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 zechcesz zaktualizować lub usunąć powiadomienie.

Aby przetestować podstawowe powiadomienia na urządzeniach z Androidem 13 i nowszymi wersjami, włącz powiadomienia ręcznie lub utwórz okno z prośbą o zgodę na wyświetlanie powiadomień.

Dodawanie przycisków działań

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

Rysunek 3. Powiadomienie z 1 przyciskiem polecenia.

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

Ten kod pokazuje na przykład, 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 BroadcastReceiver do wykonywania zadań w tle znajdziesz w artykule Omówienie transmisji.

Jeśli zamiast tego chcesz utworzyć powiadomienie z przyciskami odtwarzania multimediów, np. wstrzymywania i pomijania utworów, dowiedz się, jak utworzyć powiadomienie z elementami sterującymi multimediami.

Dodawanie działania związanego z bezpośrednią odpowiedzią

Działanie związane z bezpośrednią odpowiedzią, wprowadzone w Androidzie 7.0 (interfejs API na poziomie 24), umożliwia użytkownikom wpisywanie tekstu bezpośrednio w powiadomieniu. Tekst jest następnie dostarczany do aplikacji bez otwierania działania. Możesz na przykład użyć działania związanego z bezpośrednią 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 tekstowe.

Działanie związane z bezpośrednią odpowiedzią wyświetla się jako dodatkowy przycisk w powiadomieniu, który otwiera pole tekstowe. 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.

Dodawanie przycisku 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 używa jako klucza do pola tekstowego. Aplikacja używa później tego klucza do pobierania tekstu.

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

Gdy użytkownik wywoła działanie powiadomienia, system wyświetli prośbę o wpisanie odpowiedzi, jak pokazano na rysunku 4.

Pobieranie danych wejściowych użytkownika z odpowiedzi

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

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

Po przetworzeniu tekstu zaktualizuj powiadomienie, wywołując 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 jak w przypadku RemoteInput. Ten przykład używa obrazu jako danych wejściowych.

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ź do dołu powiadomienia, wywołując setRemoteInputHistory(). Jeśli jednak tworzysz aplikację do przesyłania 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 przesyłania wiadomości znajdziesz w sekcji poświęconej sprawdzonym sposobom tworzenia aplikacji do przesyłania wiadomości.

Wyświetlanie pilnej wiadomości

Aplikacja może wymagać wyświetlenia pilnej wiadomości, która jest wrażliwa na czas, np. połączenia przychodzącego lub dzwonka alarmu. W takich sytuacjach możesz powiązać z powiadomieniem intencję pełnoekranową.

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

  • Jeśli urządzenie użytkownika jest zablokowane, pojawi się działanie pełnoekranowe, które zasłoni ekran blokady.
  • Jeśli urządzenie użytkownika jest odblokowane, powiadomienie pojawi się w rozwiniętej postaci, która zawiera opcje obsługi lub odrzucenia powiadomienia.

Ten 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 na ekranie blokady

Aby kontrolować poziom szczegółowości widoczny w powiadomieniu na ekranie blokady, wywołaj 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: na ekranie blokady widoczne 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 obsługi SMS-ów może wyświetlać powiadomienie „Masz 3 nowe SMS-y”, ale ukrywać treść wiadomości i nadawców. Aby podać to alternatywne powiadomienie, najpierw utwórz je za pomocą NotificationCompat.Builder jak zwykle. Następnie dołącz alternatywne powiadomienie do zwykłego powiadomienia za pomocą setPublicVersion().

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

Aktualizowanie powiadomienia

Aby zaktualizować powiadomienie po jego wysłaniu, ponownie wywołaj NotificationManagerCompat.notify(), przekazując mu ten sam identyfikator, którego używasz. Jeśli poprzednie powiadomienie zostanie odrzucone, zamiast niego zostanie utworzone nowe powiadomienie.

Opcjonalnie możesz wywołać setOnlyAlertOnce(), aby powiadomienie przerywało użytkownikowi (dźwiękiem, wibracjami lub wskazówkami wizualnymi) tylko przy pierwszym wyświetleniu, a nie przy późniejszych aktualizacjach.

Usuwanie powiadomienia

Powiadomienia pozostają widoczne do momentu, gdy:

  • użytkownik odrzuci powiadomienie;
  • użytkownik kliknie powiadomienie, jeśli podczas jego tworzenia wywołasz setAutoCancel().
  • wywołasz cancel() dla konkretnego identyfikatora powiadomienia. Ta metoda usuwa też powiadomienia w toku.
  • wywołasz cancelAll(), które usuwa wszystkie wcześniej wysłane powiadomienia.
  • upłynie określony czas, jeśli podczas tworzenia powiadomienia, jeśli ustawisz limit czasu za pomocą setTimeoutAfter(). W razie potrzeby możesz anulować powiadomienie przed upływem określonego limitu czasu.

Sprawdzone sposoby tworzenia aplikacji do przesyłania wiadomości

Podczas tworzenia powiadomień dla aplikacji do przesyłania wiadomości i czatów weź pod uwagę sprawdzone sposoby wymienione poniżej.

Korzystanie z MessagingStyle

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

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.

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

  • Wywołaj MessagingStyle.setConversationTitle(), aby ustawić tytuł czatów grupowych z więcej niż 2 osobami. Dobry tytuł rozmowy może być nazwą czatu grupowego lub, jeśli nie ma nazwy, listą uczestników rozmowy. Bez tego wiadomość może zostać błędnie uznana za należącą do rozmowy 1 na 1 z nadawcą najnowszej wiadomości w rozmowie.
  • Użyj metody MessagingStyle.setData(), aby dołączyć wiadomości multimedialne np. obrazy. Obsługiwane są typy MIME pasujące do wzorca image/*.

Korzystanie z bezpośredniej odpowiedzi

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

  • Gdy użytkownik odpowie za pomocą działania związanego z odpowiedzią w tekście, użyj MessagingStyle.addMessage(), aby zaktualizować MessagingStyle powiadomienie, i nie wycofuj ani nie anuluj powiadomienia. Nieanulowanie powiadomienia umożliwia użytkownikowi wysyłanie wielu odpowiedzi z powiadomienia.
  • Aby działanie związane z odpowiedzią w tekście było zgodne z Wear OS, wywołaj Action.WearableExtender.setHintDisplayInlineAction(true).
  • Użyj metody addHistoricMessage() , aby dodać do powiadomienia historyczne wiadomości i zapewnić kontekst rozmowy z bezpośrednią odpowiedzią.

Włączanie Inteligentnej odpowiedzi

  • Aby włączyć Inteligentną odpowiedź, wywołaj setAllowGeneratedResponses(true) w działaniu związanym z 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 Szybka 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 powiadomienia