Attivazione delle funzionalità offline

Le applicazioni Firebase funzionano anche se l'app perde temporaneamente la connessione di rete. Inoltre, Firebase fornisce strumenti per rendere persistenti i dati in locale, gestire la presenza e gestire la latenza.

Persistenza del disco

Le app Firebase gestiscono automaticamente le interruzioni temporanee della rete. I dati memorizzati nella cache sono disponibili offline e Firebase invia nuovamente tutte le scritture quando la connettività di rete viene ripristinata.

Quando attivi la persistenza del disco, l'app scrive i dati localmente sul dispositivo in modo che possa mantenere lo stato offline, anche se l'utente o il sistema operativo riavvia l'app.

Puoi attivare la persistenza del disco con una sola riga di codice.

FirebaseDatabase.instance.setPersistenceEnabled(true);

Comportamento di persistenza

Se attivi la persistenza, tutti i dati che il client Firebase Realtime Database sincronizzerebbe quando è online vengono salvati sul disco e sono disponibili offline, anche quando l'utente o il sistema operativo riavvia l'app. Ciò significa che la tua app funziona come se fosse online utilizzando i dati locali memorizzati nella cache. I callback del listener continueranno a essere attivati per gli aggiornamenti locali.

Il client Firebase Realtime Database mantiene automaticamente una coda di tutte le operazioni di scrittura eseguite mentre l'app è offline. Quando la persistenza è attivata, questa coda viene salvata anche su disco, in modo che tutte le scritture siano disponibili quando l'utente o il sistema operativo riavvia l'app. Quando l'app riacquista la connettività, tutte le operazioni vengono inviate al server Firebase Realtime Database.

Se la tua app utilizza Firebase Authentication, il client Firebase Realtime Database mantiene il token di autenticazione dell'utente durante i riavvii dell'app. Se il token di autenticazione scade mentre l'app è offline, il client mette in pausa le operazioni di scrittura finché l'app non autentica nuovamente l'utente, altrimenti le operazioni di scrittura potrebbero non riuscire a causa delle regole di sicurezza.

Mantenere i dati aggiornati

Firebase Realtime Database sincronizza e archivia una copia locale dei dati per i listener attivi. Inoltre, puoi mantenere sincronizzate posizioni specifiche.

final scoresRef = FirebaseDatabase.instance.ref("scores");
scoresRef.keepSynced(true);

Il client Firebase Realtime Database scarica automaticamente i dati in queste posizioni e li mantiene sincronizzati anche se il riferimento non ha listener attivi. Puoi disattivare di nuovo la sincronizzazione con la seguente riga di codice.

scoresRef.keepSynced(false);

Per impostazione predefinita, vengono memorizzati nella cache 10 MB di dati sincronizzati in precedenza. Dovrebbe essere sufficiente per la maggior parte delle applicazioni. Se la cache supera le dimensioni configurate, Firebase Realtime Database elimina i dati utilizzati meno di recente. I dati mantenuti sincronizzati non vengono eliminati dalla cache.

Esecuzione di query sui dati offline

Firebase Realtime Database archivia i dati restituiti da una query per l'utilizzo offline. Per le query create offline, Firebase Realtime Database continua a funzionare per i dati caricati in precedenza. Se i dati richiesti non sono stati caricati, Firebase Realtime Database carica i dati dalla cache locale. Quando la connettività di rete sarà di nuovo disponibile, i dati verranno caricati e rifletteranno la query.

Ad esempio, questo codice esegue una query per gli ultimi quattro elementi in un database di punteggi:

final scoresRef = FirebaseDatabase.instance.ref("scores");
scoresRef.orderByValue().limitToLast(4).onChildAdded.listen((event) {
  debugPrint("The ${event.snapshot.key} dinosaur's score is ${event.snapshot.value}.");
});

Supponi che l'utente perda la connessione, passi alla modalità offline e riavvii l'app. Mentre è ancora offline, l'app esegue una query per gli ultimi due elementi della stessa posizione. Questa query restituirà correttamente gli ultimi due elementi perché l'app aveva caricato tutti e quattro gli elementi nella query precedente.

scoresRef.orderByValue().limitToLast(2).onChildAdded.listen((event) {
  debugPrint("The ${event.snapshot.key} dinosaur's score is ${event.snapshot.value}.");
});

Nell'esempio precedente, il client Firebase Realtime Database genera eventi "child added" per i due dinosauri con il punteggio più alto, utilizzando la cache persistente. Tuttavia, non genererà un evento "value", poiché l'app non ha mai eseguito questa query mentre era online.

Se l'app dovesse richiedere gli ultimi sei elementi offline, riceverebbe immediatamente gli eventi "figlio aggiunto" per i quattro elementi memorizzati nella cache. Quando il dispositivo torna online, il client Firebase Realtime Database si sincronizza con il server e riceve gli ultimi due eventi "child added" e "value" per l'app.

Gestione delle transazioni offline

Tutte le transazioni eseguite mentre l'app è offline vengono messe in coda. Una volta che l'app si connette nuovamente alla rete, le transazioni vengono inviate al server Realtime Database.

Firebase Realtime Database offre molte funzionalità per gestire scenari offline e la connettività di rete. Il resto di questa guida si applica alla tua app indipendentemente dal fatto che tu abbia attivato o meno la persistenza.

Gestione della presenza

Nelle applicazioni in tempo reale è spesso utile rilevare quando i client si connettono e si disconnettono. Ad esempio, potresti voler contrassegnare un utente come "offline" quando il suo client si disconnette.

