Attivare le funzionalità offline su Android

Le applicazioni Firebase funzionano anche se la tua app perde temporaneamente la connessione alla rete. Inoltre, Firebase fornisce strumenti per la persistenza dei dati a livello locale, la gestione della presenza e la gestione della latenza.

Persistenza dei dischi

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

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

Puoi attivare la persistenza dei dati sul disco con una sola riga di codice.

Kotlin+KTX

Firebase.database.setPersistenceEnabled(true)
OfflineActivity.kt

Java

FirebaseDatabase.getInstance().setPersistenceEnabled(true);
OfflineActivity.java

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 mentre l'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 gli ascoltatori attivi. Inoltre, puoi mantenere sincronizzate località specifiche.

Kotlin+KTX

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

Java

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.

Kotlin+KTX

scoresRef.keepSynced(false)
OfflineActivity.kt

Java

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.

Eseguire 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

Kotlin+KTX

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

Java

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.

Kotlin+KTX

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

Java

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 mentre 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.

Le transazioni non vengono conservate dopo i riavvii dell'app

Anche con la persistenza abilitata, le transazioni non vengono mantenute tra i riavvii dell'app. Pertanto, non puoi fare affidamento sul fatto che le transazioni effettuate offline vengano applicate al tuo Firebase Realtime Database. Per offrire la migliore esperienza utente, la tua app deve mostrare che una transazione non è stata ancora salvata in Firebase Realtime Database o assicurarti che la tua app le ricordi manualmente ed eseguile di nuovo dopo un riavvio dell'app.

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

Gestione della presenza

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

I client di Firebase Database forniscono primitive semplici che puoi utilizzare per scrivere nel database quando un client si disconnette dai server di Firebase Database. Questi aggiornamenti si verificano indipendentemente dal fatto che il client si disconnetta correttamente o meno, quindi puoi utilizzarli per ripulire i dati anche se una connessione viene interrotta o un client si arresta in modo anomalo. Tutte le operazioni di scrittura, tra cui impostazione, aggiornamento e rimozione, possono essere eseguite dopo una disconnessione.

Ecco un semplice esempio di scrittura dei dati al momento della disconnessione mediante l'utilizzo della primitiva onDisconnect:

Kotlin+KTX

val presenceRef = Firebase.database.getReference("disconnectmessage")
// Write a string when this client loses connection
presenceRef.onDisconnect().setValue("I disconnected!")
OfflineActivity.kt

Java

DatabaseReference presenceRef = FirebaseDatabase.getInstance().getReference("disconnectmessage");
// Write a string when this client loses connection
presenceRef.onDisconnect().setValue("I disconnected!");
OfflineActivity.java

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 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 sull'operazione di scrittura per assicurarsi che onDisconnect sia stato allegato correttamente:

Kotlin+KTX

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

Java

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():

Kotlin+KTX

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

Java

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

Rilevamento dello stato della connessione

Per molte funzionalità relative 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 cambia lo stato di connessione del client Firebase Realtime Database. Ecco un esempio:

Kotlin+KTX

val connectedRef = Firebase.database.getReference(".info/connected")
connectedRef.addValueEventListener(object : ValueEventListener {
    override fun onDataChange(snapshot: DataSnapshot) {
        val connected = snapshot.getValue(Boolean::class.java) ?: false
        if (connected) {
            Log.d(TAG, "connected")
        } else {
            Log.d(TAG, "not connected")
        }
    }

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

Java

DatabaseReference connectedRef = FirebaseDatabase.getInstance().getReference(".info/connected");
connectedRef.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(@NonNull DataSnapshot snapshot) {
        boolean connected = snapshot.getValue(Boolean.class);
        if (connected) {
            Log.d(TAG, "connected");
        } else {
            Log.d(TAG, "not connected");
        }
    }

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

/.info/connected è un valore booleano che non viene sincronizzato tra i client Realtime Database perché dipende dallo stato del client. In altre parole, se un client legge /.info/connected come falso, non è garantito che anche un altro client lo legga come falso.

Su Android, Firebase gestisce automaticamente lo stato della connessione per ridurre la larghezza di banda e l'utilizzo della batteria. Quando un client non ha ascoltatori attivi, operazioni di scrittura o onDisconnect in attesa e non viene disconnesso esplicitamente dal metodo goOffline, Firebase chiude la connessione dopo 60 secondi di inattività.

Latenza di elaborazione

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:

Kotlin+KTX

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

Java

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

Spostamento 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 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 locale registrata (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.

Kotlin+KTX

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

Java

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

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 memorizza i dati in una posizione del database per indicare se un cliente Realtime Database è online o meno. I client impostano questa posizione su true quando si connettono e su un timestamp quando si disconnettono. Questo timestamp indica l'ultima volta che l'utente in questione era online.

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

Ecco un semplice sistema di rilevamento della presenza dell'utente:

Kotlin+KTX

// 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
val database = Firebase.database
val myConnectionsRef = database.getReference("users/joe/connections")

// Stores the timestamp of my last disconnect (the last time I was seen online)
val lastOnlineRef = database.getReference("/users/joe/lastOnline")

val connectedRef = database.getReference(".info/connected")
connectedRef.addValueEventListener(object : ValueEventListener {
    override fun onDataChange(snapshot: DataSnapshot) {
        val connected = snapshot.getValue<Boolean>() ?: false
        if (connected) {
            val con = myConnectionsRef.push()

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

            // When I disconnect, update the last time I was seen online
            lastOnlineRef.onDisconnect().setValue(ServerValue.TIMESTAMP)

            // Add this device to my connections list
            // this value could contain info about the device or a timestamp too
            con.setValue(java.lang.Boolean.TRUE)
        }
    }

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

Java

// 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 FirebaseDatabase database = FirebaseDatabase.getInstance();
final DatabaseReference myConnectionsRef = database.getReference("users/joe/connections");

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

final DatabaseReference connectedRef = database.getReference(".info/connected");
connectedRef.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(@NonNull DataSnapshot snapshot) {
        boolean connected = snapshot.getValue(Boolean.class);
        if (connected) {
            DatabaseReference con = myConnectionsRef.push();

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

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

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

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