Advanced Android in Kotlin 01.2: Android Firebase Cloud Messaging

Dieses Codelab ist Teil des Kurses „Advanced Android in Kotlin“. Sie können den größten Nutzen aus diesem Kurs ziehen, wenn Sie die Codelabs der Reihe nach durcharbeiten. Das ist jedoch nicht zwingend erforderlich. Alle Codelabs des Kurses sind auf der Landingpage für Codelabs zu „Android für Fortgeschrittene mit Kotlin“ aufgeführt.

Dieses Codelab ist Teil einer Reihe, in der Sie erfahren, wie Sie In-App- und Push-Benachrichtigungen verwenden. Wir empfehlen, alle Codelabs der Reihe nach durchzuarbeiten, da die Aufgaben Schritt für Schritt erklärt werden.

Die Codelabs in dieser Reihe sind:

• 1.1 Android-Benachrichtigungen verwenden
• 1.2 Android Firebase Cloud Messaging

Einführung

Im vorherigen Codelab haben Sie Ihrem Eieruhr-Projekt Benachrichtigungen hinzugefügt, die in Ihrer App erstellt und ausgelöst werden. Ein weiterer wichtiger Anwendungsfall für Benachrichtigungen ist das Remote-Senden von Push-Benachrichtigungen, die auch dann empfangen werden können, wenn Ihre App nicht ausgeführt wird.

Was ist eine Push-Benachrichtigung?

Push-Benachrichtigungen sind Benachrichtigungen, die der Server an Mobilgeräte „sendet“. Sie können auf einem Gerät zugestellt werden, unabhängig davon, ob Ihre App ausgeführt wird oder nicht.

Push-Benachrichtigungen sind eine gute Möglichkeit, Nutzer über ein Update zu informieren oder sie an eine Aufgabe oder Funktion zu erinnern. Stellen Sie sich vor, Sie warten darauf, dass ein Produkt wieder auf Lager ist. Mit einer Push-Benachrichtigung kann eine Shopping-App Sie über Aktualisierungen des Lagerbestands informieren, sodass Sie den Lagerstatus nicht jeden Tag prüfen müssen.

Push-Benachrichtigungen nutzen das Publish/Subscribe-Muster, mit dem Backend-Apps relevante Inhalte an interessierte Clients senden können. Ohne ein Publish/Subscribe-Modell müssten die Nutzer Ihrer App regelmäßig nach Updates suchen. Dieser Prozess ist für Nutzer mühsam und unzuverlässig. Außerdem würde die Anzahl der Clients mit der Zeit immer weiter steigen, sodass diese regelmäßigen Prüfungen die Netzwerk- und Verarbeitungsressourcen sowohl für den Server Ihrer App als auch für das Gerät eines Nutzers zu stark belasten würden.

Wie bei allen anderen Arten von Benachrichtigungen sollten Sie auch bei Push-Benachrichtigungen die Nutzer respektieren. Wenn die Benachrichtigungsinhalte für den Nutzer nicht interessant oder zeitnah sind, kann er alle Benachrichtigungen Ihrer App ganz einfach deaktivieren.

Was ist Firebase Cloud Messaging?

Firebase Cloud Messaging ist Teil der Firebase-Plattform für die mobile Entwicklung. Normalerweise müssten Sie einen Server von Grund auf einrichten, der mit Mobilgeräten kommunizieren kann, um Benachrichtigungen auszulösen. Mit Firebase Cloud Messaging können Sie Benachrichtigungen an alle Nutzer Ihrer installierten App oder an eine Teilmenge davon senden, ohne einen Server einrichten zu müssen. Sie können Nutzern beispielsweise eine Erinnerung senden oder ihnen ein besonderes Angebot wie ein kostenloses Geschenk machen.Sie können eine Benachrichtigung per Remotezugriff an ein einzelnes oder mehrere Geräte senden.

