Acceder a datos sin conexión

Cloud Firestore admite la persistencia de datos sin conexión. Esta función almacena en caché una copia de los datos de Cloud Firestore que su aplicación usa activamente, para que su aplicación pueda acceder a los datos cuando el dispositivo está desconectado. Puede escribir, leer, escuchar y consultar los datos almacenados en caché. Cuando el dispositivo vuelve a estar en línea, Cloud Firestore sincroniza cualquier cambio local realizado por su aplicación con el backend de Cloud Firestore.

Para usar la persistencia sin conexión, no necesitas realizar ningún cambio en el código que usas para acceder a los datos de Cloud Firestore. Con la persistencia sin conexión habilitada, la biblioteca cliente de Cloud Firestore administra automáticamente el acceso a datos en línea y fuera de línea y sincroniza los datos locales cuando el dispositivo vuelve a estar en línea.

Configurar la persistencia sin conexión

Cuando inicializas Cloud Firestore, puedes habilitar o deshabilitar la persistencia sin conexión:

  • Para las plataformas Android y Apple, la persistencia sin conexión está habilitada de forma predeterminada. Para deshabilitar la persistencia, establezca la opción PersistenceEnabled en false .
  • Para la web, la persistencia sin conexión está deshabilitada de forma predeterminada. Para habilitar la persistencia, llame al método enablePersistence . El caché de Cloud Firestore no se borra automáticamente entre sesiones. En consecuencia, si su aplicación web maneja información confidencial, asegúrese de preguntarle al usuario si está en un dispositivo confiable antes de habilitar la persistencia.

Web modular API

// Memory cache is the default if no config is specified.
initializeFirestore(app);

// This is the default behavior if no persistence is specified.
initializeFirestore(app, {localCache: memoryLocalCache()});

// Defaults to single-tab persistence if no tab manager is specified.
initializeFirestore(app, {localCache: persistentLocalCache(/*settings*/{})});

// Same as `initializeFirestore(app, {localCache: persistentLocalCache(/*settings*/{})})`,
// but more explicit about tab management.
initializeFirestore(app, 
  {localCache: 
    persistentLocalCache(/*settings*/{tabManager: persistentSingleTabManager()})
});

// Use multi-tab IndexedDb persistence.
initializeFirestore(app, 
  {localCache: 
    persistentLocalCache(/*settings*/{tabManager: persistentMultipleTabManager()})
  });
  

Web namespaced API

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
Rápido
Nota: Este producto no está disponible en destinos watchOS y App Clip.
let settings = FirestoreSettings()

// Use memory-only cache
settings.cacheSettings =
MemoryCacheSettings(garbageCollectorSettings: MemoryLRUGCSettings())

// Use persistent disk cache, with 100 MB cache size
settings.cacheSettings = PersistentCacheSettings(sizeBytes: 100 * 1024 * 1024 as NSNumber)

// Any additional options
// ...

// Enable offline data persistence
let db = Firestore.firestore()
db.settings = settings
C objetivo
Nota: Este producto no está disponible en destinos watchOS y App Clip.
FIRFirestoreSettings *settings = [[FIRFirestoreSettings alloc] init];

// Use memory-only cache
settings.cacheSettings = [[FIRMemoryCacheSettings alloc]
    initWithGarbageCollectorSettings:[[FIRMemoryLRUGCSettings alloc] init]];

// Use persistent disk cache (default behavior)
// This example uses 100 MB.
settings.cacheSettings = [[FIRPersistentCacheSettings alloc]
    initWithSizeBytes:@(100 * 1024 * 1024)];

// Any additional options
// ...

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

Kotlin+KTX

val settings = firestoreSettings {
    // Use memory cache
    setLocalCacheSettings(memoryCacheSettings {})
    // Use persistent disk cache (default)
    setLocalCacheSettings(persistentCacheSettings {})
}
db.firestoreSettings = settings

Java

FirebaseFirestoreSettings settings = 
new FirebaseFirestoreSettings.Builder(db.getFirestoreSettings())
    // Use memory-only cache
    .setLocalCacheSettings(MemoryCacheSettings.newBuilder().build())
    // Use persistent disk cache (default)
    .setLocalCacheSettings(PersistentCacheSettings.newBuilder()
                            .build())
    .build();
db.setFirestoreSettings(settings);

Dart

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

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

Configurar el tamaño de la caché

Cuando la persistencia está habilitada, Cloud Firestore almacena en caché todos los documentos recibidos desde el backend para accederlos sin conexión. Cloud Firestore establece un umbral predeterminado para el tamaño de la caché. Después de exceder el valor predeterminado, Cloud Firestore intenta periódicamente limpiar los documentos más antiguos y no utilizados. Puede configurar un umbral de tamaño de caché diferente o desactivar el proceso de limpieza por completo:

Web modular API

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

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

Web namespaced API

firebase.firestore().settings({
    cacheSizeBytes: firebase.firestore.CACHE_SIZE_UNLIMITED
});
Rápido
Nota: Este producto no está disponible en destinos watchOS y 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
// Set cache size to 100 MB
settings.cacheSettings = PersistentCacheSettings(sizeBytes: 100 * 1024 * 1024 as NSNumber)
Firestore.firestore().settings = settings
C objetivo
Nota: Este producto no está disponible en destinos watchOS y 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;
// Set cache size to 100 MB
settings.cacheSettings =
    [[FIRPersistentCacheSettings alloc] initWithSizeBytes:@(100 * 1024 * 1024)];
[FIRFirestore firestore].settings = 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

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

Dart

db.settings = const Settings(
  persistenceEnabled: true,
  cacheSizeBytes: Settings.CACHE_SIZE_UNLIMITED,
);

