Accedi ai dati offline

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 per false .
  • 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
initialize_persistence.js

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
test.firestore.js
Veloce
Nota: questo prodotto non è disponibile sui target watchOS e App Clip.
let settings = FirestoreSettings()
settings.isPersistenceEnabled = true

// Any additional options
// ...

// Enable offline data persistence
let db = Firestore.firestore()
db.settings = settings
ViewController.swift
Obiettivo-C
Nota: questo prodotto non è disponibile sui target watchOS e App Clip.
FIRFirestoreSettings *settings = [[FIRFirestoreSettings alloc] init];
settings.persistenceEnabled = YES;

// Any additional options
// ...

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

Java

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

Kotlin+KTX

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

Dart

// Apple and Android
db.settings = const Settings(persistenceEnabled: true);

// Web
await db
    .enablePersistence(const PersistenceSettings(synchronizeTabs: true));
firestore.dart

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
});
fs_setup_cache.js

Web version 8

firebase.firestore().settings({
    cacheSizeBytes: firebase.firestore.CACHE_SIZE_UNLIMITED
});
test.firestore.js
Veloce
Nota: questo prodotto non è disponibile sui target watchOS e App Clip.
// 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
ViewController.swift
Obiettivo-C
Nota: questo prodotto non è disponibile sui target watchOS e App Clip.
// 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;
ViewController.m

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,
);
firestore.dart

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);
    });
});
use_from_cache.js

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);
      });
  });
test.firestore.js
Veloce
Nota: questo prodotto non è disponibile sui target watchOS e App Clip.
// 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)")
}
ViewController.swift
Obiettivo-C
Nota: questo prodotto non è disponibile sui target watchOS e App Clip.
// 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);
    }];
ViewController.m

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

            }
        });
DocSnippets.java

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")
            }
        }
DocSnippets.kt

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}");
    }
  }
});
firestore.dart

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
// ...
disable_network.js

Web version 8

firebase.firestore().disableNetwork()
    .then(() => {
        // Do offline actions
        // ...
    });
test.firestore.js
Veloce
Nota: questo prodotto non è disponibile sui target watchOS e App Clip.
Firestore.firestore().disableNetwork { (error) in
    // Do offline things
    // ...
}
ViewController.swift
Obiettivo-C
Nota: questo prodotto non è disponibile sui target watchOS e App Clip.
[[FIRFirestore firestore] disableNetworkWithCompletion:^(NSError *_Nullable error) {
  // Do offline actions
  // ...
}];
ViewController.m

Java

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

Kotlin+KTX

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

Dart

db.disableNetwork().then((_) {
  // Do offline things
});
firestore.dart

Utilizzare il seguente metodo per riattivare l'accesso alla rete:

Web version 9

import { enableNetwork } from "firebase/firestore"; 

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

Web version 8

firebase.firestore().enableNetwork()
    .then(() => {
        // Do online actions
        // ...
    });
test.firestore.js
Veloce
Nota: questo prodotto non è disponibile sui target watchOS e App Clip.
Firestore.firestore().enableNetwork { (error) in
    // Do online things
    // ...
}
ViewController.swift
Obiettivo-C
Nota: questo prodotto non è disponibile sui target watchOS e App Clip.
[[FIRFirestore firestore] enableNetworkWithCompletion:^(NSError *_Nullable error) {
  // Do online actions
  // ...
}];
ViewController.m

Java

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

Kotlin+KTX

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

Dart

db.enableNetwork().then((_) {
  // Back online
});
firestore.dart