Sie können Firebase Cloud Messages auch verwenden, um Daten von Ihrer Backend-App oder einem Firebase-Projekt an Ihre Nutzer zu übertragen.

In diesem Codelab erfahren Sie, wie Sie mit Firebase Cloud Messaging Push-Benachrichtigungen für Ihre Android-App und Daten senden.

Wenn Sie bei der Bearbeitung dieses Codelabs auf Probleme stoßen (z. B. Codefehler, Grammatikfehler oder unklare Formulierungen), melden Sie das Problem bitte über den Link Fehler melden unten links im Codelab.

Was Sie bereits wissen sollten

Sie sollten mit Folgendem vertraut sein:

• So erstellen Sie Android-Apps in Kotlin. Insbesondere mit dem Android SDK.
• So entwerfen Sie Ihre App mit Architekturkomponenten und Datenbindung.
• Grundlegendes Verständnis von Broadcast-Empfängern.
• Grundlegendes Verständnis von AlarmManager.
• Benachrichtigungen mit NotificationManager erstellen und senden.

Lerninhalte

• So senden Sie Nachrichten über Firebase Cloud Messaging an den Nutzer.
• So senden Sie Daten von einem Backend an Ihre App mithilfe von Datennachrichten, die Teil von Firebase Cloud Messaging sind.

Aufgaben

• Push-Benachrichtigungen zur Starter-App hinzufügen
• Firebase Cloud Messaging verarbeiten, während Ihre App ausgeführt wird
• Daten mit Firebase Cloud Messaging übertragen.

In diesem Codelab arbeiten Sie mit dem Code aus dem vorherigen Codelab „Benachrichtigungen in Android-Apps verwenden“. Im vorherigen Codelab haben Sie eine Eieruhr-App entwickelt, die Benachrichtigungen sendet, wenn die Kochzeit abgelaufen ist. In diesem Codelab fügen Sie Firebase Cloud Messaging hinzu, um Push-Benachrichtigungen an Ihre App-Nutzer zu senden und sie daran zu erinnern, Eier zu essen.

Sie haben folgende Möglichkeiten, die Beispiel-App zu erhalten:

Klonen Sie das Repository von GitHub und wechseln Sie zum Zweig starter:

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

Alternativ können Sie das Repository als ZIP-Datei herunterladen, entzippen und in Android Studio öffnen.

Zip herunterladen

Schritt 1: Firebase-Projekt erstellen

Bevor Sie Firebase zu Ihrer Android-App hinzufügen können, müssen Sie ein Firebase-Projekt erstellen, das mit Ihrer Android-App verbunden wird.

1. Melden Sie sich in der Firebase Console an.
2. Klicken Sie auf Projekt hinzufügen und wählen Sie einen Projektname aus oder geben Sie einen ein. Geben Sie Ihrem Projekt den Namen fcm-codelab.
3. Klicken Sie auf Weiter.
4. Sie können die Einrichtung von Google Analytics überspringen, indem Sie die Schaltfläche Google Analytics für dieses Projekt aktivieren deaktivieren.
5. Klicken Sie auf Projekt erstellen, um die Einrichtung des Firebase-Projekts abzuschließen.

Schritt 2: App bei Firebase registrieren

Nachdem Sie ein Firebase-Projekt haben, können Sie Ihre Android-App hinzufügen.

1. Klicken Sie in der Mitte der Projektübersicht in der Firebase Console auf das Android, um den Einrichtungsworkflow zu starten.

2. Geben Sie im Feld Android-Paketname com.example.android.eggtimernotifications ein.
3. Klicken Sie auf App registrieren.

Wichtig : Achten Sie darauf, dass Sie die richtige ID für Ihre App eingeben. Sie können diesen Wert nicht mehr hinzufügen oder ändern, nachdem Sie Ihre App in Ihrem Firebase-Projekt registriert haben.

Schritt 3: Firebase-Konfigurationsdatei zum Projekt hinzufügen

Fügen Sie Ihrer App die Firebase-Konfigurationsdatei für Android hinzu.

