Ta strona została przetłumaczona przez Cloud Translation API.

Zaawansowany Android w Kotlinie 01.2: Komunikacja w chmurze Firebase na Androidzie

Te warsztaty są częścią kursu Zaawansowany Android w Kotlinie. Najwięcej korzyści z tego kursu uzyskasz, jeśli przejdziesz wszystkie ćwiczenia w kolejności, ale nie jest to obowiązkowe. Wszystkie ćwiczenia z tego kursu znajdziesz na stronie docelowej ćwiczeń z zaawansowanego Androida w Kotlinie.

Wprowadzenie

W poprzednim laboratorium dodaliśmy do minutnika powiadomienia, które są tworzone i wywoływane w aplikacji. Innym ważnym zastosowaniem powiadomień jest zdalne wysyłanie powiadomień push, które można odbierać nawet wtedy, gdy aplikacja nie jest uruchomiona.

Czym jest powiadomienie push?

Powiadomienia push to powiadomienia, które serwer „wypycha” na urządzenia mobilne. Mogą być dostarczane na urządzenie niezależnie od tego, czy aplikacja jest uruchomiona.

Powiadomienia push to świetny sposób na informowanie użytkowników o aktualizacjach lub przypominanie im o zadaniach lub funkcjach. Wyobraź sobie, że czekasz na ponowną dostępność produktu. Dzięki powiadomieniom push aplikacja do zakupów może informować Cię o aktualizacjach stanu magazynowego, zamiast zmuszać Cię do codziennego sprawdzania stanu.

Powiadomienia push korzystają z wzorca publikowania/subskrypcji, który umożliwia aplikacjom backendowym przesyłanie odpowiednich treści do zainteresowanych klientów. Bez modelu publikowania i subskrypcji użytkownicy aplikacji musieliby okresowo sprawdzać, czy są dostępne aktualizacje. Jest to dla nich uciążliwe i niezbyt wiarygodne. Poza tym wraz ze wzrostem liczby klientów te okresowe kontrole będą zbyt mocno obciążać zasoby sieciowe i przetwarzania zarówno serwera aplikacji, jak i urządzenia użytkownika.

Podobnie jak w przypadku innych typów powiadomień, w przypadku powiadomień push musisz szanować użytkowników. Jeśli treść powiadomienia nie jest interesująca lub aktualna dla użytkownika, może on łatwo wyłączyć wszystkie powiadomienia z Twojej aplikacji.

Czym jest Komunikacja w chmurze Firebase?

Komunikacja w chmurze Firebase jest częścią platformy Firebase do tworzenia aplikacji mobilnych. Zwykle musisz od zera skonfigurować serwer, który może komunikować się z urządzeniami mobilnymi, aby wywoływać powiadomienia. Dzięki Komunikacji w chmurze Firebase możesz wysyłać powiadomienia do wszystkich użytkowników, którzy mają zainstalowaną Twoją aplikację, lub do ich podzbioru bez konfigurowania serwera. Możesz na przykład wysłać użytkownikom przypomnienie lub zaoferować im specjalną promocję, np. bezpłatny prezent. Możesz zdalnie wysłać powiadomienie na jedno lub wiele urządzeń.

Możesz też używać Komunikacji w chmurze Firebase do przesyłania danych z aplikacji backendu lub z projektu Firebase do użytkowników.

Z tego przewodnika dowiesz się, jak używać Komunikacji w chmurze Firebase do wysyłania powiadomień push do aplikacji na Androida, a także do przesyłania danych.

Jeśli podczas wykonywania tego laboratorium napotkasz jakiekolwiek problemy (błędy w kodzie, błędy gramatyczne, niejasne sformułowania itp.), zgłoś je, klikając link Zgłoś błąd w lewym dolnym rogu laboratorium.

Co warto wiedzieć

Musisz znać:

