‫Advanced Android in Kotlin 01.2: Android Firebase Cloud Messaging

ה-codelab הזה הוא חלק מהקורס Advanced Android in Kotlin (פיתוח מתקדם ל-Android ב-Kotlin). כדי להפיק את המרב מהקורס הזה, מומלץ לעבוד על ה-codelabs לפי הסדר, אבל זה לא חובה. כל ה-codelab של הקורס מפורטים בדף הנחיתה של ה-codelab בנושא Android מתקדם ב-Kotlin.

ה-codelab הזה הוא חלק מסדרה שמסבירה איך להשתמש בהודעות פוש ובהודעות מתוך האפליקציה. מומלץ לבצע את כל ה-codelabs לפי הסדר, כי הם מתקדמים במשימות שלב אחר שלב.

ה-codelabs בסדרה הזו הם:

• ‫1.1 שימוש בהתראות ב-Android
• ‫1.2 העברת הודעות בענן ב-Firebase ל-Android

מבוא

במעבדת הקוד הקודמת, הוספתם לאפליקציית שעון העצר התראות שנוצרות ומופעלות בתוך האפליקציה. מקרה שימוש חשוב נוסף של התראות הוא שליחה מרחוק של התראות פוש, שאפשר לקבל גם כשהאפליקציה לא פועלת.

מהי התראה?

התראות פוש הן התראות שהשרת שולח למכשירים ניידים. אפשר לשלוח אותם למכשיר בלי קשר לשאלה אם האפליקציה שלכם פועלת או לא.

התראות פוש הן דרך מצוינת ליידע את המשתמשים על עדכון או להזכיר להם משימה או תכונה. תארו לעצמכם שאתם מחכים שמוצר מסוים יחזור למלאי. באמצעות התראות פוש, אפליקציות קניות יכולות לעדכן אתכם לגבי שינויים במלאי במקום שתצטרכו לבדוק את סטטוס המלאי מדי יום.

ההתראות בדחיפה מבוססות על דפוס הפרסום/הרשמה, שמאפשר לאפליקציות בקצה העורפי לדחוף תוכן רלוונטי ללקוחות שהביעו עניין. בלי מודל של פרסום/הרשמה, המשתמשים באפליקציה יצטרכו לבדוק מעת לעת אם יש עדכונים לאפליקציה. התהליך הזה מייגע ולא אמין למשתמשים. בנוסף, ככל שמספר הלקוחות גדל, הבדיקות התקופתיות האלה יוצרות עומס גדול מדי על משאבי הרשת והעיבוד, גם בשרת של האפליקציה וגם במכשיר של המשתמש.

כמו בכל סוג אחר של התראות, חשוב לכבד את המשתמשים בהתראות פוש. אם תוכן ההתראה לא מעניין או לא רלוונטי למשתמש, הוא יכול להשבית בקלות את כל ההתראות מהאפליקציה שלכם.

מה זה Firebase Cloud Messaging?

‫Firebase Cloud Messaging הוא חלק מפלטפורמת Firebase לפיתוח אפליקציות לנייד. בדרך כלל צריך להגדיר שרת מאפס שיכול לתקשר עם מכשירים ניידים כדי להפעיל התראות. בעזרת Firebase Cloud Messaging, אתם יכולים לשלוח התראות לכל המשתמשים שהתקינו את האפליקציה שלכם, או רק לחלק מהם, בלי להגדיר שרת. לדוגמה, אתם יכולים לשלוח למשתמשים תזכורת או לתת להם מבצע מיוחד, כמו מתנה בחינם.אתם יכולים לשלוח מרחוק התראה למכשיר יחיד או למספר מכשירים.

אפשר גם להשתמש ב-Firebase Cloud Messages כדי להעביר נתונים מהאפליקציה בעורף או מפרויקט Firebase למשתמשים.

ב-codelab הזה תלמדו איך להשתמש ב-Firebase Cloud Messaging כדי לשלוח הודעות push לאפליקציית Android, וגם איך לשלוח נתונים.