1. Klicken Sie auf google-services.json herunterladen, um Ihre Firebase-Konfigurationsdatei für Android (google-services.json) zu erhalten. Achten Sie darauf, dass der Konfigurationsdatei keine zusätzlichen Zeichen angehängt werden und sie genau google-services.json heißt.
2. Verschieben Sie die Konfigurationsdatei in das Modulverzeichnis (auf App-Ebene) Ihrer App.

Hinweis:Sie können Ihre Firebase-Android-Konfigurationsdatei jederzeit wieder herunterladen.

Schritt 4: Android-Projekt für Firebase-Produkte konfigurieren

Wenn Sie Firebase-Produkte in Ihrer App aktivieren möchten, müssen Sie das google-services-Plug-in in Ihre Gradle-Dateien einfügen.

1. Prüfen Sie in der Gradle-Datei auf Stammebene (Projektebene) (build.gradle), ob das Maven-Repository von Google vorhanden ist.
2. Fügen Sie dann Regeln hinzu, um das Google-Dienste-Plug‑in einzuschließen.

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
    // ...
  }
}

3. Fügen Sie in der Gradle-Datei des Moduls (auf Anwendungsebene, in der Regel app/build.gradle) eine Zeile hinzu, um das Plug-in am Ende der Datei anzuwenden.

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

In dieser Aufgabe fügen Sie Ihrem Projekt Firebase Cloud Messaging (FCM) hinzu, um Push-Benachrichtigungen zu nutzen.

Der Android-Dienstcode für FCM dieses Codelabs ist in MyFirebaseMessagingService.kt angegeben. In den folgenden Schritten fügen Sie Ihrer Android-App Code hinzu.

Sie verwenden den Notifications Composer, um Ihre Implementierung zu testen. Mit dem Benachrichtigungs-Composer können Sie Nachrichten über die Firebase-Konsole verfassen und senden.

1. MyFirebaseMessagingService.kt öffnen
2. Prüfen Sie die Datei und insbesondere die folgenden Funktionen:

• onNewToken(): Wird automatisch aufgerufen, wenn Ihr Dienst im Android-Manifest registriert ist. Diese Funktion wird beim ersten Ausführen Ihrer App und jedes Mal aufgerufen, wenn Firebase ein neues Token für Ihre App ausgibt. Ein Token ist ein Zugriffsschlüssel für Ihr Firebase-Backend-Projekt. Sie wird für Ihr spezifisches Clientgerät generiert. Anhand dieses Tokens weiß Firebase, an welchen Client das Backend Nachrichten senden soll. Firebase weiß auch, ob dieser Client gültig ist und Zugriff auf dieses Firebase-Projekt hat.
• onMessageReceived: Wird aufgerufen, wenn Ihre App ausgeführt wird und Firebase eine Nachricht an Ihre App sendet. Diese Funktion empfängt ein RemoteMessage-Objekt, das eine Benachrichtigungs- oder Datennachrichtennutzlast enthalten kann. Später in diesem Codelab erfahren Sie mehr über die Unterschiede zwischen Benachrichtigungen und Nutzlasten von Datennachrichten.

Schritt 1: FCM-Benachrichtigungen an ein einzelnes Gerät senden

In der Benachrichtigungskonsole können Sie das Senden einer Benachrichtigung testen. Wenn Sie über die Konsole eine Nachricht an ein bestimmtes Gerät senden möchten, benötigen Sie das Registrierungstoken dieses Geräts.

Wenn das Firebase-Backend ein neues oder aktualisiertes Token generiert, wird die Funktion onNewToken() aufgerufen und das neue Token als Argument übergeben. Wenn Sie ein einzelnes Gerät als Ziel verwenden oder eine Gruppe von Geräten erstellen möchten, an die Sie eine Broadcast-Nachricht senden möchten, müssen Sie auf dieses Token zugreifen, indem Sie FirebaseMessagingService erweitern und onNewToken() überschreiben.

