Zaawansowane funkcje Androida w Kotlin 01.2: Komunikacja w chmurze Androida Firebase

To ćwiczenie programowania jest częścią kursu „Android dla zaawansowanych w Kotlinie”. Korzyści z tego kursu będą dla Ciebie najbardziej wartościowe, jeśli wykonasz je w sekwencjach ćwiczeń z programowania, ale nie jest to obowiązkowe. Wszystkie ćwiczenia z kursu są wymienione na stronie Zaawansowane ćwiczenia z programowania na Androida w Kotlin.

Wstęp

W ramach poprzedniego ćwiczenia z programowania dodałeś powiadomienia do minutnika jaj, które są tworzone i uruchamiane w aplikacji. Innym ważnym przykładem powiadomień jest zdalne wysyłanie powiadomień push, które możesz otrzymywać nawet wtedy, gdy aplikacja nie jest uruchomiona.

Co to jest powiadomienie push?

Powiadomienia push to powiadomienia wysyłane przez serwer na urządzenia mobilne. Mogą one być wysyłane na urządzenie niezależnie od tego, czy jest uruchomiona.

Dzięki powiadomieniom push możesz poinformować użytkowników o aktualizacji lub zadaniu. Wyobraź sobie, że czekasz na ponowne udostępnienie produktu. Dzięki powiadomieniom push aplikacja zakupowa może informować Cię o aktualizacjach akcji, zamiast sprawdzać codziennie stan zapasów.

Powiadomienia push używają wzorca publikowania/subskrypcji, który umożliwia aplikacjom backendu przekazywanie odpowiednich treści zainteresowanym klientom. Bez modelu publikowania i subskrypcji użytkownicy musieliby od czasu do czasu sprawdzać dostępność aktualizacji w Twojej aplikacji. Ten proces jest żmudny i niestabilny dla użytkowników. Co więcej, wraz ze wzrostem liczby klientów tego rodzaju okresowe kontrole będą zbyt duże do wykorzystania na potrzeby sieci i przetwarzania zasobów, zarówno na serwerze aplikacji, jak i na urządzeniu użytkownika.

Tak jak w przypadku innych rodzajów powiadomień, zadbaj o to, by szanować użytkowników za pomocą powiadomień push. Jeśli treść powiadomienia nie jest interesująca dla użytkownika lub nie zawiera aktualnych informacji, użytkownik może łatwo wyłączyć wszystkie powiadomienia z aplikacji.

Co to jest Firebase Cloud Messaging?

Komunikacja w chmurze Firebase jest częścią platformy Firebase do programowania aplikacji mobilnych. Zazwyczaj konieczne jest skonfigurowanie serwera od zera, który może komunikować się z urządzeniami mobilnymi w celu aktywowania powiadomień. Dzięki Komunikacji w chmurze Firebase (FCM) możesz wysyłać powiadomienia do wszystkich użytkowników swojej aplikacji lub tylko do niektórych z nich bez konieczności konfigurowania serwera. Możesz na przykład wysłać użytkownikom przypomnienie lub specjalną promocję, taką jak prezent.Możesz wysłać powiadomienie zdalnie na jedno lub wiele urządzeń.

Możesz też wykorzystać Wiadomości Firebase Cloud do przenoszenia danych z aplikacji backendu lub z projektu Firebase do użytkowników.

Z tego modułu dowiesz się, jak używać Komunikacji w chmurze Firebase do wysyłania powiadomień push w aplikacji na Androida i wysyłania danych.

Jeśli podczas ćwiczeń z programowania napotkasz jakiekolwiek błędy (błędy w kodzie, błędy gramatyczne, niejasne słowa itp.), zgłoś je, klikając link Zgłoś błąd w lewym dolnym rogu ćwiczeń z programowania.

Co musisz wiedzieć

Pamiętaj:

  • Jak tworzyć aplikacje na Androida w Kotlinie. Szczególnie dotyczy to pakietu Android SDK.
  • Projektowanie aplikacji z wykorzystaniem komponentów architektury i wiązania danych.
  • Podstawowe informacje o odbiorcach transmisji.
  • Podstawowe informacje o usłudze AlarmManager.
  • Tworzenie i wysyłanie powiadomień za pomocą usługi NotificationsManager.