I client Firebase Database forniscono primitive semplici che puoi utilizzare per scrivere nel database quando un client si disconnette dai server Firebase Database. Questi aggiornamenti vengono eseguiti indipendentemente dal fatto che il client si disconnetta correttamente o meno, quindi puoi fare affidamento su di essi per liberare spazio anche se una connessione viene interrotta o un client si arresta in modo anomalo. Tutte le operazioni di scrittura, inclusi impostazione, aggiornamento e rimozione, possono essere eseguite in caso di disconnessione.

Ecco un semplice esempio di scrittura dei dati al momento della disconnessione utilizzando la primitiva onDisconnect:

final presenceRef = FirebaseDatabase.instance.ref("disconnectmessage");
// Write a string when this client loses connection
presenceRef.onDisconnect().set("I disconnected!");

Come funziona onDisconnect

Quando stabilisci un'operazione onDisconnect(), questa risiede sul server Firebase Realtime Database. Il server controlla la sicurezza per assicurarsi che l'utente possa eseguire l'evento di scrittura richiesto e comunica alla tua app se non è valido. Il server monitora la connessione. Se la connessione scade in qualsiasi momento o viene chiusa attivamente dal client Realtime Database, il server controlla la sicurezza una seconda volta (per assicurarsi che l'operazione sia ancora valida) e poi richiama l'evento.

try {
    await presenceRef.onDisconnect().remove();
} catch (error) {
    debugPrint("Could not establish onDisconnect event: $error");
}

Un evento onDisconnect può essere annullato anche chiamando .cancel():

final onDisconnectRef = presenceRef.onDisconnect();
onDisconnectRef.set("I disconnected");
// ...
// some time later when we change our minds
// ...
onDisconnectRef.cancel();

Rilevamento dello stato della connessione

Per molte funzionalità correlate alla presenza, è utile che la tua app sappia quando è online o offline. Firebase Realtime Database fornisce una posizione speciale in /.info/connected che viene aggiornata ogni volta che lo stato della connessione del client Firebase Realtime Database cambia. Ecco un esempio:

final connectedRef = FirebaseDatabase.instance.ref(".info/connected");
connectedRef.onValue.listen((event) {
  final connected = event.snapshot.value as bool? ?? false;
  if (connected) {
    debugPrint("Connected.");
  } else {
    debugPrint("Not connected.");
  }
});

/.info/connected è un valore booleano che non viene sincronizzato tra i client Realtime Database perché il valore dipende dallo stato del client. In altre parole, se un client legge /.info/connected come false, non è garantito che un client separato leggerà anche false.

Latenza di gestione

Timestamp del server

I server Firebase Realtime Database forniscono un meccanismo per inserire timestamp generati sul server come dati. Questa funzionalità, combinata con onDisconnect, offre un modo semplice per annotare in modo affidabile l'ora in cui un client Realtime Database si è disconnesso:

final userLastOnlineRef =
    FirebaseDatabase.instance.ref("users/joe/lastOnline");
userLastOnlineRef.onDisconnect().set(ServerValue.timestamp);

Skew dell'orologio

Sebbene ServerValue.timestamp sia molto più preciso e preferibile per la maggior parte delle operazioni di lettura/scrittura, a volte può essere utile stimare la differenza di orologio del client rispetto ai server di Firebase Realtime Database. Puoi collegare un callback alla posizione /.info/serverTimeOffset per ottenere il valore, in millisecondi, che i client Firebase Realtime Database aggiungono all'ora locale segnalata (ora Unix in millisecondi) per stimare l'ora del server. Tieni presente che l'accuratezza di questo offset può essere influenzata dalla latenza di rete, pertanto è utile principalmente per rilevare discrepanze di grandi dimensioni (> 1 secondo) nell'ora dell'orologio.

final offsetRef = FirebaseDatabase.instance.ref(".info/serverTimeOffset");
offsetRef.onValue.listen((event) {
  final offset = event.snapshot.value as num? ?? 0.0;
  final estimatedServerTimeMs =
      DateTime.now().millisecondsSinceEpoch + offset;
});

App di esempio per la presenza

Combinando le operazioni di disconnessione con il monitoraggio dello stato della connessione e i timestamp del server, puoi creare un sistema di presenza degli utenti. In questo sistema, ogni utente archivia i dati in una posizione del database per indicare se un client Realtime Database è online. I client impostano questa posizione su true quando si connettono a internet e un timestamp quando si disconnettono. Questo timestamp indica l'ultima volta che l'utente specificato è stato online.

Tieni presente che la tua app deve mettere in coda le operazioni di disconnessione prima che un utente venga contrassegnato come online, per evitare condizioni di competizione nel caso in cui la connessione di rete del client venga persa prima che entrambi i comandi possano essere inviati al server.

// Since I can connect from multiple devices, we store each connection
// instance separately any time that connectionsRef's value is null (i.e.
// has no children) I am offline.
final myConnectionsRef =
    FirebaseDatabase.instance.ref("users/joe/connections");

// Stores the timestamp of my last disconnect (the last time I was seen online)
final lastOnlineRef =
    FirebaseDatabase.instance.ref("/users/joe/lastOnline");

final connectedRef = FirebaseDatabase.instance.ref(".info/connected");
connectedRef.onValue.listen((event) {
  final connected = event.snapshot.value as bool? ?? false;
  if (connected) {
    final con = myConnectionsRef.push();

    // When this device disconnects, remove it.
    con.onDisconnect().remove();

    // When I disconnect, update the last time I was seen online.
    lastOnlineRef.onDisconnect().set(ServerValue.timestamp);

    // Add this device to my connections list.
    // This value could contain info about the device or a timestamp too.
    con.set(true);
  }
});