Attivare le funzionalità offline su Android

Comportamento di persistenza

Se attivi la persistenza, tutti i dati che il client Firebase Realtime Database sincronizzerebbe quando è online vengono memorizzati 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 dell'ascoltatore continueranno a essere attivati per gli aggiornamenti locali.

Il client Firebase Realtime Database mantiene automaticamente una coda di tutte le operazioni di scrittura eseguite quando la tua app è offline. Quando la persistenza è attivata, questa coda viene mantenuta anche sul disco, quindi tutte le tue scritture sono disponibili quando l'utente o il sistema operativo riavvia l'app. Quando l'app recupera 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 quando l'app è offline, il client mette in pausa le operazioni di scrittura finché l'app non autentica di nuovo l'utente, altrimenti le operazioni di scrittura potrebbero non riuscire a causa delle regole di sicurezza.

Aggiornamento dei dati

Firebase Realtime Database sincronizza e archivia una copia locale dei dati per i listener attivi. Inoltre, puoi mantenere sincronizzate località 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 ascoltatori 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, il 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, il 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 è 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

Supponiamo che l'utente perda la connessione, passi alla modalità offline e riavvii l'app. Mentre è ancora offline, l'app esegue query sugli ultimi due elementi della stessa località. Questa query restituirà correttamente gli ultimi due elementi perché l'app ha 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. Tuttavia, non verrà generato un evento "value", poiché l'app non ha mai eseguito la query mentre era online.

Se l'app richiedesse gli ultimi sei elementi in modalità offline, riceverebbe subito gli eventi "elemento 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 "elemento figlio aggiunto" e 'valore" per l'app.

Gestione delle transazioni offline

Eventuali transazioni eseguite quando l'app è offline vengono messe in coda. Una volta che l'app recupera la connettività di rete, le transazioni vengono inviate al server Realtime Database.

Come funziona onDisconnect

Quando stabilisci un'operazione onDisconnect(), questa si trova sul server Firebase Realtime Database. Il server controlla la sicurezza per assicurarsi che l'utente possa eseguire l'evento di scrittura richiesto e informa la tua app se non è valido. Il server monitora quindi la connessione. Se in un determinato momento la connessione scade 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 nell'operazione di scrittura per assicurarti che onDisconnect sia stato collegato 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 .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 come dati i timestamp generati sul server. Questa funzionalità, combinata con onDisconnect, offre un modo semplice per annotare in modo affidabile il momento 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

Disallineamento 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 lo sfasamento dell'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 registrata locale (ora di epoch in millisecondi) per stimare l'ora del server. Tieni presente che l'accuratezza di questo offset può essere influenzata dalla latenza della rete ed è quindi utile principalmente per rilevare discrepanze elevate (> 1 secondo) nell'ora del sistema.

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