Catch up on everthing we announced at this year's Firebase Summit. Learn more

Offline auf Daten zugreifen

Cloud Firestore unterstützt die Offlinedatenpersistenz. Diese Funktion speichert eine Kopie der Cloud Firestore-Daten, die Ihre App aktiv verwendet, im Cache, sodass Ihre App auf die Daten zugreifen kann, wenn das Gerät offline ist. Sie können die zwischengespeicherten Daten schreiben, lesen, anhören und abfragen. Wenn das Gerät wieder online ist, synchronisiert Cloud Firestore alle von Ihrer App vorgenommenen lokalen Änderungen mit dem Cloud Firestore-Back-End.

Um die Offlinepersistenz zu verwenden, müssen Sie keine Änderungen am Code vornehmen, mit dem Sie auf Cloud Firestore-Daten zugreifen. Bei aktivierter Offline-Persistenz verwaltet die Cloud Firestore-Clientbibliothek automatisch den Online- und Offline-Datenzugriff und synchronisiert lokale Daten, wenn das Gerät wieder online ist.

Offline-Persistenz konfigurieren

Wenn Sie Cloud Firestore initialisieren, können Sie die Offlinepersistenz aktivieren oder deaktivieren:

  • Für Android- und Apple-Plattformen ist die Offline-Persistenz standardmäßig aktiviert. So deaktivieren Sie Ausdauer, stellen Sie die PersistenceEnabled Option false .
  • Für das Web ist die Offlinepersistenz standardmäßig deaktiviert. So aktivieren Sie Ausdauer, rufen Sie die enablePersistence Methode. Der Cache von Cloud Firestore wird zwischen Sitzungen nicht automatisch gelöscht. Wenn Ihre Web-App vertrauliche Informationen verarbeitet, sollten Sie daher den Benutzer fragen, ob er sich auf einem vertrauenswürdigen Gerät befindet, bevor Sie die Persistenz aktivieren.

Webversion 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

Webversion 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
Schnell
Hinweis: Dieses Produkt ist nicht verfügbar auf watchOS und App Clip Ziele.
let settings = FirestoreSettings()
settings.isPersistenceEnabled = true

// Any additional options
// ...

// Enable offline data persistence
let db = Firestore.firestore()
db.settings = settings
Ziel c
Hinweis: Dieses Produkt ist nicht verfügbar auf watchOS und App Clip Ziele.
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

Cache-Größe konfigurieren

Wenn die Persistenz aktiviert ist, speichert Cloud Firestore jedes vom Back-End empfangene Dokument für den Offlinezugriff im Cache. Cloud Firestore legt einen Standardschwellenwert für die Cachegröße fest. Nachdem der Standardwert überschritten wurde, versucht Cloud Firestore regelmäßig, ältere, nicht verwendete Dokumente zu bereinigen. Sie können einen anderen Schwellenwert für die Cachegröße konfigurieren oder den Bereinigungsprozess vollständig deaktivieren:

Webversion 9

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

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

Webversion 8

firebase.firestore().settings({
    cacheSizeBytes: firebase.firestore.CACHE_SIZE_UNLIMITED
});
Schnell
Hinweis: Dieses Produkt ist nicht verfügbar auf watchOS und App Clip Ziele.
// 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
Ziel c
Hinweis: Dieses Produkt ist nicht verfügbar auf watchOS und App Clip Ziele.
// 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

Offline-Daten anhören

Wenn das Gerät offline ist und Sie die Offlinepersistenz aktiviert haben, empfangen Ihre Listener Listenereignisse, wenn sich die lokal zwischengespeicherten Daten ändern. Sie können Dokumente, Sammlungen und Abfragen anhören.

Um zu überprüfen , ob Sie Daten von dem Server oder dem Cache empfangen, verwenden Sie die fromCache Eigenschaft auf dem SnapshotMetadata in Ihrem Snapshot - Ereignisse. Wenn fromCache ist true , kamen die Daten aus dem Cache und möglicherweise veraltete oder unvollständig sein. Wenn fromCache ist false , sind die Daten vollständig und aktuell mit dem neuesten Updates auf dem Server.

Standardmäßig wird kein Ereignis ausgelöst , wenn nur die SnapshotMetadata geändert. Wenn Sie sich auf die verlassen fromCache Werte geben die includeMetadataChanges Option hören , wenn Sie Ihren Handler hören befestigen.

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

Webversion 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);
      });
  });
Schnell
Hinweis: Dieses Produkt ist nicht verfügbar auf watchOS und App Clip Ziele.
// 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)")
}
Ziel c
Hinweis: Dieses Produkt ist nicht verfügbar auf watchOS und App Clip Ziele.
// 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")
            }
        }

Offline-Daten abrufen

Wenn Sie ein Dokument erhalten, während das Gerät offline ist, gibt Cloud Firestore Daten aus dem Cache zurück.

Beim Abfragen einer Sammlung wird ein leeres Ergebnis zurückgegeben, wenn keine zwischengespeicherten Dokumente vorhanden sind. Beim Abrufen eines bestimmten Dokuments wird stattdessen ein Fehler zurückgegeben.

Offlinedaten abfragen

Das Abfragen funktioniert mit Offline-Persistenz. Sie können die Ergebnisse von Abfragen entweder mit einem direkten Get oder durch Abhören abrufen, wie in den vorherigen Abschnitten beschrieben. Sie können auch neue Abfragen für lokal persistente Daten erstellen, während das Gerät offline ist, aber die Abfragen werden zunächst nur für die zwischengespeicherten Dokumente ausgeführt.

Deaktivieren und aktivieren Sie den Netzwerkzugriff

Sie können die folgende Methode verwenden, um den Netzwerkzugriff für Ihren Cloud Firestore-Client zu deaktivieren. Während der Netzwerkzugriff deaktiviert ist, rufen alle Snapshot-Listener und Dokumentanforderungen Ergebnisse aus dem Cache ab. Schreibvorgänge werden in die Warteschlange gestellt, bis der Netzwerkzugriff wieder aktiviert wird.

Webversion 9

import { disableNetwork } from "firebase/firestore"; 

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

Webversion 8

firebase.firestore().disableNetwork()
    .then(() => {
        // Do offline actions
        // ...
    });
Schnell
Hinweis: Dieses Produkt ist nicht verfügbar auf watchOS und App Clip Ziele.
Firestore.firestore().disableNetwork { (error) in
    // Do offline things
    // ...
}
Ziel c
Hinweis: Dieses Produkt ist nicht verfügbar auf watchOS und App Clip Ziele.
[[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
    // ...
}

Verwenden Sie die folgende Methode, um den Netzwerkzugriff wieder zu aktivieren:

Webversion 9

import { enableNetwork } from "firebase/firestore"; 

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

Webversion 8

firebase.firestore().enableNetwork()
    .then(() => {
        // Do online actions
        // ...
    });
Schnell
Hinweis: Dieses Produkt ist nicht verfügbar auf watchOS und App Clip Ziele.
Firestore.firestore().enableNetwork { (error) in
    // Do online things
    // ...
}
Ziel c
Hinweis: Dieses Produkt ist nicht verfügbar auf watchOS und App Clip Ziele.
[[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
    // ...
}