Attiva dati offline

Firestore supporta la persistenza dei dati offline. Questa funzionalità memorizza nella cache una copia dei dati Firestore che la tua app sta utilizzando attivamente, in modo che l'app possa accedere ai dati quando il dispositivo è offline. Puoi scrivere, leggere, ascoltare ed eseguire query sui dati memorizzati nella cache. Quando il dispositivo torna online, Firestore sincronizza tutte le modifiche locali apportate dalla tua app con il backend di Firestore.

Per utilizzare la persistenza offline, non è necessario apportare modifiche al codice che utilizzi per accedere ai dati Firestore. Con la persistenza offline abilitata, la libreria client Firestore gestisce automaticamente l'accesso ai dati online e offline e sincronizza i dati locali quando il dispositivo torna online.

Configura la persistenza offline

Quando inizializza Firestore, puoi abilitare o disabilitare la persistenza offline:

Per le piattaforme Android e Apple, la persistenza offline è abilitata per impostazione predefinita. Per disattivare la persistenza, imposta l'opzione PersistenceEnabled su false.
Per il web, la persistenza offline è disattivata per impostazione predefinita. Per attivare la persistenza, chiama il metodo enablePersistence. La cache di Firestore non viene cancellata automaticamente da una sessione all'altra. Di conseguenza, se la tua app web gestisce informazioni sensibili, assicurati di chiedere all'utente se si trova su un dispositivo attendibile prima di abilitare la persistenza.

Versione web 9

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

Versione web 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 successfullytest.firestore.js

Swift

Nota: questo prodotto non è disponibile per i target watchOS e 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 = settingsViewController.swift

Objective-C

Nota: questo prodotto non è disponibile per i target watchOS e 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;ViewController.m

Kotlin+KTX
Android

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

Java
Android

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);DocSnippets.java

Fresco

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

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

Configura le dimensioni della cache

Se la persistenza è abilitata, Firestore memorizza nella cache ogni documento ricevuto dal backend per l'accesso offline. Firestore imposta una soglia predefinita per le dimensioni della cache. Dopo aver superato il valore predefinito, Firestore tenta periodicamente di eliminare i documenti meno recenti e inutilizzati. Puoi configurare una soglia per le dimensioni della cache diversa o disattivare completamente la procedura di pulizia:

Versione web 9

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

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

Versione web 8

firebase.firestore().settings({
    cacheSizeBytes: firebase.firestore.CACHE_SIZE_UNLIMITED
});test.firestore.js

Swift

Nota: questo prodotto non è disponibile per i 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
// Set cache size to 100 MB
settings.cacheSettings = PersistentCacheSettings(sizeBytes: 100 * 1024 * 1024 as NSNumber)
Firestore.firestore().settings = settingsViewController.swift

Objective-C

Nota: questo prodotto non è disponibile per i 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;
// Set cache size to 100 MB
settings.cacheSettings =
    [[FIRPersistentCacheSettings alloc] initWithSizeBytes:@(100 * 1024 * 1024)];
[FIRFirestore firestore].settings = settings;ViewController.m

Kotlin+KTX
Android


// 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
Android


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

Fresco

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

Ascoltare dati offline

Mentre il dispositivo è offline, se hai attivato la persistenza offline, gli ascoltatori riceveranno gli eventi di ascolto quando i dati memorizzati nella cache locale cambiano. Puoi ascoltare documenti, raccolte e query.

Per verificare se i dati vengono ricevuti dal server o dalla cache, utilizza la proprietà fromCache in SnapshotMetadata nell'evento snapshot. Se fromCache è true, i dati provengono dalla cache e potrebbero essere inattivi o incompleti. Se fromCache è false, i dati sono completi e aggiornati agli più recenti aggiornamenti sul server.

Per impostazione predefinita, non viene generato alcun evento se viene modificato solo il valore SnapshotMetadata. Se utilizzi i valori fromCache, specifica l'opzione di ascolto includeMetadataChanges quando colleghi il gestore di ascolto.

Versione web 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

Versione web 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

Swift

Nota: questo prodotto non è disponibile per i 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

Objective-C

Nota: questo prodotto non è disponibile per i 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

Kotlin+KTX
Android

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

Java
Android

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

Fresco

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

Ricevi dati offline

Se ricevi un documento mentre il dispositivo è offline, Firestore restituisce i dati dalla cache.

Quando esegui una query su una raccolta, viene restituito un risultato vuoto se non ci sono documenti memorizzati nella cache. Durante il recupero di un documento specifico viene restituito un errore.

Esegui query su dati offline

Le query funzionano con persistenza offline. Puoi recuperare i risultati delle query con un comando get o in ascolto, come descritto nelle sezioni precedenti. Puoi anche creare nuove query sui dati persistenti localmente quando il dispositivo è offline, ma inizialmente le query verranno eseguite solo sui documenti memorizzati nella cache.