Czego się nauczysz

  • Jak przekazywać wiadomości do użytkownika za pomocą Komunikacji w chmurze Firebase (FCM).
  • Jak wysyłać dane z backendu do aplikacji przy użyciu komunikatów danych, które są częścią Firebase Cloud Messaging.

Jakie zadania wykonasz:

  • Dodawaj powiadomienia push do aplikacji startowej.
  • obsługiwać Komunikację w chmurze Firebase (FCM) podczas działania aplikacji.
  • Przenoszenie danych za pomocą Komunikacji w chmurze Firebase (FCM).

W ramach tych ćwiczeń będziesz pracować nad kodem z poprzedniego ćwiczenia z sekcji Powiadomienia w aplikacjach na Androida. W poprzednim ćwiczeniu z programowania stworzyliśmy aplikację jajek do wysyłania jaj, która wysyła powiadomienia po zakończeniu licznika czasu W ramach tego ćwiczenia dodasz komunikaty Firebase Cloud Messaging, aby wysyłać użytkownikom push powiadomienia przypominające o spożywaniu jaj.

Możesz pobrać aplikację próbną na dwa sposoby:

Skopiuj repozytorium z GitHuba i przełącz się na gałąź 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 aplikację Zip

Krok 1. Utwórz projekt Firebase

Zanim dodasz Firebase do swojej aplikacji na Androida, musisz utworzyć projekt Firebase i połączyć się z aplikacją na Androida.

  1. Zaloguj się w konsoli Firebase.
  2. Kliknij Dodaj projekt, a następnie wybierz lub wpisz nazwę projektu. Nazwij swój projekt fcm-codelab.
  3. Kliknij Dalej.
  4. Aby pominąć konfigurowanie Google Analytics, wyłącz przycisk Włącz Google Analytics w tym projekcie.
  5. Kliknij Utwórz projekt, aby zakończyć konfigurowanie projektu Firebase.

Krok 2. Zarejestruj aplikację w Firebase

Po utworzeniu projektu Firebase możesz dodać do niego aplikację na Androida.

  1. Na środku strony podsumowania projektu w konsoli Firebase kliknij ikonę Androida, aby uruchomić przepływ konfiguracji.

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

Ważne: upewnij się, że podajesz prawidłowy identyfikator aplikacji, ponieważ po zarejestrowaniu jej w projekcie Firebase nie można dodać ani zmienić tej wartości.

Krok 3. Dodaj plik konfiguracji Firebase do projektu

Dodaj do aplikacji plik konfiguracji Firebase na Androida.

  1. Kliknij Pobierz google-services.json, aby uzyskać plik konfiguracyjny Firebase na Androida (google-services.json). Upewnij się, że plik konfiguracji nie zawiera dodatkowych znaków i dokładnie nazywa się google-services.json.
  2. Przenieś plik konfiguracyjny do katalogu modułu (na poziomie aplikacji) aplikacji.

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

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

  1. W pliku Gradle na poziomie katalogu głównego (build.gradle) sprawdź, czy masz repozytorium Maven Google.
  2. Następnie dodaj reguły, by dodać wtyczkę Usługi 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
    // ...
  }
}
  1. W pliku Gradle modułu (na poziomie aplikacji) (zwykle app/build.gradle) dodaj wiersz, aby zastosować wtyczkę u dołu pliku.

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 Firebase Cloud Messaging (FCM), aby korzystać z powiadomień push.

Kod usługi Androida dla FCM tego ćwiczenia z programowania znajdziesz w MyFirebaseMessagingService.kt. W kolejnych krokach dodasz kod do swojej aplikacji na Androida.