1. Öffnen Sie AndroidManifest.xml und heben Sie die Auskommentierung des folgenden Codes auf, um MyFirebaseMessagingService für die Eieruhr-App zu aktivieren. Durch die Dienstmetadaten im Android-Manifest wird MyFirebaseMessagingService als Dienst registriert und ein Intent-Filter hinzugefügt, damit dieser Dienst Nachrichten empfängt, die von FCM gesendet werden. Im letzten Teil der Metadaten wird breakfast_notification_channel_id als default_notification_channel_id für Firebase deklariert. Sie benötigen diese ID im nächsten Schritt.

<!-- 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] -->

Es empfiehlt sich, einen neuen Benachrichtigungskanal für FCM zu erstellen, da Nutzer möglicherweise den Eieruhr-Timer oder FCM-Push-Benachrichtigungen separat aktivieren/deaktivieren möchten.

2. Öffne ui/EggTimerFragment.kt . Füge in onCreateView() den folgenden Code zum Erstellen von Channels hinzu.

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

3. Öffnen Sie MyFirebaseMessagingService.kt und entfernen Sie die Kommentarzeichen für die Funktion onNewToken(). Diese Funktion wird aufgerufen, wenn ein neues Token generiert wird.

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

4. Führen Sie die Eieruhr-App aus.
5. Sehen Sie sich Logcat an (View > Tool Windows > Logcat). Sie sollten eine Logzeile mit Ihrem Token sehen, die in etwa so aussieht: Dies ist das Token, das Sie benötigen, um eine Nachricht an dieses Gerät zu senden. Diese Funktion wird nur aufgerufen, wenn ein neues Token erstellt wird.

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

Hinweis : Wenn Sie das Token nicht in den logcat-Nachrichten sehen, hat Ihre App es möglicherweise bereits erhalten. In diesem Fall können Sie die App deinstallieren, um ein neues Token zu erhalten.

Hinweis : Wenn Sie ein separates Backend-Projekt haben, können Sie dieses Client-Token optional speichern, um einzelne Nachrichten an diesen Client zu senden. In diesem Fall müssen Sie Ihr Backend aufrufen, um dieses Token sofort nach Erhalt eines neuen Tokens zu speichern. Der Backend-Dienst kann auf Firebase oder einem anderen Backend-Dienst gehostet werden. Im Beispielcode finden Sie eine leere Funktion namens sendRegistrationToServer(), die nach dem Empfang eines neuen Tokens aufgerufen wird. Mit dieser Funktion können Sie dieses Token an das Back-End Ihrer Wahl senden.

Jetzt können Sie eine Benachrichtigung senden, um den Test durchzuführen. Zum Senden einer Benachrichtigung verwenden Sie den Notifications Composer.

4. Öffnen Sie die Firebase Console und wählen Sie Ihr Projekt aus.
5. Wählen Sie als Nächstes im Navigationsbereich auf der linken Seite Cloud Messaging aus.
6. Klicken Sie auf Erste Nachricht senden.

5. Geben Sie Time for Breakfast! als Benachrichtigungstitel und Don't forget to eat eggs! als Benachrichtigungstext ein und wählen Sie Testnachricht senden aus. Das Pop-up-Dialogfeld Auf Gerät testen wird angezeigt und Sie werden aufgefordert, ein FCM-Registrierungstoken anzugeben.

6. Kopieren Sie Ihr App-Token aus Logcat.

7. Fügen Sie dieses Token in das Feld FCM-Registrierungstoken hinzufügen im Pop-up-Fenster ein und klicken Sie dann neben dem Token auf die Schaltfläche Hinzufügen.
8. Wählen Sie in der angezeigten Liste mit Kästchen das Token aus. Die Schaltfläche Testen sollte aktiviert werden.

9. Lege die Eieruhr App auf deinem Gerät in den Hintergrund .
10. Klicken Sie im Pop-up-Fenster auf Test.

