Nuvola Firestore supporta dati offline persistenza. Questa funzione memorizza nella cache una copia dei dati cloud Firestore che la vostra applicazione sta attivamente utilizzando, in modo dalla vostra applicazione può accedere ai dati quando il dispositivo non è in linea. È possibile scrivere, leggere, ascoltare e interrogare i dati memorizzati nella cache. Quando il dispositivo torna in linea, Nube Firestore sincronizza tutte le modifiche locali da parte vostra applicazione al backend cloud FireStore.
Per utilizzare offline persistenza, non è necessario apportare modifiche al codice che si utilizza per l'accesso cloud FireStore dati. Con la persistenza offline abilitata, la libreria client cloud Firestore gestisce automaticamente l'accesso ai dati online e offline e sincronizza i dati locali quando il dispositivo è di nuovo online.
Configurare collegato persistenza
Quando si inizializza cloud FireStore, è possibile attivare o disattivare la persistenza non in linea:
- Per le piattaforme Android e Apple, non in linea la persistenza è abilitato di default. Per la persistenza disabilitare, impostare l'
PersistenceEnabled
opzione perfalse
. - Per il web, in linea di persistenza è disabilitato per impostazione predefinita. Per abilitare la persistenza, chiamare l'
enablePersistence
metodo. la cache di Cloud Firestore non viene cancellato automaticamente tra le sessioni. Di conseguenza, se le tue applicazioni Web gestisce informazioni sensibili, assicuratevi di chiedere all'utente se sono su un dispositivo di fiducia prima di attivare la persistenza.
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
Veloce
let settings = FirestoreSettings() settings.isPersistenceEnabled = true // Any additional options // ... // Enable offline data persistence let db = Firestore.firestore() db.settings = settings
Obiettivo-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));
Configurare la dimensione della cache
Quando la persistenza è abilitato, Nube Firestore memorizza nella cache tutti i documenti ricevuti dal backend per l'accesso offline. Nuvola Firestore imposta una soglia predefinita per la dimensione della cache. Dopo aver superato il valore di default, Nube FireStore tenta periodicamente per pulire più anziani, i documenti non utilizzati. È possibile configurare una soglia di dimensione della cache diverse o disattivare completamente il processo di clean-up:
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 });
Veloce
// 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
Obiettivo-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, );
Ascoltate dati offline
Mentre il dispositivo non è in linea, se è stato attivato in linea persistenza, gli ascoltatori riceveranno ascoltare eventi quando il memorizzati nella cache locale le modifiche dei dati. È possibile ascoltare i documenti, collezioni e query.
Per verificare se si sta ricevendo i dati dal server o la cache, utilizzare la fromCache
proprietà sulla SnapshotMetadata
nel vostro evento snapshot. Se fromCache
è true
, i dati provengono dalla cache e potrebbero essere stantio o incompleta. Se fromCache
è false
, i dati sono completi e aggiornati con gli ultimi aggiornamenti sul server.
Per impostazione predefinita, nessun evento viene generato se solo lo SnapshotMetadata
cambiato. Se ci si basa sulle fromCache
valori, specificare le includeMetadataChanges
ascoltano opzione quando si collega il gestore di ascoltare.
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); }); });
Veloce
// 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)") }
Obiettivo-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}"); } } });
Ottenere dati offline
Se si ottiene un documento mentre il dispositivo è offline, Nube Firestore restituisce i dati dalla cache.
Quando l'interrogazione di una collezione, un risultato vuoto viene restituito se non ci sono documenti memorizzati nella cache. Durante il recupero di un documento specifico, viene restituito un errore, invece.
Query dati offline
Interrogazione di opere con la persistenza offline. È possibile recuperare i risultati delle query sia con un get diretta o attraverso l'ascolto, come descritto nelle sezioni precedenti. È inoltre possibile creare nuove query sui dati persistenti a livello locale, mentre il dispositivo non è in linea, ma le query sarà inizialmente eseguito solo contro i documenti memorizzati nella cache.
Disabilitare e abilitare l'accesso alla rete
È possibile utilizzare il seguente metodo per disabilitare l'accesso alla rete per il client di cloud Firestore. Mentre l'accesso alla rete è disattivato, tutti gli ascoltatori di snapshot e le richieste di documenti recuperare i risultati dalla cache. le operazioni di scrittura sono in coda fino a quando l'accesso alla rete viene riattivato.
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 // ... });
Veloce
Firestore.firestore().disableNetwork { (error) in // Do offline things // ... }
Obiettivo-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 });
Utilizzare il seguente metodo per riattivare l'accesso alla rete:
Web version 9
import { enableNetwork } from "firebase/firestore"; await enableNetwork(db); // Do online actions // ...
Web version 8
firebase.firestore().enableNetwork() .then(() => { // Do online actions // ... });
Veloce
Firestore.firestore().enableNetwork { (error) in // Do online things // ... }
Obiettivo-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 });