Android מתקדם ב-Kotlin 01.2: העברת הודעות בענן ב-Android Firebase

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

מבוא

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

מהי התראה?

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

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

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

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

מה זה Firebase Cloud Messaging?

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

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

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

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

דברים שחשוב לדעת

כדאי שתכירו את:

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

מה תלמדו

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

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

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

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

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

משכפלים את המאגר מ-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. לוחצים על Continue.
  4. אפשר לדלג על הגדרת Google Analytics באמצעות השבתה של הלחצן הפעלת Google Analytics לפרויקט הזה.
  5. לוחצים על יצירת פרויקט כדי לסיים את ההגדרה של פרויקט Firebase.

שלב 2: רושמים את האפליקציה באמצעות Firebase

אחרי שיוצרים פרויקט ב-Firebase, אפשר להוסיף אליו את האפליקציה ל-Android.

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

  1. בשדה שם החבילה ל-Android, מזינים com.example.android.eggtimernotifications.
  2. לוחצים על רישום אפליקציה.

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

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

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

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

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

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

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

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

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

  1. פתיחה של MyFirebaseMessagingService.kt
  2. בודקים את הקובץ, ובמיוחד את הפונקציות הבאות:
  • onNewToken()—השיחה תבוצע באופן אוטומטי אם השירות רשום בקובץ המניפסט של Android. הפונקציה הזו מופעלת בפעם הראשונה שאתם מפעילים את האפליקציה ובכל פעם ש-Firebase מנפיקה אסימון חדש לאפליקציה שלכם. אסימון הוא מפתח גישה לפרויקט קצה עורפי ב-Firebase. הוא נוצר עבור מכשיר הלקוח הספציפי שלכם. באמצעות האסימון הזה, Firebase יודע לאיזה לקוח הקצה העורפי צריך לשלוח הודעות. אנחנו גם יודעים אם הלקוח הזה חוקי ושיש לו גישה לפרויקט Firebase הזה.
  • onMessageReceived— שיחה זו מופעלת כשהאפליקציה שלך פועלת ו-Firebase שולחת הודעה לאפליקציה שלך. הפונקציה הזו מקבלת אובייקט RemoteMessage, שיכול לכלול התראה או מטען ייעודי של הודעות נתונים. מידע נוסף על ההבדלים בין התראות לבין מטענים ייעודיים (payload) של הודעות נתונים מתבצע ב-Codelab הזה.

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

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

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

  1. צריך לפתוח את AndroidManifest.xml ולבטל את הוספת הקוד הבא כדי להפעיל את MyFirebaseMessagingService לאפליקציית טיימר הביצים. המטא-נתונים של השירות במניפסט של Android רושמים את MyFirebaseMessagingService כשירות ומוסיפים מסנן Intent כדי שהשירות יקבל הודעות שנשלחו מ-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 בנפרד.

  1. פותחים את 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)
    )
  1. יש לפתוח את 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]
  1. מריצים את אפליקציית הטיימר לביצים.
  2. בודקים את 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

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

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

  1. פותחים את Firebase Console ובוחרים את הפרויקט שלכם.
  2. לאחר מכן בוחרים באפשרות העברת הודעות בענן בתפריט הניווט שמימין.
  3. לוחצים על שליחת ההודעה הראשונה.

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

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

  1. מדביקים את האסימון בשדה הוספת אסימון רישום FCM בחלון הקופץ, ואז לוחצים על הלחצן הוספה לצד האסימון.
  2. ברשימת תיבות הסימון שמופיעה, בוחרים את האסימון. הלחצן בדיקה צריך להיות מופעל.

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

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

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

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

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

כדי להירשם לנושא מסוים, אפליקציית הלקוח מתקשרת לפונקציה של העברת הודעות בענן ב-Firebase subscribeToTopic() עם שם הנושא 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]
    }
  1. צריך להפעיל את הפונקציה subscribeTopic() כדי להירשם לנושא כשהאפליקציה מתחילה. יש לגלול למעלה עד onCreateView() ולהוסיף שיחה אל subscribeTopic().
// EggTimerFragment.kt

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

    return binding.root
  1. כדי להירשם לנושא של ארוחת הבוקר, מריצים שוב את האפליקציה. אתם אמורים לראות הודעה קופצת שבה כתוב "נרשמת לנושא;"

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

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

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

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

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

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

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

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

כדי לטפל בהודעות נתונים, צריך לטפל במטען הייעודי (payload) של הפונקציה onMessageReceived() של MyFirebaseMessagingService. המטען הייעודי מאוחסן בנכס 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. פותחים את מחבר ההודעות, יוצרים הודעה חדשה ומגדירים את היעד שלה לנושא "breakspeed"
  2. הפעם כשמגיעים לשלב 4, אפשרויות נוספות, מגדירים את המפתח ואת מאפייני הערך של נתונים מותאמים אישית באופן הבא:
  1. מפתח: eggs
  2. ערך: 3

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

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

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

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

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

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

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

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

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

קורס אוניברסיטה:

מסמכי התיעוד של Firebase:

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