הפעלת יכולות לא מקוונות

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

התמדה בדיסק

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

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

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

FirebaseDatabase.instance.setPersistenceEnabled(true);

התנהגות התמדה

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

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

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

שמירה על נתונים טריים

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

final scoresRef = FirebaseDatabase.instance.ref("scores");
scoresRef.keepSynced(true);

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

scoresRef.keepSynced(false);

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

שאילתת נתונים במצב לא מקוון

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

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

final scoresRef = FirebaseDatabase.instance.ref("scores");
scoresRef.orderByValue().limitToLast(4).onChildAdded.listen((event) {
  debugPrint("The ${event.snapshot.key} dinosaur's score is ${event.snapshot.value}.");
});

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

scoresRef.orderByValue().limitToLast(2).onChildAdded.listen((event) {
  debugPrint("The ${event.snapshot.key} dinosaur's score is ${event.snapshot.value}.");
});

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

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

טיפול בעסקאות במצב לא מקוון

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

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

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

ניהול נוכחות

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

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

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

final presenceRef = FirebaseDatabase.instance.ref("disconnectmessage");
// Write a string when this client loses connection
presenceRef.onDisconnect().set("I disconnected!");

איך onDisconnect עובד

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

try {
    await presenceRef.onDisconnect().remove();
} catch (error) {
    debugPrint("Could not establish onDisconnect event: $error");
}

ניתן לבטל אירוע onDisconnect גם על ידי קריאה .cancel() :

final onDisconnectRef = presenceRef.onDisconnect();
onDisconnectRef.set("I disconnected");
// ...
// some time later when we change our minds
// ...
onDisconnectRef.cancel();

זיהוי מצב חיבור

עבור תכונות רבות הקשורות לנוכחות, שימושי לאפליקציה שלך לדעת מתי היא מקוונת או לא מקוונת. Firebase Realtime Database מספק מיקום מיוחד בכתובת /.info/connected שמתעדכן בכל פעם שמצב החיבור של לקוח Firebase Realtime Database משתנה. הנה דוגמא:

final connectedRef = FirebaseDatabase.instance.ref(".info/connected");
connectedRef.onValue.listen((event) {
  final connected = event.snapshot.value as bool? ?? false;
  if (connected) {
    debugPrint("Connected.");
  } else {
    debugPrint("Not connected.");
  }
});

/.info/connected הוא ערך בוליאני שאינו מסונכרן בין לקוחות Realtime Database מכיוון שהערך תלוי במצב הלקוח. במילים אחרות, אם לקוח אחד קורא את /.info/connected כ-false, אין זה ערובה לכך שגם לקוח נפרד יקרא false.

טיפול ב-Latency

חותמות זמן של שרת

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

final userLastOnlineRef =
    FirebaseDatabase.instance.ref("users/joe/lastOnline");
userLastOnlineRef.onDisconnect().set(ServerValue.timestamp);

להטות שעון

בעוד ServerValue.timestamp הוא הרבה יותר מדויק, ועדיף עבור רוב פעולות הקריאה/כתיבה, זה יכול להיות שימושי מדי פעם להעריך את הטיית השעון של הלקוח ביחס לשרתי Firebase Realtime Database. אתה יכול לצרף התקשרות חזרה למיקום /.info/serverTimeOffset כדי לקבל את הערך, באלפיות שניות, שלקוחות Firebase Realtime Database מוסיפים לזמן המדווח המקומי (זמן עידן באלפיות שניות) כדי להעריך את זמן השרת. שימו לב שהדיוק של היסט זה יכול להיות מושפע מהשהייה ברשת, ולכן הוא שימושי בעיקר לגילוי אי התאמות גדולות (> שנייה אחת) בזמן השעון.

final offsetRef = FirebaseDatabase.instance.ref(".info/serverTimeOffset");
offsetRef.onValue.listen((event) {
  final offset = event.snapshot.value as num? ?? 0.0;
  final estimatedServerTimeMs =
      DateTime.now().millisecondsSinceEpoch + offset;
});

אפליקציית נוכחות לדוגמה

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

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

// Since I can connect from multiple devices, we store each connection
// instance separately any time that connectionsRef's value is null (i.e.
// has no children) I am offline.
final myConnectionsRef =
    FirebaseDatabase.instance.ref("users/joe/connections");

// Stores the timestamp of my last disconnect (the last time I was seen online)
final lastOnlineRef =
    FirebaseDatabase.instance.ref("/users/joe/lastOnline");

final connectedRef = FirebaseDatabase.instance.ref(".info/connected");
connectedRef.onValue.listen((event) {
  final connected = event.snapshot.value as bool? ?? false;
  if (connected) {
    final con = myConnectionsRef.push();

    // When this device disconnects, remove it.
    con.onDisconnect().remove();

    // When I disconnect, update the last time I was seen online.
    lastOnlineRef.onDisconnect().set(ServerValue.timestamp);

    // Add this device to my connections list.
    // This value could contain info about the device or a timestamp too.
    con.set(true);
  }
});