Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Acessar dados off-line

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

O Cloud Firestore é compatível com a 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 on-line, 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 usado para acessar os dados do Cloud Firestore. Com a persistência off-line habilitada, a biblioteca de 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 offline

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 como false .
  • Para a web, a persistência offline está desabilitada por padrão. Para habilitar 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 lidar com informações confidenciais, pergunte 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
Observação: este produto não está disponível em destinos watchOS e App Clip.
let settings = FirestoreSettings()
settings.isPersistenceEnabled = true

// Any additional options
// ...

// Enable offline data persistence
let db = Firestore.firestore()
db.settings = settings
Objetivo-C
Observação: este produto não está disponível em destinos 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;

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

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 limpar documentos mais antigos e não utilizados periodicamente. 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
Observação: este produto não está disponível em destinos 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
Objetivo-C
Observação: este produto não está disponível em destinos 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;
  

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

Ouvir dados off-line

Enquanto o dispositivo estiver offline, se você tiver ativado a persistência offline, 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 desatualizados 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
Observação: este produto não está disponível em destinos 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)")
}
Objetivo-C
Observação: este produto não está disponível em destinos 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);
    }];

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

Obtenha dados off-line

Se você receber um documento enquanto o dispositivo estiver off-line, o Cloud Firestore retornará 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 escutando, conforme descrito nas seções anteriores. Você também pode criar novas consultas em dados persistidos localmente enquanto o dispositivo estiver offline, mas as consultas serão executadas inicialmente apenas nos documentos armazenados em cache.

Configurar índices de consulta offline

Por padrão, o SDK do Firestore 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.

Os SDKs da plataforma Apple , Android e JavaScript fornecem um método setIndexConfiguration que permite configurar índices de consulta locais para melhorar o desempenho de suas consultas offline.

Esses métodos leem a mesma configuração estruturada em JSON usada para configurar índices no servidor, seguindo o mesmo formato de definição de índice .

A configuração de índice offline a ser usada depende de quais coleções e documentos seu aplicativo acessa fortemente enquanto offline e do desempenho offline desejado. Embora você possa exportar sua configuração de índice de back-end para uso no cliente, os padrões de acesso offline do seu aplicativo provavelmente diferem significativamente dos padrões de acesso online, portanto, sua configuração de índice online pode não ser adequada para uso offline. 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 para definição de índice do guia de indexação .

Para disponibilizar configurações de índice offline para carregamento em seu aplicativo cliente:

  • compile e distribua-os com seu aplicativo
  • baixá-los de um CDN
  • buscá-los em um sistema de armazenamento como o Cloud Storage para Firebase .

Desabilitar e habilitar o acesso à rede

Você pode usar o método abaixo para desativar o acesso à rede para seu cliente do Cloud Firestore. Enquanto o acesso à rede está desabilitado, 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
Observação: este produto não está disponível em destinos watchOS e App Clip.
Firestore.firestore().disableNetwork { (error) in
    // Do offline things
    // ...
}
Objetivo-C
Observação: este produto não está disponível em destinos watchOS e App Clip.
[[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
});

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
Observação: este produto não está disponível em destinos watchOS e App Clip.
Firestore.firestore().enableNetwork { (error) in
    // Do online things
    // ...
}
Objetivo-C
Observação: este produto não está disponível em destinos watchOS e App Clip.
[[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
});