Aby przetestować implementację, użyj narzędzia do tworzenia powiadomień. Narzędzie do tworzenia powiadomień to narzędzie, które pomaga tworzyć i wysyłać wiadomości w witrynie konsoli Firebase.

  1. Otwórz: MyFirebaseMessagingService.kt
  2. Sprawdź plik, a w szczególności:
  • onNewToken() – jest wywoływana automatycznie, jeśli Twoja usługa jest zarejestrowana w pliku manifestu Androida. Ta funkcja jest wywoływana przy pierwszym uruchomieniu aplikacji i za każdym razem, gdy Firebase wygeneruje nowy token dla Twojej aplikacji. Token to klucz dostępu do projektu Firebase. Jest generowany dla Twojego urządzenia klienckiego. 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 – jest wywoływane, gdy aplikacja jest uruchomiona, a Firebase wysyła do niej wiadomość. Ta funkcja otrzymuje obiekt RemoteMessage, który może przekazywać powiadomienie lub ładunek danych. Więcej informacji o różnicach między powiadomieniami a ładunkami wiadomości znajdziesz w dalszej części tego ćwiczenia.

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

Konsola powiadomień umożliwia przetestowanie wysłania powiadomienia. Aby wysłać wiadomość na określone urządzenie za pomocą konsoli, musisz znać ten token rejestracji 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 1 urządzenie lub utworzyć grupę urządzeń, na które chcesz wysłać wiadomość, musisz uzyskać dostęp do tego tokena, rozwijając FirebaseMessagingService i zastępując wartość onNewToken().

  1. Otwórz AndroidManifest.xml i cofnij oznaczenie tego kodu, by włączyć MyFirebaseMessagingService w aplikacji z licznikiem jaj. Usługa Meta-danych w pliku manifestu Androida rejestruje MyFirebaseMessagingService jako usługę i dodaje filtr intencji, dzięki czemu będzie otrzymywać wiadomości wysyłane z FCM. Ostatnia część metadanych deklaruje breakfast_notification_channel_id jako default_notification_channel_id dla 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] -->

Dobrze jest utworzyć nowy kanał powiadomień w FCM, ponieważ użytkownicy mogą chcieć włączyć lub wyłączyć powiadomienia od progów dla jaj lub powiadomienia push w FCM.

  1. Otwórz aplikację ui/EggTimerFragment.kt. W 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)
    )
  1. Otwórz MyFirebaseMessagingService.kt i cofnij komentarz do funkcji onNewToken(). Ta funkcja zostanie wywołana po wygenerowaniu nowego tokena.
// 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]
  1. Uruchom aplikację jajka z licznikiem czasu.
  2. Obserwuj dziennik (View > Tool Windows > Logcat). Powinien pojawić się wiersz dziennika pokazujący token podobny do poniższego. Jest to token, którego potrzebujesz do wysłania wiadomości na to urządzenie. Ta funkcja jest wywoływana tylko podczas tworzenia nowego tokena. 
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, oznacza to, że aplikacja mogła już go uzyskać. W takim przypadku odinstalowanie aplikacji pomoże Ci otrzymać nowy token.

Możesz teraz przeprowadzić test, wysyłając powiadomienie. Do wysyłania powiadomień będziesz używać narzędzia do tworzenia powiadomień.

  1. Otwórz konsolę Firebase i wybierz projekt.
  2. W menu po lewej stronie wybierz Cloud Messaging.
  3. Kliknij Wyślij pierwszą wiadomość.

  1. Wpisz Time for Breakfast! jako tytuł powiadomienia i Don't forget to eat eggs! jako tekst powiadomienia, a następnie wybierz Wyślij wiadomość testową. Pojawi się wyskakujące okienko Test na urządzeniu z prośbą o podanie tokena rejestracji FCM.

  1. Skopiuj token aplikacji z logcat.

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

  1. Na urządzeniu umieść aplikację Minutnik jaj w tle.
  2. W wyskakującym okienku kliknij Przetestuj.
  1. Gdy klikniesz Przetestuj, urządzenie klienckie, na którym Twoja aplikacja działa w tle, powinno otrzymać powiadomienie w obszarze powiadomień systemu. Później zobaczysz, jak obsługiwać wiadomości w FCM, gdy aplikacja działa na pierwszym planie.

Zadanie: wysyłanie powiadomień FCM na temat

