O Cloud Firestore oferece suporte à persistência de dados off-line. Esse recurso armazena em cache uma cópia dos dados do Cloud Firestore que seu aplicativo está usando ativamente, para que seu aplicativo possa acessar os dados quando o dispositivo estiver off-line. Você pode gravar, ler, ouvir e consultar os dados armazenados em cache. Quando o dispositivo volta a ficar online, o Cloud Firestore sincroniza todas as alterações locais feitas pelo seu aplicativo com o back-end do Cloud Firestore.
Para usar a persistência off-line, você não precisa fazer alterações no código que usa para acessar os dados do Cloud Firestore. Com a persistência off-line habilitada, a biblioteca cliente do Cloud Firestore gerencia automaticamente o acesso a dados on-line e off-line e sincroniza os dados locais quando o dispositivo volta a ficar on-line.
Configurar persistência off-line
Ao inicializar o Cloud Firestore, você pode ativar ou desativar a persistência off-line:
- Para plataformas Android e Apple, a persistência offline é habilitada por padrão. Para desabilitar a persistência, defina a opção
PersistenceEnabled
comofalse
. - Para a web, a persistência offline é desativada por padrão. Para ativar a persistência, chame o método
enablePersistence
. O cache do Cloud Firestore não é limpo automaticamente entre as sessões. Conseqüentemente, se seu aplicativo da web lida com informações confidenciais, certifique-se de perguntar ao usuário se ele está em um dispositivo confiável antes de habilitar a persistência.
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
Rápido
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;
Kotlin+KTX
val settings = firestoreSettings { isPersistenceEnabled = true } db.firestoreSettings = settings
Java
FirebaseFirestoreSettings settings = new FirebaseFirestoreSettings.Builder() .setPersistenceEnabled(true) .build(); db.setFirestoreSettings(settings);
Dart
// Apple and Android db.settings = const Settings(persistenceEnabled: true); // Web await db .enablePersistence(const PersistenceSettings(synchronizeTabs: true));
Configurar o tamanho do cache
Quando a persistência está habilitada, o Cloud Firestore armazena em cache todos os documentos recebidos do back-end para acesso off-line. O Cloud Firestore define um limite padrão para o tamanho do cache. Depois de exceder o padrão, o Cloud Firestore tenta periodicamente limpar documentos antigos e não utilizados. Você pode configurar um limite de tamanho de cache diferente ou desativar completamente o processo de limpeza:
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 });
Rápido
// 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;
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, );
Ouvir dados off-line
Enquanto o dispositivo estiver off-line, se você tiver ativado a persistência off-line, seus ouvintes receberão eventos de escuta quando os dados armazenados em cache local forem alterados. Você pode ouvir documentos, coleções e consultas.
Para verificar se você está recebendo dados do servidor ou do cache, use a propriedade fromCache
no SnapshotMetadata
em seu evento de instantâneo. Se fromCache
for true
, os dados vieram do cache e podem estar obsoletos ou incompletos. Se fromCache
for false
, os dados estarão completos e atualizados com as atualizações mais recentes no servidor.
Por padrão, nenhum evento é gerado se apenas o SnapshotMetadata
for alterado. Se você confiar nos valores fromCache
, especifique a opção de escuta includeMetadataChanges
ao anexar seu manipulador de escuta.
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); }); });
Rápido
// 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); }];
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}"); } } });
Obter dados off-line
Se você obtiver um documento enquanto o dispositivo estiver off-line, o Cloud Firestore retornará os dados do cache.
Ao consultar uma coleção, um resultado vazio é retornado se não houver documentos em cache. Ao buscar um documento específico, um erro é retornado.
Consultar dados off-line
A consulta funciona com persistência offline. Você pode recuperar os resultados das consultas com uma obtenção direta ou ouvindo, conforme descrito nas seções anteriores. Você também pode criar novas consultas em dados persistentes localmente enquanto o dispositivo estiver offline, mas as consultas inicialmente serão executadas apenas nos documentos armazenados em cache.
Configurar índices de consulta off-line
Por padrão, o Firestore SDK verifica todos os documentos em uma coleção em seu cache local ao executar consultas off-line. Com esse comportamento padrão, o desempenho da consulta offline pode ser prejudicado quando os usuários ficam offline por longos períodos de tempo.
Você pode melhorar o desempenho de consultas off-line configurando índices de consulta local:
Rápido
O SDK da plataforma Apple fornece um método setIndexConfiguration
que lê a mesma configuração estruturada em JSON usada para configurar índices no servidor, seguindo o mesmo formato de definição de índice .
// You will normally read this from a file asset or cloud storage. let indexConfigJson = """ { indexes: [ ... ], fieldOverrides: [ ... ] } """ // Apply the configuration. Firestore.firestore().setIndexConfiguration(indexConfigJson)
Objective-C
O SDK da plataforma Apple fornece setIndexConfiguration
- métodos que leem a mesma configuração estruturada em JSON usada para configurar índices no servidor, seguindo o mesmo formato de definição de índice .
// You will normally read this from a file asset or cloud storage. NSString *indexConfigJson = @" { " " indexes: [ " " ... " " ], " " fieldOverrides: [ " " ... " " ] " " } "; // Apply the configuration. [[FIRFirestore firestore] setIndexConfigurationFromJSON:indexConfigJson completion:^(NSError * _Nullable error) { // ... }];
Java
O Android SDK fornece um método setIndexConfiguration
que lê a mesma configuração estruturada em JSON usada para configurar índices no servidor, seguindo o mesmo formato de definição de índice .
// You will normally read this from a file asset or cloud storage. String indexConfigJson = " { " + " indexes: [ " + " ... " + " ], " + " fieldOverrides: [ " + " ... " + " ] " + " } "; // Apply the configuration. FirebaseFirestore.getInstance().setIndexConfiguration(indexConfigJson);
Kotlin+KTX
O Android SDK fornece um método setIndexConfiguration
que lê a mesma configuração estruturada em JSON usada para configurar índices no servidor, seguindo o mesmo formato de definição de índice .
// You will normally read this from a file asset or cloud storage. val indexConfigJson = """ { indexes: [ ... ], fieldOverrides: [ ... ] } """ // Apply the configuration. FirebaseFirestore.getInstance().setIndexConfiguration(indexConfigJson)
Dart
O Flutter SDK fornece um método setIndexConfigurationFromJSON
que lê a mesma configuração estruturada em JSON usada para configurar índices no servidor, seguindo o mesmo formato de definição de índice .
// You will normally read this from a file asset or cloud storage. var indexConfigJson = """ { indexes: [ ... ], fieldOverrides: [ ... ] } """; // Apply the configuration. await FirebaseFirestore.instance.setIndexConfigurationFromJSON(json: indexConfigJson);
Como alternativa, você pode usar o método setIndexConfiguration
para configurar índices com uma API baseada em classe.
var indexes = [ Index( collectionGroup: "posts", queryScope: QueryScope.collection, fields: [ IndexField(fieldPath: "author", arrayConfig: ArrayConfig.contains), IndexField(fieldPath: "timestamp", order: Order.descending) ], ), ]; await FirebaseFirestore.instance.setIndexConfiguration(indexes: indexes);
A configuração de índice off-line a ser usada depende de quais coleções e documentos seu aplicativo acessa intensamente enquanto estiver off-line e do desempenho off-line desejado. Embora você possa exportar sua configuração de índice de back-end para uso no cliente, os padrões de acesso off-line de seu aplicativo provavelmente diferem significativamente dos padrões de acesso on-line, portanto, sua configuração de índice on-line pode não ser adequada para uso off-line. Quais coleções e documentos você deseja que seu aplicativo acesse offline com alto desempenho? Depois de analisar o comportamento do seu aplicativo, siga os princípios de definição de índice do guia de indexação .
Para disponibilizar configurações de índice off-line para carregamento em seu aplicativo cliente:
- compilá-los e distribuí-los com seu aplicativo
- baixá-los de um CDN
- busque-os em um sistema de armazenamento como o Cloud Storage para Firebase .
Desativar e ativar o acesso à rede
Você pode usar o método abaixo para desativar o acesso à rede para seu cliente Cloud Firestore. Enquanto o acesso à rede está desativado, todos os ouvintes de instantâneos e solicitações de documentos recuperam os resultados do cache. As operações de gravação são enfileiradas até que o acesso à rede seja reativado.
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 // ... });
Rápido
Firestore.firestore().disableNetwork { (error) in // Do offline things // ... }
Objective-C
[[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 });
Use o seguinte método para reativar o acesso à rede:
Web version 9
import { enableNetwork } from "firebase/firestore"; await enableNetwork(db); // Do online actions // ...
Web version 8
firebase.firestore().enableNetwork() .then(() => { // Do online actions // ... });
Rápido
Firestore.firestore().enableNetwork { (error) in // Do online things // ... }
Objective-C
[[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 });