Activation des capacités hors ligne sur Android

Comportement de persistance

En activant la persistance, toutes les données que le client Firebase Realtime Database synchroniserait en ligne persistent sur le disque et sont disponibles hors ligne, même lorsque l'utilisateur ou le système d'exploitation redémarre l'application. Cela signifie que votre application fonctionne comme si elle était en ligne en utilisant les données locales stockées dans le cache. Les rappels d'écoute continueront à se déclencher pour les mises à jour locales.

Le client Firebase Realtime Database conserve automatiquement une file d'attente de toutes les opérations d'écriture effectuées lorsque votre application est hors ligne. Lorsque la persistance est activée, cette file d'attente est également conservée sur le disque afin que toutes vos écritures soient disponibles lorsque l'utilisateur ou le système d'exploitation redémarre l'application. Lorsque l'application retrouve la connectivité, toutes les opérations sont envoyées au serveur Firebase Realtime Database.

Si votre application utilise Firebase Authentication , le client Firebase Realtime Database conserve le jeton d'authentification de l'utilisateur lors des redémarrages de l'application. Si le jeton d'authentification expire alors que votre application est hors ligne, le client suspend les opérations d'écriture jusqu'à ce que votre application authentifie à nouveau l'utilisateur, sinon les opérations d'écriture risquent d'échouer en raison des règles de sécurité.

Garder les données à jour

La base de données en temps réel Firebase synchronise et stocke une copie locale des données pour les auditeurs actifs. De plus, vous pouvez synchroniser des emplacements spécifiques.

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

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

Le client Firebase Realtime Database télécharge automatiquement les données à ces emplacements et les maintient synchronisées même si la référence n'a pas d'écouteurs actifs. Vous pouvez désactiver la synchronisation avec la ligne de code suivante.

scoresRef.keepSynced(false)
OfflineActivity.kt

scoresRef.keepSynced(false);
OfflineActivity.java

Par défaut, 10 Mo de données précédemment synchronisées sont mises en cache. Cela devrait suffire pour la plupart des applications. Si le cache dépasse sa taille configurée, la base de données en temps réel Firebase purge les données qui ont été utilisées le moins récemment. Les données maintenues synchronisées ne sont pas purgées du cache.

Interroger des données hors ligne

La base de données en temps réel Firebase stocke les données renvoyées par une requête pour une utilisation hors connexion. Pour les requêtes construites hors connexion, la base de données en temps réel Firebase continue de fonctionner pour les données précédemment chargées. Si les données demandées n'ont pas été chargées, la base de données en temps réel Firebase charge les données à partir du cache local. Lorsque la connectivité réseau est à nouveau disponible, les données se chargent et reflètent la requête.

Par exemple, ce code interroge les quatre derniers éléments d'une base de données en temps réel Firebase de scores

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

Supposons que l'utilisateur perd la connexion, se déconnecte et redémarre l'application. Alors qu'elle est toujours hors ligne, l'application recherche les deux derniers éléments à partir du même emplacement. Cette requête renverra avec succès les deux derniers éléments, car l'application a chargé les quatre éléments dans la requête ci-dessus.

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

Dans l'exemple précédent, le client Firebase Realtime Database déclenche des événements "enfant ajouté" pour les deux dinosaures les plus performants, en utilisant le cache persistant. Mais cela ne déclenchera pas d'événement 'value', car l'application n'a jamais exécuté cette requête en ligne.

Si l'application demandait les six derniers éléments hors ligne, elle obtiendrait immédiatement des événements "enfants ajoutés" pour les quatre éléments mis en cache. Lorsque l'appareil revient en ligne, le client Firebase Realtime Database se synchronise avec le serveur et obtient les deux derniers événements "enfant ajouté" et "valeur" pour l'application.

Traitement des transactions hors ligne

Toutes les transactions effectuées lorsque l'application est hors ligne sont mises en file d'attente. Une fois que l'application retrouve la connectivité réseau, les transactions sont envoyées au serveur de base de données en temps réel.

Comment fonctionne la déconnexion

Lorsque vous établissez une opération onDisconnect() , l'opération réside sur le serveur Firebase Realtime Database. Le serveur vérifie la sécurité pour s'assurer que l'utilisateur peut effectuer l'événement d'écriture demandé et informe votre application s'il n'est pas valide. Le serveur surveille alors la connexion. Si, à un moment quelconque, la connexion expire ou est activement fermée par le client de la base de données en temps réel, le serveur vérifie la sécurité une deuxième fois (pour s'assurer que l'opération est toujours valide), puis invoque l'événement.

Votre application peut utiliser le rappel sur l'opération d'écriture pour s'assurer que l' onDisconnect a été correctement attaché :

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 événement onDisconnect peut également être annulé en appelant .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

Horodatages du serveur

Les serveurs Firebase Realtime Database fournissent un mécanisme pour insérer les horodatages générés sur le serveur en tant que données. Cette fonctionnalité, associée à onDisconnect , fournit un moyen simple de noter de manière fiable l'heure à laquelle un client Realtime Database s'est déconnecté :

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

Décalage de l'horloge

Bien que firebase.database.ServerValue.TIMESTAMP soit beaucoup plus précis et préférable pour la plupart des opérations de lecture/écriture, il peut parfois être utile d'estimer le décalage d'horloge du client par rapport aux serveurs de la base de données Firebase Realtime. Vous pouvez joindre un rappel à l'emplacement /.info/serverTimeOffset pour obtenir la valeur, en millisecondes, que les clients Firebase Realtime Database ajoutent à l'heure locale signalée (heure d'époque en millisecondes) pour estimer l'heure du serveur. Notez que la précision de ce décalage peut être affectée par la latence du réseau, et est donc principalement utile pour découvrir des écarts importants (> 1 seconde) dans l'heure de l'horloge.

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