Komunikaty na temat FCM są oparte na modelu publikowania/subskrypcji.

Dobrym przykładem modelu Opublikuj/Subskrybuj może być aplikacja do obsługi wiadomości. Wyobraź sobie, że aplikacja szuka nowych wiadomości co 10 sekund. Nie tylko spowoduje to wyczerpywanie się baterii, ale spowoduje również niepotrzebne wykorzystanie sieci i spowoduje niepotrzebne obciążenie serwera aplikacji. Zamiast tego urządzenie klienckie może subskrybować usługę i otrzymywać powiadomienia o nowych wiadomościach wysyłanych z niej.

Tematy umożliwiają wysyłanie wiadomości na wiele urządzeń, na których włączono ten temat. Tematy odnoszą się do konkretnych źródeł danych, którymi klient jest zainteresowany. Na serwerze tematy to grupy urządzeń, które zgodziły się na otrzymywanie aktualizacji z konkretnego źródła danych. Tematy mogą służyć do prezentacji kategorii powiadomień, takich jak wiadomości, prognozy pogody czy wyniki sportowe. W ramach tej części ćwiczenia utworzysz w temacie „&śniadanie” temat, który pozwoli zainteresowanym użytkownikom zjeść jaja przy śniadaniu.

Aby subskrybować temat, aplikacja kliencka wywołuje funkcję Komunikacja w chmurze Firebase subscribeToTopic() o nazwie tematu breakfast. To połączenie może mieć dwa wyniki. Jeśli element wywołujący zostanie wywołany, wywołanie zwrotne OnCompleteListener zostanie wysłane z subskrybowaną wiadomością. Jeśli klient nie ukończy subskrypcji, wywołanie zwrotne otrzyma komunikat o błędzie.

W aplikacji automatycznie zasubskrybujesz temat śniadaniowy. Jednak w większości aplikacji w wersji produkcyjnej lepiej jest dać użytkownikom kontrolę nad subskrybowanymi tematami.

  1. Otwórz EggTimerFragment.kt i znajdź pustą funkcję subscribeTopic().
  2. Pobierz wystąpienie FirebaseMessaging i wywołaj funkcję subscibeToTopic() o nazwie tematu.
  3. Dodaj addOnCompleteListener, aby otrzymywać z FCM powiadomienia o tym, czy Twoja 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]
    }
  1. Wywołaj funkcję subscribeTopic(), aby zasubskrybować temat przy uruchamianiu 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
  1. Aby zasubskrybować temat śniadaniowy, uruchom aplikację ponownie. Powinien wyświetlić się komunikat „Subskrybujesz temat”.

Teraz możesz przetestować wysyłanie wiadomości w temacie:

  1. Otwórz narzędzia do tworzenia powiadomień i wybierz Utwórz powiadomienie.
  2. Ustaw odpowiednio Tytuł powiadomienia i Tekst powiadomienia.
  3. Tym razem zamiast wysyłać wiadomość na 1 urządzenie, kliknij Temat w sekcji Cel i wpisz breakfast jako temat wiadomości.

  1. W sekcji Harmonogram wybierz Teraz.

  1. Upewnij się, że aplikacja działa w tle na urządzeniu testowym.
  1. Kliknij kolejno Sprawdź i Opublikuj. Jeśli możesz uruchomić aplikację na więcej niż jednym urządzeniu, możesz sprawdzić i sprawdzić, czy powiadomienie jest odbierane na wszystkich urządzeniach, które subskrybują ten temat.

W aplikacji są teraz dostępne te kanały powiadomień: Jagoda i Śniadanie. Na urządzeniu klienckim kliknij ikonę aplikacji, wybierz Informacje i kliknij Powiadomienia. Powinny być widoczne kanały Jagodła i Śniadanie, jak widać na zrzucie ekranu poniżej. Jeśli odznaczysz kanał Śniadanie, aplikacja nie będzie otrzymywać od niego powiadomień.

Gdy korzystasz z powiadomień, pamiętaj, że użytkownicy mogą w każdej chwili wyłączyć kanał powiadomień.