Jak tworzyć aplikacje na Androida w języku Kotlin. W szczególności pracuj z pakietem Android SDK.
Jak zaprojektować aplikację za pomocą komponentów architektury i powiązywania danych.
Podstawowa wiedza o odbiornikach transmisji.
Podstawowa znajomość AlarmManager.
Jak tworzyć i wysyłać powiadomienia za pomocą NotificationManager.

Czego się nauczysz

Jak wysyłać wiadomości do użytkownika za pomocą Komunikacji w chmurze Firebase.
Jak wysyłać dane z backendu do aplikacji za pomocą wiadomości z danymi, które są częścią Komunikacji w chmurze Firebase.

Jakie zadania wykonasz

Dodaj powiadomienia push do aplikacji startowej.
Obsługa Komunikacji w chmurze Firebase podczas działania aplikacji.
Przenoszenie danych za pomocą Komunikacji w chmurze Firebase.

W tych ćwiczeniach z programowania będziesz pracować nad kodem z poprzednich ćwiczeń z programowania dotyczących używania powiadomień w aplikacjach na Androida. W poprzednim laboratorium kodowania utworzyliśmy aplikację do odmierzania czasu gotowania jajek, która wysyła powiadomienia, gdy czasomierz dobiegnie końca. W tym laboratorium kodowania dodasz Komunikację w chmurze Firebase, aby wysyłać powiadomienia push do użytkowników aplikacji i przypominać im o jedzeniu jajek.

Aby pobrać przykładową aplikację, możesz wykonać jedną z tych czynności:

Sklonuj repozytorium z GitHuba i przejdź do gałęzi starter:

$  git clone https://github.com/googlecodelabs/android-kotlin-notifications-fcm

Możesz też pobrać repozytorium jako plik ZIP, rozpakować go i otworzyć w Android Studio.

Pobierz plik ZIP

Krok 1. Utwórz projekt Firebase

Zanim dodasz Firebase do aplikacji na Androida, musisz utworzyć projekt Firebase, aby połączyć go z tą aplikacją.

Zaloguj się w konsoli Firebase.
Kliknij Dodaj projekt, a potem wybierz lub wpisz Nazwę projektu. Nazwij projekt fcm-codelab.
Kliknij Dalej.
Możesz pominąć konfigurowanie Google Analytics, wyłączając przycisk Włącz Google Analytics w tym projekcie .
Aby zakończyć konfigurowanie projektu Firebase, kliknij Utwórz projekt.

Krok 2. Zarejestruj aplikację w Firebase

Mając projekt Firebase, możesz dodać do niego swoją aplikację na Androida.

W centrum strony „Opis” projektu w konsoli Firebase kliknij ikonę Android, aby uruchomić proces konfiguracji.

W polu Nazwa pakietu na Androida wpisz com.example.android.eggtimernotifications.
Kliknij Zarejestruj aplikację.

Ważne: wpisz prawidłowy identyfikator aplikacji, ponieważ po zarejestrowaniu aplikacji w projekcie Firebase nie możesz dodać ani zmodyfikować tej wartości.

Krok 3. Dodaj do projektu plik konfiguracji Firebase

Dodaj do aplikacji plik konfiguracyjny Firebase na Androida.

Kliknij Pobierz plik google-services.json, aby uzyskać plik konfiguracyjny Firebase na Androida (google-services.json). Upewnij się, że do pliku konfiguracyjnego nie zostały dodane żadne dodatkowe znaki i że jego nazwa to dokładnie google-services.json.
Przenieś plik konfiguracyjny do katalogu modułu (na poziomie aplikacji).

Krok 4. Skonfiguruj projekt na Androida, aby włączyć usługi Firebase

Aby włączyć usługi Firebase w aplikacji, musisz dodać wtyczkę usług Google do plików Gradle.

W pliku Gradle na poziomie głównym (projektu) (build.gradle) sprawdź, czy masz repozytorium Google Maven.
Następnie dodaj reguły, aby uwzględnić wtyczkę Usług Google.

build.gradle