6. Nachdem Sie auf Testen geklickt haben, sollte das Zielclientgerät, auf dem Ihre App im Hintergrund ausgeführt wird, die Benachrichtigung in der Taskleiste für Systembenachrichtigungen empfangen. (Wie Sie FCM-Nachrichten verarbeiten, wenn sich Ihre App im Vordergrund befindet, erfahren Sie später.)

Aufgabe: FCM-Benachrichtigungen an ein Thema senden

FCM-Themennachrichten basieren auf dem Publish/Subscribe-Modell.

Eine Messaging-App ist ein gutes Beispiel für das Publish/Subscribe-Modell. Angenommen, eine App ruft alle 10 Sekunden neue Nachrichten ab. Das belastet nicht nur den Akku Ihres Smartphones, sondern verbraucht auch unnötige Netzwerkressourcen und führt zu einer unnötigen Belastung des Servers Ihrer App. Stattdessen kann ein Clientgerät abonnieren und benachrichtigt werden, wenn neue Nachrichten über Ihre App zugestellt werden.

Mit Themen können Sie eine Nachricht an mehrere Geräte senden, die dieses Thema abonniert haben. Für Kunden sind Themen bestimmte Datenquellen, die sie interessieren. Für den Server sind Themen Gruppen von Geräten, die sich für den Empfang von Updates zu einer bestimmten Datenquelle registriert haben. Mit Themen können Sie Benachrichtigungskategorien wie Nachrichten, Wettervorhersagen und Sportergebnisse präsentieren. In diesem Teil des Codelabs erstellen Sie das Thema „Frühstück“, um interessierte App-Nutzer daran zu erinnern, Eier zum Frühstück zu essen.

Um ein Thema zu abonnieren, ruft die Client-App die Firebase Cloud Messaging-Funktion subscribeToTopic() mit dem Namen des Themas breakfast auf. Dieser Aufruf kann zwei Ergebnisse haben. Wenn der Aufrufer erfolgreich ist, wird der OnCompleteListener-Callback mit der abonnierten Nachricht aufgerufen. Wenn der Client das Abo nicht abschließen kann, wird stattdessen eine Fehlermeldung an den Callback gesendet.

In Ihrer App abonnieren Sie Ihre Nutzer automatisch für das Frühstücksthema. In den meisten Produktions-Apps ist es jedoch besser, Nutzern die Möglichkeit zu geben, selbst zu entscheiden, welche Themen sie abonnieren möchten.

1. Öffnen Sie EggTimerFragment.kt und suchen Sie nach der leeren Funktion subscribeTopic().
2. Rufen Sie eine Instanz von FirebaseMessaging ab und rufen Sie die Funktion subscibeToTopic() mit dem Namen des Themas auf.
3. Fügen Sie ein addOnCompleteListener hinzu, um von FCM benachrichtigt zu werden, ob Ihr Abo erfolgreich war oder fehlgeschlagen ist.

// 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]
    }

2. Rufen Sie die Funktion subscribeTopic() auf, um beim Start der App ein Thema zu abonnieren. Scrollen Sie nach oben zu onCreateView() und fügen Sie einen Aufruf von subscribeTopic() hinzu.

// EggTimerFragment.kt

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

    return binding.root

3. Wenn Sie das Frühstücksthema abonnieren möchten, starten Sie die App noch einmal. Es sollte eine Kurzmitteilung mit dem Text „Subscribed to topic“ (Thema abonniert) angezeigt werden.

Sie können jetzt das Senden von Nachrichten an ein Thema testen:

1. Öffnen Sie den Benachrichtigungs-Composer und wählen Sie Benachrichtigung erstellen aus.
2. Legen Sie den Benachrichtigungstitel und den Benachrichtigungstext wie zuvor fest.
3. Klicken Sie dieses Mal unter Ziel auf Thema und geben Sie breakfast als Nachrichtenthema ein, anstatt die Nachricht an ein einzelnes Gerät zu senden.

