דף זה תורגם על ידי Cloud Translation API.

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

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

התמדה בדיסק

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

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

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

Kotlin+KTX

Firebase.database.setPersistenceEnabled(true)OfflineActivity.kt

Java

FirebaseDatabase.getInstance().setPersistenceEnabled(true);OfflineActivity.java

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

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

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

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

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

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

Kotlin+KTX

val scoresRef = Firebase.database.getReference("scores")
scoresRef.keepSynced(true)OfflineActivity.kt

Java

DatabaseReference scoresRef = FirebaseDatabase.getInstance().getReference("scores");
scoresRef.keepSynced(true);OfflineActivity.java

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

Kotlin+KTX

scoresRef.keepSynced(false)OfflineActivity.kt

Java

scoresRef.keepSynced(false);OfflineActivity.java

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

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

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

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

Kotlin+KTX

val scoresRef = Firebase.database.getReference("scores")
scoresRef.orderByValue().limitToLast(4).addChildEventListener(object : ChildEventListener {
    override fun onChildAdded(snapshot: DataSnapshot, previousChild: String?) {
        Log.d(TAG, "The ${snapshot.key} dinosaur's score is ${snapshot.value}")
    }

    // ...
})OfflineActivity.kt

Java

DatabaseReference scoresRef = FirebaseDatabase.getInstance().getReference("scores");
scoresRef.orderByValue().limitToLast(4).addChildEventListener(new ChildEventListener() {
    @Override
    public void onChildAdded(@NonNull DataSnapshot snapshot, String previousChild) {
        Log.d(TAG, "The " + snapshot.getKey() + " dinosaur's score is " + snapshot.getValue());
    }

    // ...
});OfflineActivity.java

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

Kotlin+KTX

scoresRef.orderByValue().limitToLast(2).addChildEventListener(object : ChildEventListener {
    override fun onChildAdded(snapshot: DataSnapshot, previousChild: String?) {
        Log.d(TAG, "The ${snapshot.key} dinosaur's score is ${snapshot.value}")
    }

    // ...
})OfflineActivity.kt

Java

scoresRef.orderByValue().limitToLast(2).addChildEventListener(new ChildEventListener() {
    @Override
    public void onChildAdded(@NonNull DataSnapshot snapshot, String previousChild) {
        Log.d(TAG, "The " + snapshot.getKey() + " dinosaur's score is " + snapshot.getValue());
    }

    // ...
});OfflineActivity.java

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

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

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

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

ניהול נוכחות

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

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

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

Kotlin+KTX

val presenceRef = Firebase.database.getReference("disconnectmessage")
// Write a string when this client loses connection
presenceRef.onDisconnect().setValue("I disconnected!")OfflineActivity.kt

Java

DatabaseReference presenceRef = FirebaseDatabase.getInstance().getReference("disconnectmessage");
// Write a string when this client loses connection
presenceRef.onDisconnect().setValue("I disconnected!");OfflineActivity.java

איך onDisconnect עובד

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

האפליקציה שלך יכולה להשתמש בהתקשרות חוזרת בפעולת הכתיבה כדי לוודא שה- onDisconnect צורף כהלכה:

Kotlin+KTX

presenceRef.onDisconnect().removeValue { error, reference ->
    error?.let {
        Log.d(TAG, "could not establish onDisconnect event: ${error.message}")
    }
}OfflineActivity.kt

Java

presenceRef.onDisconnect().removeValue(new DatabaseReference.CompletionListener() {
    @Override
    public void onComplete(DatabaseError error, @NonNull DatabaseReference reference) {
        if (error != null) {
            Log.d(TAG, "could not establish onDisconnect event:" + error.getMessage());
        }
    }
});OfflineActivity.java

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

Kotlin+KTX

val onDisconnectRef = presenceRef.onDisconnect()
onDisconnectRef.setValue("I disconnected")
// ...
// some time later when we change our minds
// ...
onDisconnectRef.cancel()OfflineActivity.kt

Java

OnDisconnect onDisconnectRef = presenceRef.onDisconnect();
onDisconnectRef.setValue("I disconnected");
// ...
// some time later when we change our minds
// ...
onDisconnectRef.cancel();OfflineActivity.java

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

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

Kotlin+KTX