buildscript {

  repositories {
    // Check that you have the following line (if not, add it):
    google()  // Google's Maven repository
  }

  dependencies {
    // ...

    // Add the following line:
    classpath 'com.google.gms:google-services:4.3.2'  // Google Services plugin
  }
}

allprojects {
  // ...

  repositories {
    // Check that you have the following line (if not, add it):
    google()  // Google's Maven repository
    // ...
  }
}

W pliku Gradle modułu (na poziomie aplikacji) (zazwyczaj app/build.gradle) dodaj na końcu wiersz, aby zastosować wtyczkę.

app/build.gradle

apply plugin: 'com.android.application'

android {
  // ...
}

// Add the following line to the bottom of the file:
apply plugin: 'com.google.gms.google-services'  // Google Play services Gradle plugin

W tym zadaniu dodasz do projektu Komunikację w chmurze Firebase (FCM), aby korzystać z powiadomień push.

Kod usługi Androida dla FCM w tym laboratorium jest podany w sekcji MyFirebaseMessagingService.kt. W kolejnych krokach dodasz kod do aplikacji na Androida.

Do testowania implementacji będziesz używać edytora powiadomień. Edytor powiadomień to narzędzie, które pomaga tworzyć i wysyłać wiadomości z witryny konsoli Firebase.

Otwórz aplikację MyFirebaseMessagingService.kt
Sprawdź plik, a w szczególności te funkcje:

onNewToken()– wywoływana automatycznie, jeśli usługa jest zarejestrowana w pliku manifestu Androida. Ta funkcja jest wywoływana przy pierwszym uruchomieniu aplikacji i za każdym razem, gdy Firebase wydaje dla niej nowy token. Token to klucz dostępu do projektu backendu Firebase. Jest on generowany dla konkretnego urządzenia klienta. Dzięki temu tokenowi Firebase wie, do którego klienta backend powinien wysyłać wiadomości. Firebase wie też, czy ten klient jest prawidłowy i ma dostęp do tego projektu Firebase.
onMessageReceived – wywoływana, gdy aplikacja jest uruchomiona, a Firebase wysyła do niej wiadomość. Ta funkcja otrzymuje obiekt RemoteMessage, który może zawierać powiadomienie lub ładunek wiadomości z danymi. Więcej informacji o różnicach między powiadomieniami a ładunkami wiadomości z danymi znajdziesz w dalszej części tego laboratorium.

Krok 1. Wysyłanie powiadomień FCM na jedno urządzenie

Konsola powiadomień umożliwia testowanie wysyłania powiadomień. Aby wysłać wiadomość do konkretnego urządzenia za pomocą konsoli, musisz znać token rejestracji tego urządzenia.

Gdy backend Firebase wygeneruje nowy lub odświeżony token, zostanie wywołana funkcja onNewToken(), a nowy token zostanie przekazany jako argument. Jeśli chcesz kierować reklamy na jedno urządzenie lub utworzyć grupę urządzeń, na które chcesz wysyłać wiadomości, musisz uzyskać dostęp do tego tokena, rozszerzając FirebaseMessagingService i zastępując onNewToken().

Otwórz AndroidManifest.xml i usuń komentarz z poniższego kodu, aby włączyć MyFirebaseMessagingService w aplikacji minutnika. Metadane usługi w pliku manifestu Androida rejestrują MyFirebaseMessagingService jako usługę i dodają filtr intencji, dzięki czemu ta usługa będzie otrzymywać wiadomości wysyłane z FCM. Ostatnia część metadanych deklaruje breakfast_notification_channel_id jako default_notification_channel_id w przypadku Firebase. Użyjesz go w następnym kroku.