4. Wählen Sie für die Planung Jetzt aus.

5. Achten Sie darauf, dass Ihre App auf Ihrem Testgerät im Hintergrund ausgeführt wird.

6. Klicken Sie auf Überprüfen und dann auf Veröffentlichen. Wenn Sie die App auf mehreren Geräten ausführen können, können Sie testen und beobachten, dass die Benachrichtigung auf allen Geräten empfangen wird, die dieses Thema abonniert haben.

Die App hat jetzt die folgenden Kanäle für Benachrichtigungen: Egg (Ei) und Breakfast (Frühstück). Klicken Sie auf einem Clientgerät lange auf das App-Symbol, wählen Sie Info und dann Benachrichtigungen aus. Sie sollten die Benachrichtigungskanäle Egg (Ei) und Breakfast (Frühstück) sehen, wie im folgenden Screenshot dargestellt. Wenn Sie den Channel Breakfast deaktivieren, erhält Ihre App keine Benachrichtigungen, die über diesen Channel gesendet werden.

Denken Sie immer daran, dass Nutzer Benachrichtigungskanäle jederzeit deaktivieren können.

Schritt 1: Datenmeldungen

FCM-Nachrichten können auch eine Daten-Payload enthalten, mit der die Nachrichten in der Client-App verarbeitet werden. Verwenden Sie in diesem Fall Datennachrichten anstelle von Benachrichtigungen.

Um Daten-Nachrichten zu verarbeiten, müssen Sie die Daten-Nutzlast in der Funktion onMessageReceived() von MyFirebaseMessagingService verarbeiten. Die Nutzlast wird im Attribut data des remoteMessage-Objekts gespeichert. Sowohl das remoteMessage-Objekt als auch das Attribut data können null sein.

1. MyFirebaseMessagingService. öffnen
2. Prüfen Sie, ob das Attribut data des Objekts remoteMessage einen Wert hat, und geben Sie die Daten im Log aus.

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

Zum Testen des Codes können Sie den Notifications Composer noch einmal verwenden.

1. Öffnen Sie den Benachrichtigungs-Composer, erstellen Sie eine neue Nachricht und legen Sie als Ziel das Thema „Frühstück“ fest.
2. Wenn Sie diesmal zu Schritt 4, Zusätzliche Optionen, gelangen, legen Sie die Schlüssel- und Werteigenschaften für Benutzerdefinierte Daten so fest:

1. Schlüssel : eggs
2. Wert : 3

3. Achten Sie darauf, dass Ihre App im Vordergrund ausgeführt wird. Wenn Ihre App im Hintergrund ausgeführt wird, löst die FCM-Nachricht eine automatische Benachrichtigung aus. Die Funktion onMessageReceived() empfängt nur das Objekt remoteMessage, wenn der Nutzer auf die Benachrichtigung klickt.
4. Senden Sie die Nachricht über den Benachrichtigungs-Composer und sehen Sie sich das Datennachrichten-Log an, das in logcat angezeigt wird.

Hinweis : Die maximale Nutzlastgröße für beide Nachrichtentypen beträgt 4 KB (außer beim Senden von Nachrichten über die Firebase-Konsole, wo ein Limit von 1.024 Zeichen gilt).

Schritt 2: Nachrichten im Vorder- und Hintergrund verarbeiten

Wenn ein Clientgerät, auf dem Ihre App ausgeführt wird, eine Nachricht mit Benachrichtigungs- und Daten-Payloads empfängt, hängt das Verhalten der App davon ab, ob sie auf diesem Gerät im Hintergrund oder im Vordergrund ausgeführt wird:

