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

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

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

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

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

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

אינטרנט v8

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

אינטרנט v9

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
מָהִיר
let settings = FirestoreSettings()
settings.isPersistenceEnabled = true

// Any additional options
// ...

// Enable offline data persistence
let db = Firestore.firestore()
db.settings = settings
מטרה-ג
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);

Kotlin + KTX

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

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

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

אינטרנט v8

firebase.firestore().settings({
    cacheSizeBytes: firebase.firestore.CACHE_SIZE_UNLIMITED
});

אינטרנט v9

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

const firestoreDb = initializeFirestore(app, {
  cacheSizeBytes: 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
מטרה-ג
// 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);

Kotlin + 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 להקשיב אפשרות כאשר אתה מצרף המטפל מקשיב שלך.

אינטרנט v8

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);
      });
  });

אינטרנט v9

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);
    });
});
מָהִיר
// 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)")
}
מטרה-ג
// 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);
                }

            }
        });

Kotlin + 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")
            }
        }

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

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

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

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

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

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

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

אינטרנט v8

firebase.firestore().disableNetwork()
    .then(() => {
        // Do offline actions
        // ...
    });

אינטרנט v9

import { disableNetwork } from "firebase/firestore"; 

await disableNetwork(db);
console.log("Network disabled!");
// Do offline actions
// ...
מָהִיר
Firestore.firestore().disableNetwork { (error) in
    // Do offline things
    // ...
}
מטרה-ג
[[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
                // ...
            }
        });

Kotlin + KTX

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

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

אינטרנט v8

firebase.firestore().enableNetwork()
    .then(() => {
        // Do online actions
        // ...
    });

אינטרנט v9

import { enableNetwork } from "firebase/firestore"; 

await enableNetwork(db);
// Do online actions
// ...
מָהִיר
Firestore.firestore().enableNetwork { (error) in
    // Do online things
    // ...
}
מטרה-ג
[[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
                // ...
            }
        });

Kotlin + KTX

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