<!-- AndroidManifest.xml -->
<!-- TODO: Step 3.0 uncomment to start the service  -->

        <service
                android:name=".MyFirebaseMessagingService"
                android:exported="false">
            <intent-filter>
                <action android:name="com.google.firebase.MESSAGING_EVENT"/>
            </intent-filter>
        </service>
        <!-- [START fcm_default_icon] -->
        <!--
 Set custom default icon. This is used when no icon is set for incoming notification messages.
             See README(https://goo.gl/l4GJaQ) for more.
        -->
        <meta-data
                android:name="com.google.firebase.messaging.default_notification_icon"
                android:resource="@drawable/common_google_signin_btn_icon_dark"/>
        <!--
 Set color used with incoming notification messages. This is used when no color is set for the incoming
             notification message. See README(https://goo.gl/6BKBk7) for more.
        -->
        <meta-data
                android:name="com.google.firebase.messaging.default_notification_color"
                android:resource="@color/colorAccent"/> <!-- [END fcm_default_icon] -->
        <!-- [START fcm_default_channel] -->
        <meta-data
            android:name="com.google.firebase.messaging.default_notification_channel_id"
            android:value="@string/breakfast_notification_channel_id" />
        <!-- [END fcm_default_channel] -->

Warto utworzyć nowy kanał powiadomień dla FCM, ponieważ użytkownicy mogą chcieć włączać i wyłączać powiadomienia push z minutnika lub FCM oddzielnie.

Otwórz ui/EggTimerFragment.kt . W pliku onCreateView() dodaj ten kod tworzenia kanału.

// EggTimerFragment.kt

   // TODO: Step 3.1 create a new channel for FCM
    createChannel(
        getString(R.string.breakfast_notification_channel_id),
        getString(R.string.breakfast_notification_channel_name)
    )

Otwórz MyFirebaseMessagingService.kt i usuń znacznik komentarza z funkcji onNewToken(). Ta funkcja zostanie wywołana, gdy zostanie wygenerowany nowy token.

// MyFirebaseMessagingService.kt

   // TODO: Step 3.2 log registration token
    // [START on_new_token]
    /**
     * Called if InstanceID token is updated. This may occur if the security of
     * the previous token had been compromised. Note that this is called when the     
     * InstanceID token is initially generated so this is where you would retrieve     
     * the token.
     */
    override fun onNewToken(token: String?) {
        Log.d(TAG, "Refreshed token: $token")

        // If you want to send messages to this application instance or
        // manage this apps subscriptions on the server side, send the
        // Instance ID token to your app server.
        sendRegistrationToServer(token)
    }
    // [END on_new_token]

Uruchom aplikację minutnika.
Obserwuj logcat (Widok > Okna narzędzi > Logcat). Powinien pojawić się wiersz dziennika z tokenem podobny do tego poniżej. Jest to token potrzebny do wysłania wiadomości na to urządzenie. Ta funkcja jest wywoływana tylko wtedy, gdy tworzony jest nowy token.

2019-07-23 13:09:15.243 2312-2459/com.example.android.eggtimernotifications D/MyFirebaseMsgService: Refreshed token: f2esflBoQbI:APA91bFMzNNFaIskjr6KIV4zKjnPA4hxekmrtbrtba2aDbh593WQnm11ed54Mv6MZ9Yeerver7pzgwfKx7R9BHFffLBItLEgPvrtF0TtX9ToCrXZ5y7Hd-m

Uwaga: jeśli nie widzisz tokena w wiadomościach logcat, być może Twoja aplikacja otrzymała go już wcześniej. W takim przypadku odinstalowanie aplikacji pomoże Ci uzyskać nowy token.

Teraz możesz przetestować wysyłanie powiadomień. Aby wysłać powiadomienie, użyj edytora powiadomień.

Otwórz konsolę Firebase i wybierz projekt.
Następnie w menu po lewej stronie wybierz Cloud Messaging.
Kliknij Wyślij pierwszą wiadomość.

Wpisz Time for Breakfast! jako tytuł powiadomienia i Don't forget to eat eggs! jako tekst powiadomienia, a potem kliknij Wyślij wiadomość testową. Pojawi się okno dialogowe Testuj na urządzeniu z prośbą o podanie tokena rejestracji FCM.

Skopiuj token aplikacji z logcat.

Wklej ten token w polu Dodaj token rejestracji FCM w wyskakującym okienku, a następnie kliknij przycisk Dodaj obok tokena.
Na wyświetlonej liście pól wyboru zaznacz token. Przycisk Test powinien zostać włączony.

Na urządzeniu uruchom aplikację Egg Timer w tle .
W wyskakującym okienku kliknij Test.

Po kliknięciu Test docelowe urządzenie klienta, na którym aplikacja działa w tle, powinno otrzymać powiadomienie w obszarze powiadomień systemowych. (Więcej informacji o obsłudze wiadomości FCM, gdy aplikacja działa na pierwszym planie, znajdziesz w dalszej części tego artykułu).

Zadanie: wysyłanie powiadomień FCM do tematu

Wysyłanie wiadomości do tematów FCM opiera się na modelu publikowania/subskrypcji.

Aplikacja do przesyłania wiadomości może być dobrym przykładem modelu publikowania/subskrypcji. Wyobraź sobie, że aplikacja sprawdza nowe wiadomości co 10 sekund. Nie tylko wyczerpuje to baterię telefonu, ale też zużywa niepotrzebne zasoby sieci i niepotrzebnie obciąża serwer aplikacji. Zamiast tego urządzenie klienta może zasubskrybować powiadomienia o nowych wiadomościach dostarczanych przez Twoją aplikację.

Tematy umożliwiają wysyłanie wiadomości na wiele urządzeń, które subskrybują dany temat. W przypadku klientów tematy to konkretne źródła danych, które ich interesują. W przypadku serwera tematy to grupy urządzeń, które wyraziły zgodę na otrzymywanie aktualizacji z określonego źródła danych. Tematy mogą służyć do prezentowania kategorii powiadomień, takich jak wiadomości, prognozy pogody i wyniki sportowe. W tej części laboratorium utworzysz temat „śniadanie”, aby przypominać zainteresowanym użytkownikom aplikacji o zjedzeniu jajek na śniadanie.

Aby zasubskrybować temat, aplikacja kliencka wywołuje funkcję subscribeToTopic() Komunikacji w chmurze Firebase z nazwą tematu breakfast. Połączenie może mieć 2 rezultaty. Jeśli wywołanie się powiedzie, funkcja zwrotna OnCompleteListener zostanie wywołana z zasubskrybowaną wiadomością. Jeśli klient nie może zasubskrybować, wywołanie zwrotne otrzyma komunikat o błędzie.

W aplikacji automatycznie zasubskrybujesz temat śniadania. W większości aplikacji produkcyjnych lepiej jednak dać użytkownikom kontrolę nad tym, które tematy chcą subskrybować.

Otwórz EggTimerFragment.kt i znajdź pustą funkcję subscribeTopic().
Uzyskaj instancję FirebaseMessaging i wywołaj funkcję subscibeToTopic() z nazwą tematu.
Dodaj addOnCompleteListener, aby otrzymywać z FCM powiadomienia o tym, czy subskrypcja się powiodła.

// EggTimerFragment.kt

   // TODO: Step 3.3 subscribe to breakfast topic
    private fun subscribeTopic() {
        // [START subscribe_topics]
        FirebaseMessaging.getInstance().subscribeToTopic(TOPIC)
            .addOnCompleteListener { task ->
                var msg = getString(R.string.message_subscribed)
                if (!task.isSuccessful) {
                    msg = getString(R.string.message_subscribe_failed)
                }
                Toast.makeText(context, msg, Toast.LENGTH_SHORT).show()
            }
        // [END subscribe_topics]
    }

Wywołaj funkcję subscribeTopic(), aby zasubskrybować temat po uruchomieniu aplikacji. Przewiń w górę do onCreateView() i dodaj połączenie do subscribeTopic().

// EggTimerFragment.kt

   // TODO: Step 3.4 call subscribe topics on start
    subscribeTopic()

    return binding.root

Aby zasubskrybować temat śniadania, ponownie uruchom aplikację. Powinien wyświetlić się komunikat „Subscribed to topic” (Subskrypcja tematu).

Teraz możesz przetestować wysyłanie wiadomości do tematu:

Otwórz edytor powiadomień i kliknij Utwórz powiadomienie.
Ustaw tytuł powiadomienia i tekst powiadomienia tak jak wcześniej.
Tym razem zamiast wysyłać wiadomość na jedno urządzenie, w sekcji Cel kliknij Temat i wpisz breakfast jako temat wiadomości.

W sekcji „Planowanie” wybierz Teraz.

Upewnij się, że aplikacja działa w tle na urządzeniu testowym.

Kliknij Sprawdź, a potem Opublikuj. Jeśli możesz uruchomić aplikację na więcej niż 1 urządzeniu, możesz przetestować i sprawdzić, czy powiadomienie jest odbierane na wszystkich urządzeniach subskrybujących ten temat.

Aplikacja ma teraz te kanały powiadomień: Egg i Breakfast. Na urządzeniu klienckim przytrzymaj ikonę aplikacji, wybierz Informacje i kliknij Powiadomienia. Powinny się wyświetlić kanały powiadomień Egg i Breakfast, jak na tym zrzucie ekranu: Jeśli odznaczysz kanał Breakfast, Twoja aplikacja nie będzie otrzymywać żadnych powiadomień wysyłanych tym kanałem.

Pamiętaj, że użytkownicy mogą w każdej chwili wyłączyć dowolny kanał powiadomień.

Krok 1. Wiadomości z danymi

Wiadomości FCM mogą też zawierać ładunek danych, który przetwarza wiadomości w aplikacji klienta. Zamiast wiadomości z powiadomieniami możesz używać wiadomości z danymi.

Aby obsługiwać wiadomości z danymi, musisz obsługiwać ładunek danych w funkcji onMessageReceived() obiektu MyFirebaseMessagingService. Ładunek jest przechowywany we właściwości data obiektu remoteMessage. Zarówno obiekt remoteMessage, jak i właściwość data mogą mieć wartość null.

Otwórz aplikację MyFirebaseMessagingService.
Sprawdź, czy właściwość data obiektu remoteMessage ma jakąś wartość, i zapisz dane w dzienniku.

// MyFirebaseMessagingService.kt

    // [START receive_message]
    override fun onMessageReceived(remoteMessage: RemoteMessage?) {
        // Not getting messages here? See why this may be: https://goo.gl/39bRNJ
        Log.d(TAG, "From: ${remoteMessage?.from}")
        
       // TODO: Step 3.5 check messages for data
        // Check if the message contains a data payload.
        remoteMessage?.data?.let {
            Log.d(TAG, "Message data payload: " + remoteMessage.data)
        }

    }
    // [END receive_message]

Aby przetestować kod, możesz ponownie użyć edytora powiadomień.

Otwórz narzędzie do tworzenia powiadomień, utwórz nową wiadomość i ustaw jej miejsce docelowe na temat „śniadanie”.
Tym razem, gdy dojdziesz do kroku 4, Opcje dodatkowe, ustaw właściwości klucza i wartości Dane niestandardowe w ten sposób:

Klucz: eggs
Wartość: 3

Sprawdź, czy aplikacja działa na pierwszym planie. Jeśli aplikacja działa w tle, wiadomość FCM wywoła automatyczne powiadomienie, a funkcja onMessageReceived() otrzyma tylko obiekt remoteMessage, gdy użytkownik kliknie powiadomienie.
Wyślij wiadomość z kompozytora powiadomień i sprawdź dziennik wiadomości z danymi, który pojawi się w logcat.

Krok 2. Obsługa wiadomości na pierwszym planie i w tle

Gdy urządzenie klienta z Twoją aplikacją otrzyma wiadomość zawierającą zarówno powiadomienie, jak i ładunek danych, zachowanie aplikacji zależy od tego, czy działa ona w tle czy na pierwszym planie:

Jeśli aplikacja działa w tle, a wiadomość zawiera ładunek powiadomienia, powiadomienie jest automatycznie wyświetlane na pasku powiadomień. Jeśli wiadomość zawiera też ładunek danych, zostanie on obsłużony przez aplikację, gdy użytkownik kliknie powiadomienie.
Jeśli aplikacja jest uruchomiona na pierwszym planie, a powiadomienie o wiadomości zawiera ładunek powiadomienia, powiadomienie nie pojawi się automatycznie. Aplikacja musi zdecydować, jak obsłużyć powiadomienie w funkcji onMessageReceived(). Jeśli wiadomość zawiera też ładunek danych, oba ładunki zostaną obsłużone przez aplikację.

W tym samouczku chcesz przypomnieć użytkownikowi aplikacji, aby zjadł jajka na śniadanie. Nie planujesz wysyłać żadnych danych, ale chcesz mieć pewność, że powiadomienie z przypomnieniem będzie się zawsze wyświetlać, niezależnie od tego, czy aplikacja działa na pierwszym planie, czy w tle.

Gdy wyślesz wiadomość FCM na urządzenia, na których jest zainstalowana aplikacja do odmierzania czasu, powiadomienie zostanie wyświetlone automatycznie, jeśli aplikacja nie jest uruchomiona lub działa w tle. Jeśli jednak aplikacja działa na pierwszym planie, powiadomienie nie jest wyświetlane automatycznie. Zamiast tego kod aplikacji decyduje, co zrobić z wiadomością. Jeśli aplikacja działa na pierwszym planie, gdy otrzyma wiadomość FCM, funkcja onMessageReceived() zostanie automatycznie wywołana z tą wiadomością. W tym miejscu aplikacja może w trybie cichym obsługiwać powiadomienia i ładunki danych lub wywoływać powiadomienia.

Chcesz, aby użytkownik otrzymywał przypomnienie, gdy aplikacja jest na pierwszym planie, więc zaimplementujmy kod, który wywoła powiadomienie:

Ponownie otwórz funkcję onMessageReceived() w MyFirebaseMessagingService.
Bezpośrednio po kodzie, który został niedawno dodany w celu sprawdzenia wiadomości z danymi, dodaj poniższy kod, który wysyła powiadomienie za pomocą platformy powiadomień.

// MyFirebaseMessagingService.kt

    // TODO: Step 3.6 check messages for notification and call sendNotification
    // Check if the message contains a notification payload.
    remoteMessage.notification?.let {
        Log.d(TAG, "Message Notification Body: ${it.body}")
        sendNotification(it.body as String)
    }

Jeśli ponownie uruchomisz aplikację i wyślesz powiadomienie za pomocą narzędzia do tworzenia powiadomień, zobaczysz powiadomienie takie samo jak w pierwszej części tego laboratorium, niezależnie od tego, czy aplikacja działa na pierwszym planie czy w tle.

Kod rozwiązania znajduje się w gałęzi głównej pobranego kodu.

Zaimplementuj FCM BroadcastReceiver, rozszerzając FirebaseMessagingService.
Skonfiguruj projekt Komunikacji w chmurze Firebase (FCM) i dodaj FCM do aplikacji na Androida.
Testuj aplikację, wysyłając powiadomienia push z kompozytora powiadomień.
Subskrybuj tematy FCM, wywołując funkcję subscribeToTopic() klasy FirebaseMessaging.
Wysyłaj ładunek danych za pomocą obiektu RemoteMessage.
Obsługa danych w funkcji onMessageReceived().
Dodaj logikę obsługi FCM, gdy aplikacja działa na pierwszym planie i w tle.

Kurs Udacity:

Tworzenie aplikacji na Androida w języku Kotlin

Dokumentacja Firebase:

Linki do innych ćwiczeń z tego kursu znajdziesz na stronie docelowej ćwiczeń z zaawansowanego Androida w Kotlinie.