Escuche datos sin conexión

Mientras el dispositivo está fuera de línea, si ha habilitado la persistencia fuera de línea, sus oyentes recibirán eventos de escucha cuando cambien los datos almacenados en caché local. Podrás escuchar documentos, colecciones y consultas.

Para verificar si está recibiendo datos del servidor o del caché, use la propiedad fromCache en SnapshotMetadata en su evento de instantánea. Si fromCache es true , los datos provienen del caché y pueden estar obsoletos o incompletos. Si fromCache es false , los datos están completos y actualizados con las últimas actualizaciones en el servidor.

De forma predeterminada, no se genera ningún evento si solo cambian los SnapshotMetadata . Si confía en los valores fromCache , especifique la opción de escucha includeMetadataChanges cuando adjunte su controlador de escucha.

Web modular API

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 namespaced API

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);
      });
  });
Rápido
Nota: Este producto no está disponible en destinos watchOS y 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)")
  }
C objetivo
Nota: Este producto no está disponible en destinos watchOS y 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);
    }];

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

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

            }
        });

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

Obtener datos sin conexión

Si obtiene un documento mientras el dispositivo está desconectado, Cloud Firestore devuelve datos del caché.

Al consultar una colección, se devuelve un resultado vacío si no hay documentos almacenados en caché. Al recuperar un documento específico, se devuelve un error.

Consultar datos sin conexión

Las consultas funcionan con persistencia fuera de línea. Puede recuperar los resultados de las consultas mediante una obtención directa o escuchando, como se describe en las secciones anteriores. También puede crear nuevas consultas sobre datos persistentes localmente mientras el dispositivo está fuera de línea, pero las consultas inicialmente se ejecutarán solo en los documentos almacenados en caché.

Configurar índices de consultas sin conexión

De forma predeterminada, el SDK de Firestore escanea todos los documentos de una colección en su caché local al ejecutar consultas sin conexión. Con este comportamiento predeterminado, el rendimiento de las consultas sin conexión puede verse afectado cuando los usuarios están desconectados durante largos períodos de tiempo.

Con la caché persistente habilitada, puede mejorar el rendimiento de las consultas sin conexión permitiendo que el SDK cree índices de consultas locales automáticamente.

La indexación automática está deshabilitada de forma predeterminada. Su aplicación debe habilitar la indexación automática cada vez que se inicia. Controle si la indexación automática está habilitada como se muestra a continuación.

Rápido
if let indexManager = Firestore.firestore().persistentCacheIndexManager {
  // Indexing is disabled by default
  indexManager.enableIndexAutoCreation()
} else {
  print("indexManager is nil")
}
    
C objetivo
PersistentCacheIndexManager *indexManager = [FIRFirestore firestore].persistentCacheIndexManager;
if (indexManager) {
  // Indexing is disabled by default
  [indexManager enableIndexAutoCreation];
}
    

Kotlin+KTX

// return type: PersistentCacheManager?

Firebase.firestore.persistentCacheIndexManager?.apply {
      // Indexing is disabled by default
      enableIndexAutoCreation()
    } ?: println("indexManager is null")
    

Java

// return type: @Nullable PersistentCacheIndexManager
PersistentCacheIndexManager indexManager = FirebaseFirestore.getInstance().getPersistentCacheIndexManager();
if (indexManager != null) {
  // Indexing is disabled by default
  indexManager.enableIndexAutoCreation();
}

// If not check indexManager != null, IDE shows warning: Method invocation 'enableIndexAutoCreation' may produce 'NullPointerException' 
FirebaseFirestore.getInstance().getPersistentCacheIndexManager().enableIndexAutoCreation();
    

Una vez habilitada la indexación automática, el SDK evalúa qué colecciones tienen una gran cantidad de documentos almacenados en caché y optimiza el rendimiento de las consultas locales.

El SDK proporciona un método para eliminar índices de consultas.

Deshabilitar y habilitar el acceso a la red

Puede utilizar el método siguiente para deshabilitar el acceso a la red para su cliente Cloud Firestore. Mientras el acceso a la red está deshabilitado, todos los escuchas de instantáneas y solicitudes de documentos recuperan resultados del caché. Las operaciones de escritura se ponen en cola hasta que se vuelve a habilitar el acceso a la red.

Web modular API

import { disableNetwork } from "firebase/firestore"; 

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

Web namespaced API

firebase.firestore().disableNetwork()
    .then(() => {
        // Do offline actions
        // ...
    });
Rápido
Nota: Este producto no está disponible en destinos watchOS y App Clip.
Firestore.firestore().disableNetwork { (error) in
  // Do offline things
  // ...
}
C objetivo
Nota: Este producto no está disponible en destinos watchOS y App Clip.
[[FIRFirestore firestore] disableNetworkWithCompletion:^(NSError *_Nullable error) {
  // Do offline actions
  // ...
}];

Kotlin+KTX

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

Java

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

Dart

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

Utilice el siguiente método para volver a habilitar el acceso a la red:

Web modular API

import { enableNetwork } from "firebase/firestore"; 

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

Web namespaced API

firebase.firestore().enableNetwork()
    .then(() => {
        // Do online actions
        // ...
    });
Rápido
Nota: Este producto no está disponible en destinos watchOS y App Clip.
Firestore.firestore().enableNetwork { (error) in
  // Do online things
  // ...
}
C objetivo
Nota: Este producto no está disponible en destinos watchOS y App Clip.
[[FIRFirestore firestore] enableNetworkWithCompletion:^(NSError *_Nullable error) {
  // Do online actions
  // ...
}];

Kotlin+KTX

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

Java

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

Dart

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