Configura gli indici di query offline

Per impostazione predefinita, l'SDK Firestore analizza tutti i documenti in una raccolta nella cache locale durante l'esecuzione di query offline. Con questo comportamento predefinito, le prestazioni delle query offline possono risentirne quando gli utenti sono offline per lunghi periodi di tempo.

Con la cache persistente abilitata, puoi migliorare le prestazioni delle query offline consentendo all'SDK di creare automaticamente indici di query locali.

L'indicizzazione automatica è disabilitata per impostazione predefinita. La tua app deve abilitare l'indicizzazione automatica a ogni avvio. Controlla se l'indicizzazione automatica è attivata come mostrato di seguito.

Swift

if let indexManager = Firestore.firestore().persistentCacheIndexManager {
  // Indexing is disabled by default
  indexManager.enableIndexAutoCreation()
} else {
  print("indexManager is nil")
}

Objective-C

PersistentCacheIndexManager *indexManager = [FIRFirestore firestore].persistentCacheIndexManager;
if (indexManager) {
  // Indexing is disabled by default
  [indexManager enableIndexAutoCreation];
}

Kotlin+KTX
Android

// return type: PersistentCacheManager?

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

Java
Android

// 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 volta abilitata l'indicizzazione automatica, l'SDK valuta quali raccolte hanno un numero elevato di documenti memorizzati nella cache e ottimizza le prestazioni delle query locali.

L'SDK fornisce un metodo per eliminare gli indici delle query.

Disattivare e abilitare l'accesso alla rete

Puoi utilizzare il metodo riportato di seguito per disabilitare l'accesso alla rete per il tuo client Firestore. Mentre l'accesso alla rete è disabilitato, tutti gli ascoltatori di snapshot e le richieste di documenti recuperano i risultati dalla cache. Le operazioni di scrittura vengono messe in coda fino a quando l'accesso alla rete non viene riattivato.

Versione web 9

import { disableNetwork } from "firebase/firestore";

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

Versione web 8

firebase.firestore().disableNetwork()
    .then(() => {
        // Do offline actions
        // ...
    });test.firestore.js

Swift

Nota: questo prodotto non è disponibile per i target watchOS e App Clip.

Firestore.firestore().disableNetwork { (error) in
  // Do offline things
  // ...
}ViewController.swift

Objective-C

Nota: questo prodotto non è disponibile per i target watchOS e App Clip.

[[FIRFirestore firestore] disableNetworkWithCompletion:^(NSError *_Nullable error) {
  // Do offline actions
  // ...
}];ViewController.m

Kotlin+KTX
Android

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

Java
Android

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

Fresco

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

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

Versione web 9

import { enableNetwork } from "firebase/firestore";

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

Versione web 8

firebase.firestore().enableNetwork()
    .then(() => {
        // Do online actions
        // ...
    });test.firestore.js

Swift

Nota: questo prodotto non è disponibile per i target watchOS e App Clip.

Firestore.firestore().enableNetwork { (error) in
  // Do online things
  // ...
}ViewController.swift

Objective-C

Nota: questo prodotto non è disponibile per i target watchOS e App Clip.

[[FIRFirestore firestore] enableNetworkWithCompletion:^(NSError *_Nullable error) {
  // Do online actions
  // ...
}];ViewController.m

Kotlin+KTX
Android

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

Java
Android

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

Fresco

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

Attiva dati offline

Configura la persistenza offline

Versione web 9

Versione web 8

Swift

Objective-C

Kotlin+KTXAndroid

JavaAndroid

Fresco

Configura le dimensioni della cache

Versione web 9

Versione web 8

Swift

Objective-C

Kotlin+KTXAndroid

JavaAndroid

Fresco

Ascoltare dati offline

Versione web 9

Versione web 8

Swift

Objective-C

Kotlin+KTXAndroid

JavaAndroid

Fresco

Ricevi dati offline

Esegui query su dati offline

Configura gli indici di query offline

Swift

Objective-C

Kotlin+KTXAndroid

JavaAndroid

Disattivare e abilitare l'accesso alla rete

Versione web 9

Versione web 8

Swift

Objective-C

Kotlin+KTXAndroid

JavaAndroid

Fresco

Versione web 9

Versione web 8

Swift

Objective-C

Kotlin+KTXAndroid

JavaAndroid

Fresco

Kotlin+KTX
Android

Java
Android

Kotlin+KTX
Android

Java
Android

Kotlin+KTX
Android

Java
Android

Kotlin+KTX
Android

Java
Android

Kotlin+KTX
Android

Java
Android

Kotlin+KTX
Android

Java
Android