val connectedRef = Firebase.database.getReference(".info/connected")
connectedRef.addValueEventListener(object : ValueEventListener {
    override fun onDataChange(snapshot: DataSnapshot) {
        val connected = snapshot.getValue(Boolean::class.java) ?: false
        if (connected) {
            Log.d(TAG, "connected")
        } else {
            Log.d(TAG, "not connected")
        }
    }

    override fun onCancelled(error: DatabaseError) {
        Log.w(TAG, "Listener was cancelled")
    }
})OfflineActivity.kt

Java

DatabaseReference connectedRef = FirebaseDatabase.getInstance().getReference(".info/connected");
connectedRef.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(@NonNull DataSnapshot snapshot) {
        boolean connected = snapshot.getValue(Boolean.class);
        if (connected) {
            Log.d(TAG, "connected");
        } else {
            Log.d(TAG, "not connected");
        }
    }

    @Override
    public void onCancelled(@NonNull DatabaseError error) {
        Log.w(TAG, "Listener was cancelled");
    }
});OfflineActivity.java

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

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

טיפול ב-Latency

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

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

Kotlin+KTX

val userLastOnlineRef = Firebase.database.getReference("users/joe/lastOnline")
userLastOnlineRef.onDisconnect().setValue(ServerValue.TIMESTAMP)OfflineActivity.kt

Java

DatabaseReference userLastOnlineRef = FirebaseDatabase.getInstance().getReference("users/joe/lastOnline");
userLastOnlineRef.onDisconnect().setValue(ServerValue.TIMESTAMP);OfflineActivity.java

להטות שעון

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

Kotlin+KTX

val offsetRef = Firebase.database.getReference(".info/serverTimeOffset")
offsetRef.addValueEventListener(object : ValueEventListener {
    override fun onDataChange(snapshot: DataSnapshot) {
        val offset = snapshot.getValue(Double::class.java) ?: 0.0
        val estimatedServerTimeMs = System.currentTimeMillis() + offset
    }

    override fun onCancelled(error: DatabaseError) {
        Log.w(TAG, "Listener was cancelled")
    }
})OfflineActivity.kt

Java

DatabaseReference offsetRef = FirebaseDatabase.getInstance().getReference(".info/serverTimeOffset");
offsetRef.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(@NonNull DataSnapshot snapshot) {
        double offset = snapshot.getValue(Double.class);
        double estimatedServerTimeMs = System.currentTimeMillis() + offset;
    }

    @Override
    public void onCancelled(@NonNull DatabaseError error) {
        Log.w(TAG, "Listener was cancelled");
    }
});OfflineActivity.java

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

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

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

הנה מערכת נוכחות משתמש פשוטה:

Kotlin+KTX

// 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
val database = Firebase.database
val myConnectionsRef = database.getReference("users/joe/connections")

// Stores the timestamp of my last disconnect (the last time I was seen online)
val lastOnlineRef = database.getReference("/users/joe/lastOnline")

val connectedRef = database.getReference(".info/connected")
connectedRef.addValueEventListener(object : ValueEventListener {
    override fun onDataChange(snapshot: DataSnapshot) {
        val connected = snapshot.getValue<Boolean>() ?: false
        if (connected) {
            val con = myConnectionsRef.push()

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

            // When I disconnect, update the last time I was seen online
            lastOnlineRef.onDisconnect().setValue(ServerValue.TIMESTAMP)

            // Add this device to my connections list
            // this value could contain info about the device or a timestamp too
            con.setValue(java.lang.Boolean.TRUE)
        }
    }

    override fun onCancelled(error: DatabaseError) {
        Log.w(TAG, "Listener was cancelled at .info/connected")
    }
})OfflineActivity.kt

Java

// 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 FirebaseDatabase database = FirebaseDatabase.getInstance();
final DatabaseReference myConnectionsRef = database.getReference("users/joe/connections");

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

final DatabaseReference connectedRef = database.getReference(".info/connected");
connectedRef.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(@NonNull DataSnapshot snapshot) {
        boolean connected = snapshot.getValue(Boolean.class);
        if (connected) {
            DatabaseReference con = myConnectionsRef.push();

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

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

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

    @Override
    public void onCancelled(@NonNull DatabaseError error) {
        Log.w(TAG, "Listener was cancelled at .info/connected");
    }
});OfflineActivity.java