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

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

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

הגדר התמדה לא מקוונת

בעת אתחול Cloud Firestore, תוכל להפעיל או להשבית התמדה לא מקוונת:

  • עבור Android ו- iOS, התמדה לא מקוונת מופעלת כברירת מחדל. כדי התמדה להשבית, להגדיר את PersistenceEnabled אפשרות false .
  • עבור האינטרנט, ההתמדה הלא מקוונת מושבתת כברירת מחדל. כדי לאפשר התמדה, לקרוא enablePersistence השיטה. המטמון של Cloud Firestore אינו מוסר אוטומטית בין ההפעלות. כתוצאה מכך, אם אפליקציית האינטרנט שלך מטפלת במידע רגיש, הקפד לשאול את המשתמש אם הוא נמצא במכשיר מהימן לפני שתאפשר התמדה.

גרסת אינטרנט 9

import { enableIndexedDbPersistence } from "firebase/firestore"; 

enableIndexedDbPersistence(db)
  .catch((err) => {
      if (err.code == 'failed-precondition') {
          // Multiple tabs open, persistence can only be enabled
          // in one tab at a a time.
          // ...
      } else if (err.code == 'unimplemented') {
          // The current browser does not support all of the
          // features required to enable persistence
          // ...
      }
  });
// Subsequent queries will use persistence, if it was enabled successfully

גרסת אינטרנט 8

firebase.firestore().enablePersistence()
  .catch((err) => {
      if (err.code == 'failed-precondition') {
          // Multiple tabs open, persistence can only be enabled
          // in one tab at a a time.
          // ...
      } else if (err.code == 'unimplemented') {
          // The current browser does not support all of the
          // features required to enable persistence
          // ...
      }
  });
// Subsequent queries will use persistence, if it was enabled successfully
מָהִיר
let settings = FirestoreSettings()
settings.isPersistenceEnabled = true

// Any additional options
// ...

// Enable offline data persistence
let db = Firestore.firestore()
db.settings = settings
Objective-C
FIRFirestoreSettings *settings = [[FIRFirestoreSettings alloc] init];
settings.persistenceEnabled = YES;

// Any additional options
// ...

// Enable offline data persistence
FIRFirestore *db = [FIRFirestore firestore];
db.settings = settings;

ג'אווה

FirebaseFirestoreSettings settings = new FirebaseFirestoreSettings.Builder()
        .setPersistenceEnabled(true)
        .build();
db.setFirestoreSettings(settings);

קוטלין+KTX

val settings = firestoreSettings {
    isPersistenceEnabled = true
}
db.firestoreSettings = settings

הגדר את גודל המטמון

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

גרסת אינטרנט 9

import { initializeFirestore, CACHE_SIZE_UNLIMITED } from "firebase/firestore";

const firestoreDb = initializeFirestore(app, {
  cacheSizeBytes: CACHE_SIZE_UNLIMITED
});

גרסת אינטרנט 8

firebase.firestore().settings({
    cacheSizeBytes: firebase.firestore.CACHE_SIZE_UNLIMITED
});
מָהִיר
// The default cache size threshold is 100 MB. Configure "cacheSizeBytes"
// for a different threshold (minimum 1 MB) or set to "FirestoreCacheSizeUnlimited"
// to disable clean-up.
let settings = Firestore.firestore().settings
settings.cacheSizeBytes = FirestoreCacheSizeUnlimited
Firestore.firestore().settings = settings
Objective-C
// The default cache size threshold is 100 MB. Configure "cacheSizeBytes"
// for a different threshold (minimum 1 MB) or set to "kFIRFirestoreCacheSizeUnlimited"
// to disable clean-up.
FIRFirestoreSettings *settings = [FIRFirestore firestore].settings;
settings.cacheSizeBytes = kFIRFirestoreCacheSizeUnlimited;
[FIRFirestore firestore].settings = settings;
  

ג'אווה


// The default cache size threshold is 100 MB. Configure "setCacheSizeBytes"
// for a different threshold (minimum 1 MB) or set to "CACHE_SIZE_UNLIMITED"
// to disable clean-up.
FirebaseFirestoreSettings settings = new FirebaseFirestoreSettings.Builder()
        .setCacheSizeBytes(FirebaseFirestoreSettings.CACHE_SIZE_UNLIMITED)
        .build();
db.setFirestoreSettings(settings);

קוטלין+KTX


// The default cache size threshold is 100 MB. Configure "setCacheSizeBytes"
// for a different threshold (minimum 1 MB) or set to "CACHE_SIZE_UNLIMITED"
// to disable clean-up.
val settings = FirebaseFirestoreSettings.Builder()
        .setCacheSizeBytes(FirebaseFirestoreSettings.CACHE_SIZE_UNLIMITED)
        .build()
db.firestoreSettings = settings

האזן לנתונים לא מקוונים

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

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

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

גרסת אינטרנט 9

import { collection, onSnapshot, where, query } from "firebase/firestore"; 

const q = query(collection(db, "cities"), where("state", "==", "CA"));
onSnapshot(q, { includeMetadataChanges: true }, (snapshot) => {
    snapshot.docChanges().forEach((change) => {
        if (change.type === "added") {
            console.log("New city: ", change.doc.data());
        }

        const source = snapshot.metadata.fromCache ? "local cache" : "server";
        console.log("Data came from " + source);
    });
});

גרסת אינטרנט 8

