Cloud Firestore תומך בהתמדה של נתונים לא מקוונים. תכונה זו מאחסנת עותק של נתוני Cloud Firestore שהאפליקציה שלך משתמשת בהם באופן פעיל, כך שהאפליקציה שלך יכולה לגשת לנתונים כשהמכשיר במצב לא מקוון. אתה יכול לכתוב, לקרוא, להאזין ולשאול את הנתונים המאוחסנים במטמון. כאשר המכשיר חוזר לאינטרנט, Cloud Firestore מסנכרן את כל השינויים המקומיים שבוצעו על ידי האפליקציה שלך ל-Cloud Firestore.
כדי להשתמש בהתמדה במצב לא מקוון, אינך צריך לבצע שינויים כלשהם בקוד שבו אתה משתמש כדי לגשת לנתוני Cloud Firestore. כאשר התמדה במצב לא מקוון מופעלת, ספריית הלקוחות של Cloud Firestore מנהלת אוטומטית גישה לנתונים מקוונים ולא מקוונים ומסנכרנת נתונים מקומיים כשהמכשיר חוזר למצב מקוון.
הגדר התמדה במצב לא מקוון
כאשר אתה מאתחל את Cloud Firestore, אתה יכול להפעיל או להשבית התמדה במצב לא מקוון:
- עבור פלטפורמות אנדרואיד ואפל, התמדה במצב לא מקוון מופעלת כברירת מחדל. כדי להשבית את ההתמדה, הגדר את האפשרות
PersistenceEnabled
ל-false
. - עבור האינטרנט, התמדה במצב לא מקוון מושבתת כברירת מחדל. כדי לאפשר התמדה, קרא לשיטת
enablePersistence
. המטמון של Cloud Firestore אינו ניקה אוטומטית בין הפעלות. כתוצאה מכך, אם אפליקציית האינטרנט שלך מטפלת במידע רגיש, הקפד לשאול את המשתמש אם הוא נמצא במכשיר מהימן לפני שתאפשר התמדה.
Web version 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
Web version 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;
Java
FirebaseFirestoreSettings settings = new FirebaseFirestoreSettings.Builder() .setPersistenceEnabled(true) .build(); db.setFirestoreSettings(settings);
Kotlin+KTX
val settings = firestoreSettings { isPersistenceEnabled = true } db.firestoreSettings = settings
Dart
// Apple and Android db.settings = const Settings(persistenceEnabled: true); // Web await db .enablePersistence(const PersistenceSettings(synchronizeTabs: true));
הגדר את גודל המטמון
כאשר התמדה מופעלת, Cloud Firestore מאחסנת כל מסמך המתקבל מהקצה העורפי לגישה לא מקוונת. Cloud Firestore מגדירה סף ברירת מחדל לגודל המטמון. לאחר חריגה מברירת המחדל, Cloud Firestore מנסה מדי פעם לנקות מסמכים ישנים שאינם בשימוש. אתה יכול להגדיר סף גודל מטמון שונה או להשבית לחלוטין את תהליך הניקוי:
Web version 9
import { initializeFirestore, CACHE_SIZE_UNLIMITED } from "firebase/firestore"; const firestoreDb = initializeFirestore(app, { cacheSizeBytes: CACHE_SIZE_UNLIMITED });
Web version 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;
Java
// 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
Dart
db.settings = const Settings( persistenceEnabled: true, cacheSizeBytes: Settings.CACHE_SIZE_UNLIMITED, );
האזן לנתונים לא מקוונים
כשהמכשיר במצב לא מקוון, אם הפעלת התמדה במצב לא מקוון, המאזינים שלך יקבלו אירועי האזנה כאשר הנתונים המאוחסנים במטמון ישתנו. אתה יכול להאזין למסמכים, אוספים ושאילתות.
כדי לבדוק אם אתה מקבל נתונים מהשרת או מהמטמון, השתמש במאפיין fromCache
ב- SnapshotMetadata
באירוע תמונת המצב שלך. אם fromCache
true
, הנתונים הגיעו מהמטמון ועשויים להיות מיושנים או לא שלמים. אם fromCache
הוא false
, הנתונים מלאים ועדכניים עם העדכונים האחרונים בשרת.
כברירת מחדל, שום אירוע לא מועלה אם רק ה- SnapshotMetadata
השתנו. אם אתה מסתמך על ערכי fromCache
, ציין את אפשרות ההאזנה includeMetadataChanges
כאשר אתה מצרף את מטפל ההאזנה שלך.
Web version 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); }); });
Web version 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); }];
Java
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") } }
Dart
db .collection("cities") .where("state", isEqualTo: "CA") .snapshots(includeMetadataChanges: true) .listen((querySnapshot) { for (var change in querySnapshot.docChanges) { if (change.type == DocumentChangeType.added) { final source = (querySnapshot.metadata.isFromCache) ? "local cache" : "server"; print("Data fetched from $source}"); } } });
קבל נתונים במצב לא מקוון
אם אתה מקבל מסמך כשהמכשיר במצב לא מקוון, Cloud Firestore מחזיר נתונים מהמטמון.
בעת שאילתת אוסף, תוצאה ריקה מוחזרת אם אין מסמכים שמורים. בעת שליפת מסמך ספציפי, במקום זאת מוחזרת שגיאה.
שאילתה בנתונים לא מקוונים
שאילתה עובדת עם התמדה במצב לא מקוון. אתה יכול לאחזר את התוצאות של שאילתות עם Get ישיר או על ידי האזנה, כמתואר בסעיפים הקודמים. אתה יכול גם ליצור שאילתות חדשות על נתונים קבועים מקומיים כשהמכשיר במצב לא מקוון, אבל השאילתות יפעלו בתחילה רק מול המסמכים המאוחסנים במטמון.
השבת והפעל גישה לרשת
אתה יכול להשתמש בשיטה שלהלן כדי להשבית את הגישה לרשת עבור לקוח Cloud Firestore שלך. בזמן שהגישה לרשת מושבתת, כל מאזיני תמונת המצב ובקשות המסמכים מאחזרות תוצאות מהמטמון. פעולות הכתיבה עומדות בתור עד להפעלת הגישה לרשת מחדש.
Web version 9
import { disableNetwork } from "firebase/firestore"; await disableNetwork(db); console.log("Network disabled!"); // Do offline actions // ...
Web version 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 // ... }];
Java
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 // ... }
Dart
db.disableNetwork().then((_) { // Do offline things });
השתמש בשיטה הבאה כדי להפעיל מחדש את הגישה לרשת:
Web version 9
import { enableNetwork } from "firebase/firestore"; await enableNetwork(db); // Do online actions // ...
Web version 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 // ... }];
Java
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 // ... }
Dart
db.enableNetwork().then((_) { // Back online });