Krok 1. Komunikaty o danych

Komunikaty FCM mogą też zawierać ładunek danych, który przetwarza wiadomości w aplikacji klienckiej, wykorzystując wiadomości z danymi zamiast wiadomości z powiadomieniami.

Aby obsługiwać wiadomości, musisz wykonać ładunek danych w funkcji onMessageReceived() funkcji MyFirebaseMessagingService. Ładunek jest przechowywany we właściwości data obiektu remoteMessage. Obiektem remoteMessage i właściwością data może być null.

  1. Otwórz: MyFirebaseMessagingService.
  2. Sprawdź, czy właściwość data obiektu remoteMessage ma jakąś wartość i wydrukuj dane do logu.
// 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 użyć ponownie narzędzia do tworzenia powiadomień.

  1. Otwórz narzędzie do tworzenia powiadomień, utwórz nową wiadomość i ustaw dla niej Element docelowy na temat „śniadanie”.
  2. Gdy dojdziesz do kroku 4 (Opcje dodatkowe), ustaw właściwości klucza i wartości Dane niestandardowe w ten sposób:
  1. Klucz: eggs
  2. Wartość: 3

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

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

Gdy na urządzeniu klienckim, na którym działa Twoja aplikacja, pojawi się komunikat zawierający zarówno powiadomienia, jak i ładunki danych, działanie aplikacji zależy od tego, czy działa w tle czy na pierwszym planie na tym urządzeniu:

  • Jeśli aplikacja działa w tle, oznacza to, że powiadomienie zawiera ładunek powiadomień i automatycznie wyświetla się w obszarze powiadomień. Jeśli wiadomość ma też ładunek danych, zostanie ona wykorzystana przez aplikację, gdy użytkownik kliknie powiadomienie.
  • Jeśli aplikacja działa na pierwszym planie, to gdy powiadomienie o wiadomości zawiera ładunek powiadomień, nie pojawi się ona automatycznie. Aplikacja musi zdecydować, jak obsługiwać powiadomienia w funkcji onMessageReceived(). Jeśli wiadomość zawiera również ładunek danych, oba ładunki będą obsługiwane przez aplikację.

Na potrzeby tego ćwiczenia chcesz przypomnieć użytkownikowi aplikacji, że może zjeść jajka na śniadanie. Nie zamierzasz wysyłać żadnych danych, ale warto mieć pewność, że powiadomienie będzie wyświetlane zawsze, 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 ładowania jaj, powiadomienie wyświetli się automatycznie, jeśli aplikacja nie jest uruchomiona lub jest uruchomiona w tle. Jeśli jednak aplikacja działa na pierwszym planie, to powiadomienie nie wyświetla się automatycznie. Zamiast tego kod aplikacji decyduje, co zrobić z wiadomością. Jeśli aplikacja znajdzie się na pierwszym planie, gdy otrzyma wiadomość FCM, funkcja onMessageReceived() zostanie wywołana automatycznie za pomocą wiadomości FCM. Aplikacja może dyskretnie obsługiwać powiadomienia i ładunki danych oraz wywoływać powiadomienia.

W przypadku aplikacji chcesz mieć pewność, że użytkownik otrzyma przypomnienie, gdy aplikacja będzie działać na pierwszym planie. Aktywujmy więc odpowiedni kod, by wywołać powiadomienie:

  1. Ponownie otwórz funkcję onMessageReceived() w aplikacji MyFirebaseMessagingService.
  2. Bezpośrednio za kodem, który został przez Ciebie dodany w celu sprawdzenia wiadomości, dodaj ten kod, który wysyła powiadomienie przy użyciu 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)
    }
  1. Jeśli ponownie uruchomisz aplikację i wyślesz powiadomienie przy użyciu narzędzia do tworzenia powiadomień, powinno ono być widoczne tak samo jak w pierwszej części ćwiczenia z programowania, 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.

Kurs Udacity:

Dokumentacja Firebase:

Linki do innych ćwiczeń z programowania w tym kursie znajdziesz na stronie Zaawansowane ćwiczenia z Androida w Kotlin.