db.collection("cities").where("state", "==", "CA")
  .onSnapshot({ includeMetadataChanges: true }, (snapshot) => {
      snapshot.docChanges().forEach((change) => {
          if (change.type === "added") {
              console.log("New city: ", change.doc.data());
          }

          var source = snapshot.metadata.fromCache ? "local cache" : "server";
          console.log("Data came from " + source);
      });
  });
מָהִיר
// Listen to metadata updates to receive a server snapshot even if
// the data is the same as the cached data.
db.collection("cities").whereField("state", isEqualTo: "CA")
    .addSnapshotListener(includeMetadataChanges: true) { querySnapshot, error in
        guard let snapshot = querySnapshot else {
            print("Error retreiving snapshot: \(error!)")
            return
        }

        for diff in snapshot.documentChanges {
            if diff.type == .added {
                print("New city: \(diff.document.data())")
            }
        }

        let source = snapshot.metadata.isFromCache ? "local cache" : "server"
        print("Metadata: Data fetched from \(source)")
}
Objective-C
// Listen to metadata updates to receive a server snapshot even if
// the data is the same as the cached data.
[[[db collectionWithPath:@"cities"] queryWhereField:@"state" isEqualTo:@"CA"]
    addSnapshotListenerWithIncludeMetadataChanges:YES
    listener:^(FIRQuerySnapshot *snapshot, NSError *error) {
      if (snapshot == nil) {
        NSLog(@"Error retreiving snapshot: %@", error);
        return;
      }
      for (FIRDocumentChange *diff in snapshot.documentChanges) {
        if (diff.type == FIRDocumentChangeTypeAdded) {
          NSLog(@"New city: %@", diff.document.data);
        }
      }

      NSString *source = snapshot.metadata.isFromCache ? @"local cache" : @"server";
      NSLog(@"Metadata: Data fetched from %@", source);
    }];

ג'אווה

db.collection("cities").whereEqualTo("state", "CA")
        .addSnapshotListener(MetadataChanges.INCLUDE, new EventListener<QuerySnapshot>() {
            @Override
            public void onEvent(@Nullable QuerySnapshot querySnapshot,
                                @Nullable FirebaseFirestoreException e) {
                if (e != null) {
                    Log.w(TAG, "Listen error", e);
                    return;
                }

                for (DocumentChange change : querySnapshot.getDocumentChanges()) {
                    if (change.getType() == Type.ADDED) {
                        Log.d(TAG, "New city:" + change.getDocument().getData());
                    }

                    String source = querySnapshot.getMetadata().isFromCache() ?
                            "local cache" : "server";
                    Log.d(TAG, "Data fetched from " + source);
                }

            }
        });

קוטלין+KTX

db.collection("cities").whereEqualTo("state", "CA")
        .addSnapshotListener(MetadataChanges.INCLUDE) { querySnapshot, e ->
            if (e != null) {
                Log.w(TAG, "Listen error", e)
                return@addSnapshotListener
            }

            for (change in querySnapshot!!.documentChanges) {
                if (change.type == DocumentChange.Type.ADDED) {
                    Log.d(TAG, "New city: ${change.document.data}")
                }

                val source = if (querySnapshot.metadata.isFromCache)
                    "local cache"
                else
                    "server"
                Log.d(TAG, "Data fetched from $source")
            }
        }

קבל נתונים לא מקוונים

אם אתה מקבל מסמך כשהמכשיר במצב לא מקוון, Cloud Firestore מחזיר נתונים מהמטמון.

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

שאילת נתונים לא מקוונים

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

השבת והפעל גישה לרשת

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

גרסת אינטרנט 9

import { disableNetwork } from "firebase/firestore"; 

await disableNetwork(db);
console.log("Network disabled!");
// Do offline actions
// ...

גרסת אינטרנט 8

firebase.firestore().disableNetwork()
    .then(() => {
        // Do offline actions
        // ...
    });
מָהִיר
Firestore.firestore().disableNetwork { (error) in
    // Do offline things
    // ...
}
Objective-C
[[FIRFirestore firestore] disableNetworkWithCompletion:^(NSError *_Nullable error) {
  // Do offline actions
  // ...
}];

ג'אווה

db.disableNetwork()
        .addOnCompleteListener(new OnCompleteListener<Void>() {
            @Override
            public void onComplete(@NonNull Task<Void> task) {
                // Do offline things
                // ...
            }
        });

קוטלין+KTX

db.disableNetwork().addOnCompleteListener {
    // Do offline things
    // ...
}

השתמש בשיטה הבאה להפעלת גישה מחדש לרשת:

גרסת אינטרנט 9

import { enableNetwork } from "firebase/firestore"; 

await enableNetwork(db);
// Do online actions
// ...

גרסת אינטרנט 8

firebase.firestore().enableNetwork()
    .then(() => {
        // Do online actions
        // ...
    });
מָהִיר
Firestore.firestore().enableNetwork { (error) in
    // Do online things
    // ...
}
Objective-C
[[FIRFirestore firestore] enableNetworkWithCompletion:^(NSError *_Nullable error) {
  // Do online actions
  // ...
}];

ג'אווה

db.enableNetwork()
        .addOnCompleteListener(new OnCompleteListener<Void>() {
            @Override
            public void onComplete(@NonNull Task<Void> task) {
                // Do online things
                // ...
            }
        });

קוטלין+KTX

db.enableNetwork().addOnCompleteListener {
    // Do online things
    // ...
}