אם נתקלתם בבעיות (באגים בקוד, שגיאות דקדוק, ניסוח לא ברור וכו') במהלך העבודה עם ה-codelab הזה, אתם יכולים לדווח על הבעיה באמצעות הקישור דיווח על טעות בפינה הימנית התחתונה של ה-codelab.

מה שכדאי לדעת

חשוב שתכירו את:

• איך יוצרים אפליקציות ל-Android ב-Kotlin. במיוחד, כדאי לעבוד עם Android SDK.
• איך לעצב את האפליקציה באמצעות רכיבי ארכיטקטורה וקישור נתונים.
• הבנה בסיסית של מקלטי שידורים.
• הבנה בסיסית של AlarmManager.
• איך יוצרים ושולחים התראות באמצעות NotificationManager.

מה תלמדו

• איך שולחים הודעות למשתמש באמצעות העברת הודעות בענן ב-Firebase.
• איך שולחים נתונים מהקצה העורפי לאפליקציה באמצעות הודעות נתונים, שהן חלק משירות העברת ההודעות בענן ב-Firebase.

הפעולות שתבצעו:

• מוסיפים התראות פוש לאפליקציית המתחילים.
• טיפול בהעברת הודעות בענן ב-Firebase בזמן שהאפליקציה פועלת.
• העברת נתונים באמצעות Firebase Cloud Messaging.

ב-Codelab הזה תעבדו על הקוד מ-Codelab הקודם בנושא שימוש בהתראות באפליקציות ל-Android. ב-codelab הקודם יצרתם אפליקציה של שעון ביצים ששולחת התראות כשהטיימר של הבישול מסתיים. ב-codelab הזה תוסיפו את Firebase Cloud Messaging כדי לשלוח הודעות פוש למשתמשי האפליקציה שלכם, ולהזכיר להם לאכול ביצים.

כדי לקבל את האפליקציה לדוגמה, אפשר:

משכפלים את המאגר מ-GitHub ועוברים להסתעפות starter:

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

לחלופין, אפשר להוריד את המאגר כקובץ ZIP, לבטל את הדחיסה שלו ולפתוח אותו ב-Android Studio.

הורדת קובץ Zip

שלב 1: יצירת פרויקט Firebase

כדי להוסיף את Firebase לאפליקציית Android, צריך ליצור פרויקט Firebase שאליו תתחברו מאפליקציית Android.

1. מתחברים למסוף Firebase.
2. לוחצים על הוספת פרויקט, ואז בוחרים או מקלידים שם פרויקט. נותנים לפרויקט את השם fcm-codelab.
3. לוחצים על המשך.
4. אפשר לדלג על ההגדרה של Google Analytics על ידי השבתת הלחצן Enable Google Analytics for this project (הפעלת Google Analytics בפרויקט הזה).
5. לוחצים על יצירת פרויקט כדי לסיים את ההגדרה של פרויקט Firebase.

שלב 2: רישום האפליקציה ב-Firebase

עכשיו, כשיש לכם פרויקט Firebase, אתם יכולים להוסיף אליו את אפליקציית Android.

1. במרכז דף סקירת הפרויקט במסוף Firebase, לוחצים על סמל Android כדי להפעיל את תהליך ההגדרה.

2. בשדה Android package name מזינים את הערך com.example.android.eggtimernotifications.
3. לוחצים על רישום האפליקציה.

חשוב: צריך לוודא שמזינים את המזהה הנכון של האפליקציה, כי אי אפשר להוסיף או לשנות את הערך הזה אחרי שמבצעים רישום של האפליקציה בפרויקט Firebase.

שלב 3: מוסיפים את קובץ ההגדרות של Firebase לפרויקט

מוסיפים לאפליקציה את קובץ ההגדרות של Firebase Android.

1. לוחצים על Download google-services.json (הורדת google-services.json) כדי לקבל את קובץ התצורה של Firebase Android ‏(google-services.json). מוודאים שלא נוספו לקובץ התצורה תווים נוספים וששמו הוא בדיוק google-services.json.
2. מעבירים את קובץ ההגדרות לתיקיית המודול (ברמת האפליקציה) של האפליקציה.

טיפ: אתם יכולים להוריד שוב את קובץ התצורה של Firebase ל-Android בכל שלב.

שלב 4: הגדרת פרויקט Android כדי להפעיל מוצרים של Firebase

כדי להפעיל מוצרים של Firebase באפליקציה, צריך להוסיף את הפלאגין google-services לקובצי Gradle.

1. בקובץ Gradle ברמת השורש (ברמת הפרויקט) (build.gradle), בודקים שיש לכם את מאגר Maven של Google.
2. לאחר מכן, מוסיפים כללים שיכללו את הפלאגין Google Services.

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. בקובץ Gradle של המודול (ברמת האפליקציה) (בדרך כלל app/build.gradle), מוסיפים שורה להחלת הפלאגין בתחתית הקובץ.

‫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

במשימה הזו תוסיפו את Firebase Cloud Messaging ‏ (FCM) לפרויקט כדי להשתמש בהתראות פוש.

קוד השירות של Android ל-FCM ב-Codelab הזה מופיע בMyFirebaseMessagingService.kt. בשלבים הבאים תוסיפו קוד לאפליקציית Android.

תשתמשו בכלי ליצירת התראות כדי לבדוק את ההטמעה. מחבר ההודעות הוא כלי שעוזר לכם לכתוב ולשלוח הודעות מאתר Firebase Console.

1. פתיחה של MyFirebaseMessagingService.kt
2. בודקים את הקובץ, ובמיוחד את הפונקציות הבאות:

• onNewToken()– מופעלת אוטומטית אם השירות רשום במניפסט של Android. הפונקציה הזו מופעלת כשמריצים את האפליקציה בפעם הראשונה, ובכל פעם ש-Firebase מנפיק אסימון חדש לאפליקציה. אסימון הוא מפתח גישה לפרויקט העורפי של Firebase. הוא נוצר עבור מכשיר הלקוח הספציפי שלכם. באמצעות הטוקן הזה, Firebase יודע לאיזה לקוח הקצה העורפי צריך לשלוח הודעות. מערכת Firebase גם יודעת אם הלקוח הזה תקף ויש לו גישה לפרויקט הזה ב-Firebase.
• ‫onMessageReceived – מופעלת כשהאפליקציה פועלת ו-Firebase שולחת הודעה לאפליקציה. הפונקציה הזו מקבלת אובייקט RemoteMessage שיכול להכיל מטען ייעודי (payload) של הודעה או של נתונים. בהמשך ה-codelab הזה נסביר יותר על ההבדלים בין התראות לבין מטען ייעודי (payload) של הודעות נתונים.

שלב 1: שליחת התראות FCM למכשיר יחיד

מסוף ההתראות מאפשר לכם לבדוק את שליחת ההתראה. כדי לשלוח הודעה למכשיר ספציפי באמצעות המסוף, צריך לדעת את טוקן הרישום של המכשיר.

כששרת הקצה העורפי של Firebase יוצר טוקן חדש או מרענן טוקן קיים, המערכת קוראת לפונקציה onNewToken() ומעבירה את הטוקן החדש כארגומנט. אם רוצים לטרגט מכשיר יחיד או ליצור קבוצת מכשירים שאליהם רוצים לשלוח הודעה לשידור, צריך לגשת לטוקן הזה על ידי הרחבת FirebaseMessagingService וביטול ברירת המחדל של onNewToken().

1. פותחים את AndroidManifest.xml ומבטלים את ההערה בקוד הבא כדי להפעיל את MyFirebaseMessagingService באפליקציית שעון העצר. המטא-נתונים של השירות במניפסט של Android רושמים את MyFirebaseMessagingService כשירות ומוסיפים מסנן של כוונות כדי שהשירות הזה יקבל הודעות שנשלחות מ-FCM. החלק האחרון של המטא-נתונים מגדיר את breakfast_notification_channel_id כ-default_notification_channel_id עבור Firebase. תצטרכו להשתמש במזהה הזה בשלב הבא.

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

מומלץ ליצור ערוץ התראות חדש עבור FCM, כי יכול להיות שהמשתמשים ירצו להפעיל או להשבית בנפרד את ההתראות על סיום הבישול או את ההתראות של FCM.

2. פותחים את ui/EggTimerFragment.kt . ב-onCreateView(), מוסיפים את הקוד הבא ליצירת ערוץ.

// 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. פותחים את MyFirebaseMessagingService.kt ומבטלים את ההערה של הפונקציה onNewToken(). המערכת תקרא לפונקציה הזו כשייווצר טוקן חדש.

// 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. מפעילים את אפליקציית הטיימר לביצים.
5. צופים ב-logcat (View > Tool Windows > Logcat). אמורה להופיע שורה ביומן שבה מוצג האסימון, בדומה לזו שבהמשך. זה האסימון שצריך כדי לשלוח הודעה למכשיר הזה. הפונקציה הזו מופעלת רק כשנוצר טוקן חדש.

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

הערה: אם לא רואים את האסימון בהודעות logcat, יכול להיות שהאפליקציה כבר קיבלה את האסימון בעבר. במקרה כזה, הסרת האפליקציה תעזור לכם לקבל אסימון חדש.

הערה: אם יש לכם פרויקט נפרד של קצה עורפי, אתם יכולים לאחסן את אסימון הלקוח הזה כדי לשלוח הודעות פרטניות ללקוח. במקרה כזה, צריך להתקשר לשרת העורפי כדי לשמור את האסימון הזה מיד אחרי שמקבלים אסימון חדש. השירות לקצה העורפי יכול להיות ב-Firebase או בכל שירות אחר לקצה העורפי. בקוד לדוגמה, יש פונקציה ריקה בשם sendRegistrationToServer() שמופעלת אחרי קבלת אסימון חדש. אפשר להשתמש בפונקציה הזו כדי לשלוח את האסימון הזה אל העורף (backend) שתבחרו.

עכשיו אפשר לשלוח התראה כדי לבדוק את ההגדרה. כדי לשלוח התראה, משתמשים בכלי ליצירת התראות.

4. פותחים את מסוף Firebase ובוחרים את הפרויקט הרלוונטי.
5. בתפריט הניווט הימני, בוחרים באפשרות Cloud Messaging.
6. לוחצים על שליחת ההודעה הראשונה.

5. מזינים Time for Breakfast! ככותרת ההתראה ו-Don't forget to eat eggs! כטקסט ההתראה, ולוחצים על שליחת הודעת בדיקה. מופיעה תיבת הדו-שיח הקופצת Test on device (בדיקה במכשיר), שבה מתבקשים לספק אסימון רישום של FCM.

6. מעתיקים את אסימון האפליקציה מ-logcat.

7. מדביקים את הטוקן בשדה Add an FCM registration token (הוספת טוקן רישום של FCM) בחלון הקופץ, ואז לוחצים על הלחצן Add (הוספה) לצד הטוקן.
8. ברשימת תיבות הסימון שמופיעה, בוחרים את האסימון. הלחצן בדיקה אמור להיות זמין.

9. במכשיר, מעבירים את אפליקציית שעון העצר לרקע .
10. בחלון הקופץ, לוחצים על בדיקה.

6. אחרי שלוחצים על בדיקה, מכשיר הלקוח שמטרגט את האפליקציה שלכם ושהאפליקציה פועלת בו ברקע אמור לקבל את ההתראה במגש ההתראות של המערכת. (בהמשך נסביר איך לטפל בהודעות FCM כשהאפליקציה פועלת בחזית).

משימה: שליחת התראות FCM לנושא

העברת הודעות בנושאים ב-FCM מבוססת על מודל פרסום/הרשמה.

אפליקציית הודעות יכולה להיות דוגמה טובה למודל פרסום/הרשמה. נניח שאפליקציה בודקת אם יש הודעות חדשות כל 10 שניות. הפעולה הזו לא רק תרוקן את הסוללה של הטלפון, אלא גם תשתמש במשאבי רשת מיותרים ותיצור עומס מיותר על השרת של האפליקציה. במקום זאת, מכשיר לקוח יכול להירשם ולקבל התראה כשמתקבלות הודעות חדשות דרך האפליקציה.

נושאים מאפשרים לכם לשלוח הודעה לכמה מכשירים שהמשתמשים שלהם הצטרפו לנושא הספציפי הזה. עבור לקוחות, נושאים הם מקורות נתונים ספציפיים שהלקוח מתעניין בהם. בשרת, נושאים הם קבוצות של מכשירים שהביעו הסכמה לקבל עדכונים לגבי מקור נתונים ספציפי. אפשר להשתמש בנושאים כדי להציג קטגוריות של התראות, כמו חדשות, תחזיות מזג אוויר ותוצאות של משחקי ספורט. בחלק הזה של ה-codelab, תיצרו נושא בשם 'ארוחת בוקר' כדי להזכיר למשתמשים באפליקציה שמתעניינים בנושא לאכול ביצים בארוחת הבוקר.

כדי להירשם לנושא, אפליקציית הלקוח קוראת לפונקציה subscribeToTopic() של העברת הודעות בענן ב-Firebase עם שם הנושא breakfast. יכולות להיות שתי תוצאות לשיחה הזו. אם המתקשר יצליח, המערכת תקרא לקריאה החוזרת OnCompleteListener עם ההודעה שנרשמת. אם הלקוח לא מצליח להירשם, פונקציית הקריאה החוזרת תקבל הודעת שגיאה במקום זאת.

באפליקציה, המשתמשים יירשמו אוטומטית לנושא ארוחת הבוקר. עם זאת, ברוב האפליקציות שמופעלות בייצור, עדיף לתת למשתמשים שליטה בנושאים שהם רוצים להירשם אליהם.

1. פותחים את EggTimerFragment.kt ומחפשים את הפונקציה הריקה subscribeTopic().
2. מקבלים מופע של FirebaseMessaging ומפעילים את הפונקציה subscibeToTopic() עם שם הנושא.
3. מוסיפים addOnCompleteListener כדי לקבל מ-FCM הודעה על הצלחה או כישלון של ההרשמה.

// 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. קוראים לפונקציה subscribeTopic() כדי להירשם לנושא כשהאפליקציה מתחילה. גוללים למעלה אל onCreateView() ומוסיפים שיחה אל subscribeTopic().

// EggTimerFragment.kt

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

    return binding.root

3. כדי להירשם לנושא 'ארוחת בוקר', מפעילים שוב את האפליקציה. אמורה להופיע הודעה קצרה שכתוב בה 'נרשמת לנושא'.

עכשיו אפשר לבדוק את שליחת ההודעות לנושא:

1. פותחים את הכלי ליצירת התראות ובוחרים באפשרות יצירת התראה.
2. מגדירים את כותרת ההתראה ואת טקסט ההתראה כמו קודם.
3. הפעם, במקום לשלוח את ההודעה למכשיר אחד, לוחצים על נושא בקטע יעד ומזינים breakfast כנושא ההודעה.

4. בוחרים באפשרות עכשיו לתזמון.

5. מוודאים שהאפליקציה פועלת ברקע במכשיר הבדיקה.

6. לוחצים על בדיקה ואז על פרסום. אם אפשר להריץ את האפליקציה ביותר ממכשיר אחד, אפשר לבדוק ולראות שההתראה מתקבלת בכל המכשירים שרשומים לנושא הזה.

באפליקציה יש עכשיו את הערוצים הבאים להתראות: Egg ו-Breakfast. במכשיר הלקוח, לוחצים לחיצה ארוכה על סמל האפליקציה, בוחרים באפשרות מידע ולוחצים על התראות. אמורים להופיע ערוצי ההתראות Egg ו-Breakfast, כמו בצילום המסך הבא. אם מבטלים את הבחירה בערוץ Breakfast, האפליקציה לא תקבל התראות שנשלחות בערוץ הזה.

כשמשתמשים בהתראות, חשוב לזכור שהמשתמשים יכולים להשבית כל ערוץ התראות בכל שלב.

שלב 1: הודעות נתונים

הודעות FCM יכולות להכיל גם מטען נתונים שמעבד את ההודעות באפליקציית הלקוח. במקרה כזה, צריך להשתמש בהודעות נתונים במקום בהודעות התראה.

כדי לטפל בהודעות נתונים, צריך לטפל במטען הנתונים בפונקציה onMessageReceived() של MyFirebaseMessagingService. המטען הייעודי (Payload) מאוחסן במאפיין data של האובייקט remoteMessage. גם האובייקט remoteMessage וגם המאפיין data יכולים להיות null.

1. פתיחה של MyFirebaseMessagingService.
2. בודקים אם למאפיין data של האובייקט remoteMessage יש ערך כלשהו ומדפיסים את הנתונים ביומן.

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

כדי לבדוק את הקוד, אפשר להשתמש שוב בכלי ליצירת התראות.

1. פותחים את הכלי ליצירת התראות, יוצרים הודעה חדשה ומגדירים את היעד שלה לנושא 'ארוחת בוקר'.
2. בפעם הזו, כשמגיעים לשלב 4, אפשרויות נוספות, מגדירים את מאפייני המפתח והערך של נתונים מותאמים אישית באופן הבא:

1. מפתח: eggs
2. ערך: 3

3. מוודאים שהאפליקציה פועלת בחזית. אם האפליקציה פועלת ברקע, הודעת ה-FCM תפעיל התראה אוטומטית והפונקציה onMessageReceived() תקבל רק את האובייקט remoteMessage כשהמשתמש ילחץ על ההתראה.
4. שולחים את ההודעה ממאגר ההודעות, ומתבוננים ביומן של הודעת הנתונים שמופיע ב-logcat.

הערה: גודל המטען הייעודי (payload) המקסימלי לשני סוגי ההודעות הוא 4KB (אלא אם שולחים הודעות ממסוף Firebase, שבו יש מגבלה של 1,024 תווים).

שלב 2: טיפול בהודעות בחזית וברקע

כשמכשיר לקוח שבו פועלת האפליקציה מקבל הודעה שכוללת גם מטען ייעודי (payload) של נתונים וגם מטען ייעודי של התראה, אופן הפעולה של האפליקציה תלוי בשאלה אם האפליקציה פועלת ברקע או בחזית במכשיר הזה:

• אם האפליקציה פועלת ברקע, ואם ההודעה כוללת מטען ייעודי (payload) של התראה, ההתראה מוצגת אוטומטית במגש ההתראות. אם ההודעה כוללת גם מטען ייעודי (payload) של נתונים, המטען הייעודי הזה יטופל על ידי האפליקציה כשהמשתמש יקיש על ההתראה.
• אם האפליקציה פועלת בחזית, אם להתראה על ההודעה יש מטען ייעודי (payload) של התראה, ההתראה לא תופיע באופן אוטומטי. האפליקציה צריכה להחליט איך לטפל בהתראה בפונקציה onMessageReceived(). אם ההודעה כוללת גם מטען נתונים, האפליקציה תטפל בשני סוגי המטען.

לצורך ה-codelab הזה, אתם רוצים להזכיר למשתמש באפליקציה לאכול ביצים לארוחת בוקר. אתם לא מתכננים לשלוח נתונים, אבל אתם רוצים לוודא שהתזכורת תמיד תופיע, בין אם האפליקציה בחזית או ברקע.

כששולחים הודעה ב-FCM למכשירים שבהם מותקנת אפליקציית שעון העצר, הודעת ההתראה תוצג באופן אוטומטי אם האפליקציה לא פועלת או פועלת ברקע. עם זאת, אם האפליקציה פועלת בחזית, ההתראה לא מוצגת באופן אוטומטי. במקום זאת, הקוד של האפליקציה קובע מה לעשות עם ההודעה. אם האפליקציה בחזית כשהיא מקבלת הודעת FCM, הפונקציה onMessageReceived() תופעל אוטומטית עם הודעת ה-FCM. כאן האפליקציה יכולה לטפל בהתראות ובמטענים של נתונים באופן שקט או להפעיל התראה.

באפליקציה שלכם, אתם רוצים לוודא שהמשתמש יקבל את התזכורת כשהאפליקציה פועלת בחזית, אז בואו נטמיע קוד שיפעיל התראה:

1. פותחים שוב את הפונקציה onMessageReceived() ב-MyFirebaseMessagingService.
2. מיד אחרי הקוד שהוספתם לאחרונה כדי לבדוק את הודעת הנתונים, מוסיפים את הקוד הבא ששולח התראה באמצעות מסגרת ההתראות.

// 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. אם מריצים את האפליקציה שוב ושולחים התראה באמצעות הכלי ליצירת התראות, אמורה להתקבל התראה בדיוק כמו שהתקבלה בחלק הראשון של ה-codelab, בלי קשר לשאלה אם האפליקציה פועלת בחזית או ברקע.

קוד הפתרון נמצא בענף הראשי של הקוד שהורדתם.

• מטמיעים FCM BroadcastReceiver על ידי הרחבת FirebaseMessagingService.
• מגדירים פרויקט של העברת הודעות בענן ב-Firebase ‏ (FCM) ומוסיפים את FCM לאפליקציית Android.
• בודקים את האפליקציה על ידי שליחת התראות בדחיפה מכלי ההתראות.
• כדי להירשם לנושאים ב-FCM, קוראים לפונקציה subscribeToTopic() של המחלקה FirebaseMessaging.
• שליחת מטען ייעודי (payload) של נתונים באמצעות אובייקט RemoteMessage.
• טיפול בנתונים בפונקציה onMessageReceived().
• מוסיפים לוגיקה לטיפול ב-FCM כשהאפליקציה בחזית וכשהיא ברקע.

קורס ב-Udacity:

• פיתוח אפליקציות ל-Android באמצעות Kotlin

מאמרי עזרה של Firebase:

• העברת הודעות בענן ב-Firebase
• מסוף Firebase
• הורדת קובץ התצורה של Firebase Android
• FirebaseMessagingService
• RemoteMessage
• שליחת הודעות באמצעות מסוף Firebase
• הרשמה של אפליקציית הלקוח לנושא

קישורים למדריכי Codelab נוספים בקורס הזה מופיעים בדף הנחיתה של מדריכי Codelab בנושא Android מתקדם ב-Kotlin.