• Wenn die App im Hintergrund ausgeführt wird und die Nachricht eine Benachrichtigungsnutzlast enthält, wird die Benachrichtigung automatisch in der Benachrichtigungsleiste angezeigt. Wenn die Nachricht auch eine Daten-Nutzlast hat, wird diese von der App verarbeitet, wenn der Nutzer auf die Benachrichtigung tippt.
• Wenn die App im Vordergrund ausgeführt wird und die Nachricht eine Benachrichtigungsnutzlast enthält, wird die Benachrichtigung nicht automatisch angezeigt. Die App muss in der Funktion onMessageReceived() entscheiden, wie die Benachrichtigung verarbeitet werden soll. Wenn die Nachricht auch eine Datennutzlast hat, werden beide Nutzlasten von der App verarbeitet.

In diesem Codelab soll der App-Nutzer daran erinnert werden, Eier zum Frühstück zu essen. Sie planen nicht, Daten zu senden, möchten aber sicherstellen, dass die Erinnerungsbenachrichtigung immer angezeigt wird, unabhängig davon, ob sich die App im Vordergrund oder Hintergrund befindet.

Wenn Sie eine FCM-Nachricht an Geräte senden, auf denen die Eieruhr-App installiert ist, wird die Benachrichtigung automatisch angezeigt, wenn die App nicht ausgeführt wird oder im Hintergrund aktiv ist. Wenn die App jedoch im Vordergrund ausgeführt wird, wird die Benachrichtigung nicht automatisch angezeigt. Stattdessen wird durch den Code der App festgelegt, was mit der Nachricht geschehen soll. Wenn die App im Vordergrund ausgeführt wird, wenn sie eine FCM-Nachricht empfängt, wird die Funktion onMessageReceived() automatisch mit der FCM-Nachricht ausgelöst. Hier kann Ihre App Benachrichtigungs- und Daten-Payloads im Hintergrund verarbeiten oder eine Benachrichtigung auslösen.

In Ihrer App soll der Nutzer die Erinnerung erhalten, wenn die App im Vordergrund ist. Implementieren wir also etwas Code, um eine Benachrichtigung auszulösen:

1. Öffnen Sie die Funktion onMessageReceived() in MyFirebaseMessagingService noch einmal.
2. Fügen Sie direkt nach dem Code, den Sie vor Kurzem zum Prüfen der Datennachricht hinzugefügt haben, den folgenden Code ein, mit dem eine Benachrichtigung über das Benachrichtigungs-Framework gesendet wird.

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

2. Wenn Sie die App noch einmal ausführen und eine Benachrichtigung mit dem Benachrichtigungs-Composer senden, sollte eine Benachrichtigung wie im ersten Teil des Codelabs angezeigt werden, unabhängig davon, ob sich die App im Vordergrund oder Hintergrund befindet.

Der Lösungscode befindet sich im Master-Branch des heruntergeladenen Codes.

• Implementieren Sie einen FCM-BroadcastReceiver, indem Sie FirebaseMessagingService erweitern.
• Richten Sie ein Firebase Cloud Messaging-Projekt (FCM) ein und fügen Sie Ihrer Android-App FCM hinzu.
• Testen Sie Ihre App, indem Sie Push-Benachrichtigungen über den Benachrichtigungs-Composer senden.
• Abonnieren Sie FCM-Themen, indem Sie die Funktion subscribeToTopic() der Klasse FirebaseMessaging aufrufen.
• Senden einer Daten-Payload mit einem RemoteMessage-Objekt.
• Daten in der Funktion onMessageReceived() verarbeiten.
• Fügen Sie Logik hinzu, um FCM zu verarbeiten, wenn die App im Vordergrund und im Hintergrund ausgeführt wird.

Udacity-Kurs:

• Android-Apps mit Kotlin entwickeln

Firebase-Dokumentation:

• Firebase Cloud Messaging
• Firebase Console
• Firebase-Android-Konfigurationsdatei herunterladen
• FirebaseMessagingService
• RemoteMessage
• Nachrichten über die Firebase Console senden
• Client-App für ein Thema abonnieren

Links zu anderen Codelabs in diesem Kurs finden Sie auf der Landingpage für die Codelabs zum Thema „Fortgeschrittenes Android in Kotlin“.