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ę na Androidzie, znajdziesz w omówieniu 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, przy jednoczesnym zachowaniu zgodności z Androidem 9 (interfejs API na poziomie 28). Jednak niektóre funkcje, takie jak działanie odpowiedzi w tekście, w starszych wersjach nie działają.

Tworzenie podstawowego powiadomienia

Powiadomienie w najbardziej podstawowej i kompaktowej postaci – zwanej też formą zwiniętą – 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 Twojej 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. Poniższy 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 treści 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 builder = NotificationCompat.Builder(context, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .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ą ten parametr.

Domyślnie tekst powiadomienia jest skracany, aby zmieścił się w jednym wierszu. Możesz wyświetlić dodatkowe informacje, 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.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)

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:

private 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(Context.NOTIFICATION_SERVICE) as NotificationManager
        notificationManager.createNotificationChannel(channel)
    }
}

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

Konstruktor NotificationChannel wymaga podania importance za pomocą jednej ze stałych z klasy NotificationManager. Ten parametr określa, jak przerywać użytkownikowi wyświetlanie powiadomień należących do tego kanału. Aby obsługiwać Androida 7.1 i starsze wersje, ustaw priorytet za pomocą setPriority(), jak pokazano w poprzednim przykładzie.

Chociaż musisz ustawić ważność lub priorytet powiadomienia, jak pokazano w tym przykładzie, system nie gwarantuje, że alert będzie działać zgodnie z Twoimi oczekiwaniami. W niektórych przypadkach system może zmienić poziom ważności na podstawie innych czynników, a użytkownik zawsze może ponownie zdefiniować poziom ważności dla danego 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.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 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 użyć tej funkcji 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(NOTIFICATION_ID, builder.build())
}

Zapisz identyfikator powiadomienia przekazywany 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 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 1 przyciskiem polecenia.

Aby dodać przycisk polecenia, przekaż PendingIntent do addAction() metody. Jest to podobne do konfigurowania domyślnego działania po kliknięciu powiadomienia, z tym że 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.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        .setContentIntent(pendingIntent)
        .addAction(R.drawable.ic_snooze, context.getString(R.string.snooze),
                snoozePendingIntent)

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

Jeśli zamiast tego próbujesz utworzyć powiadomienie z przyciskami odtwarzania multimediów, takimi jak wstrzymywanie i pomijanie utworów, dowiedz się, jak utworzyć powiadomienie z elementami sterującymi multimediami.

Dodawanie działania bezpośredniej odpowiedzi

Działanie bezpośredniej 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 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 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 Twojej 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 wykorzystuje jako klucz do wprowadzania tekstu. Twoja aplikacja używa później tego klucza do pobierania tekstu.

// Key for the string that's delivered in the action's intent.
private val KEY_TEXT_REPLY = "key_text_reply"
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,
        conversation.getConversationId(),
        getMessageReplyIntent(conversation.getConversationId()),
        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.ic_reply_icon,
        context.getString(R.string.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 wprowadzenie odpowiedzi, jak pokazano na rysunku 4.

Pobieranie danych wejściowych użytkownika z odpowiedzi

Aby otrzymywać dane wejściowe użytkownika w interfejsie 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.ic_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 KEY_REPLY = "key_reply"
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
            try {
                val inputStream = context.contentResolver.openInputStream(imageUri)
                val bitmap = BitmapFactory.decodeStream(inputStream)
                // Display the image
                // ...
            } catch (e: Exception) {
                Log.e("ReplyReceiver", "Failed to process image URI", e)
            }
        }
    }
}

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 obsługi wiadomości, utwórz powiadomienie w stylu wiadomości i dołącz nową wiadomość do wątku.

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

Wyświetlanie pilnej wiadomości

Twoja aplikacja może wyświetlać pilne, wrażliwe na czas wiadomości, takie 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ą 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.notification_icon)
        .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 wiadomości tekstowe”, ale ukrywać treść wiadomości i nadawców. Aby podać 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 wcześniej. Jeśli poprzednie powiadomienie zostanie odrzucone, zamiast tego 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 o trwającej aktywności.
  • 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 metody dotyczące aplikacji do obsługi wiadomości

Podczas tworzenia powiadomień dla aplikacji do obsługi wiadomości i czatów weź pod uwagę sprawdzone metody 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 user = Person.Builder()
    .setIcon(userIcon)
    .setName(userName)
    .build()

val notification = NotificationCompat.Builder(context, 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()

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 wątku.
  • Użyj metody MessagingStyle.setData(), aby dołączyć wiadomości multimedialne , takie jak obrazy. Obsługiwane są typy MIME pasujące do wzorca image/*.

Korzystanie z bezpośredniej odpowiedzi

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

  • Gdy użytkownik odpowie za pomocą działania 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 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 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