Attivare le funzionalità offline su Android

Comportamento di persistenza

Se attivi la persistenza, tutti i dati che il client Firebase Realtime Database sincronizzerebbe 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 dei 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 anche dopo il riavvio 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 gli ascoltatori attivi. Inoltre, puoi mantenere sincronizzate posizioni specifiche.

val scoresRef = Firebase.database.getReference("scores")
scoresRef.keepSynced(true)
OfflineActivity.kt

DatabaseReference scoresRef = FirebaseDatabase.getInstance().getReference("scores");
scoresRef.keepSynced(true);
OfflineActivity.java

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)
OfflineActivity.kt

scoresRef.keepSynced(false);
OfflineActivity.java

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 memorizza i dati restituiti da una query per l'utilizzo quando è 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 vengono caricati e riflettono la query.

Ad esempio, questo codice esegue query sugli ultimi quattro elementi di un Firebase Realtime Database di punteggi

val scoresRef = Firebase.database.getReference("scores")
scoresRef.orderByValue().limitToLast(4).addChildEventListener(object : ChildEventListener {
    override fun onChildAdded(snapshot: DataSnapshot, previousChild: String?) {
        Log.d(TAG, "The ${snapshot.key} dinosaur's score is ${snapshot.value}")
    }

    // ...
})
OfflineActivity.kt

DatabaseReference scoresRef = FirebaseDatabase.getInstance().getReference("scores");
scoresRef.orderByValue().limitToLast(4).addChildEventListener(new ChildEventListener() {
    @Override
    public void onChildAdded(@NonNull DataSnapshot snapshot, String previousChild) {
        Log.d(TAG, "The " + snapshot.getKey() + " dinosaur's score is " + snapshot.getValue());
    }

    // ...
});
OfflineActivity.java

Supponi che l'utente perda la connessione, passi 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).addChildEventListener(object : ChildEventListener {
    override fun onChildAdded(snapshot: DataSnapshot, previousChild: String?) {
        Log.d(TAG, "The ${snapshot.key} dinosaur's score is ${snapshot.value}")
    }

    // ...
})
OfflineActivity.kt

scoresRef.orderByValue().limitToLast(2).addChildEventListener(new ChildEventListener() {
    @Override
    public void onChildAdded(@NonNull DataSnapshot snapshot, String previousChild) {
        Log.d(TAG, "The " + snapshot.getKey() + " dinosaur's score is " + snapshot.getValue());
    }

    // ...
});
OfflineActivity.java

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. ma 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 "elemento secondario 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.

Come funziona onDisconnect

Quando stabilisci un'operazione onDisconnect(), l'operazione 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.

La tua app può utilizzare il callback sull'operazione di scrittura per assicurarsi che onDisconnect sia stato allegato correttamente:

presenceRef.onDisconnect().removeValue { error, reference ->
    error?.let {
        Log.d(TAG, "could not establish onDisconnect event: ${error.message}")
    }
}
OfflineActivity.kt

presenceRef.onDisconnect().removeValue(new DatabaseReference.CompletionListener() {
    @Override
    public void onComplete(DatabaseError error, @NonNull DatabaseReference reference) {
        if (error != null) {
            Log.d(TAG, "could not establish onDisconnect event:" + error.getMessage());
        }
    }
});
OfflineActivity.java

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

val onDisconnectRef = presenceRef.onDisconnect()
onDisconnectRef.setValue("I disconnected")
// ...
// some time later when we change our minds
// ...
onDisconnectRef.cancel()
OfflineActivity.kt

OnDisconnect onDisconnectRef = presenceRef.onDisconnect();
onDisconnectRef.setValue("I disconnected");
// ...
// some time later when we change our minds
// ...
onDisconnectRef.cancel();
OfflineActivity.java

Timestamp del server

I server Firebase Realtime Database forniscono un meccanismo per inserire i 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:

val userLastOnlineRef = Firebase.database.getReference("users/joe/lastOnline")
userLastOnlineRef.onDisconnect().setValue(ServerValue.TIMESTAMP)
OfflineActivity.kt

DatabaseReference userLastOnlineRef = FirebaseDatabase.getInstance().getReference("users/joe/lastOnline");
userLastOnlineRef.onDisconnect().setValue(ServerValue.TIMESTAMP);
OfflineActivity.java

Skew dell'orologio

Sebbene firebase.database.ServerValue.TIMESTAMP sia molto più accurato 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.

val offsetRef = Firebase.database.getReference(".info/serverTimeOffset")
offsetRef.addValueEventListener(object : ValueEventListener {
    override fun onDataChange(snapshot: DataSnapshot) {
        val offset = snapshot.getValue(Double::class.java) ?: 0.0
        val estimatedServerTimeMs = System.currentTimeMillis() + offset
    }

    override fun onCancelled(error: DatabaseError) {
        Log.w(TAG, "Listener was cancelled")
    }
})
OfflineActivity.kt

DatabaseReference offsetRef = FirebaseDatabase.getInstance().getReference(".info/serverTimeOffset");
offsetRef.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(@NonNull DataSnapshot snapshot) {
        double offset = snapshot.getValue(Double.class);
        double estimatedServerTimeMs = System.currentTimeMillis() + offset;
    }

    @Override
    public void onCancelled(@NonNull DatabaseError error) {
        Log.w(TAG, "Listener was cancelled");
    }
});
OfflineActivity.java