Activation des fonctionnalités hors ligne sur Android

Les applications Firebase fonctionnent même si votre application perd temporairement sa connexion réseau. De plus, Firebase fournit des outils pour conserver les données localement, gérer la présence et gérer la latence.

Persistance du disque

Les applications Firebase gèrent automatiquement les interruptions temporaires du réseau. Les données mises en cache sont disponibles hors ligne et Firebase renvoie toutes les écritures lorsque la connectivité réseau est restaurée.

Lorsque vous activez la persistance du disque, votre application écrit les données localement sur l'appareil afin qu'elle puisse conserver son état hors ligne, même si l'utilisateur ou le système d'exploitation redémarre l'application.

Vous pouvez activer la persistance du disque avec une seule ligne de code.

Kotlin+KTX

Firebase.database.setPersistenceEnabled(true)

Java

FirebaseDatabase.getInstance().setPersistenceEnabled(true);

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 elle le ferait en ligne en utilisant les données locales stockées dans le cache. Les rappels des auditeurs continueront à être déclenchés 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 pourraient échouer en raison des règles de sécurité.

Garder les données à jour

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

Kotlin+KTX

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

Java

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

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 aucun écouteur actif. Vous pouvez désactiver la synchronisation avec la ligne de code suivante.

Kotlin+KTX

scoresRef.keepSynced(false)

Java

scoresRef.keepSynced(false);

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 les moins récemment utilisées. Les données synchronisées ne sont pas purgées du cache.

Interrogation de données hors ligne

La base de données Firebase Realtime stocke les données renvoyées par une requête pour les utiliser hors ligne. Pour les requêtes créées hors ligne, la base de données en temps réel Firebase continue de fonctionner avec 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 Firebase Realtime charge les données à partir du cache local. Lorsque la connectivité réseau est à nouveau disponible, les données se chargent et refléteront la requête.

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

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}")
    }

    // ...
})

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());
    }

    // ...
});

Supposons que l'utilisateur perd la connexion, se déconnecte et redémarre l'application. Lorsqu'elle est toujours hors ligne, l'application recherche les deux derniers éléments 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.

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}")
    }

    // ...
})

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());
    }

    // ...
});

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

Si l'application demandait les six derniers éléments en mode hors connexion, elle obtiendrait immédiatement des événements « enfant ajouté » 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.

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

Gérer la présence

Dans les applications en temps réel, il est souvent utile de détecter quand les clients se connectent et se déconnectent. Par exemple, vous souhaiterez peut-être marquer un utilisateur comme « hors ligne » lorsque son client se déconnecte.

Les clients Firebase Database fournissent des primitives simples que vous pouvez utiliser pour écrire dans la base de données lorsqu'un client se déconnecte des serveurs Firebase Database. Ces mises à jour se produisent que le client se déconnecte proprement ou non, vous pouvez donc compter sur elles pour nettoyer les données même si une connexion est interrompue ou si un client plante. Toutes les opérations d'écriture, y compris la configuration, la mise à jour et la suppression, peuvent être effectuées lors d'une déconnexion.

Voici un exemple simple d'écriture de données lors de la déconnexion à l'aide de la primitive onDisconnect :

Kotlin+KTX

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

Java

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

Comment fonctionne onDisconnect

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 si elle n'est pas valide. Le serveur surveille ensuite la connexion. Si, à un moment donné, la connexion expire ou est activement fermée par le client Realtime Database, le serveur vérifie la sécurité une seconde fois (pour s'assurer que l'opération est toujours valide), puis appelle l'événement.

Votre application peut utiliser le rappel lors de l'opération d'écriture pour garantir que le onDisconnect a été correctement attaché :

Kotlin+KTX

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

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());
        }
    }
});

Un événement onDisconnect peut également être annulé en appelant .cancel() :

Kotlin+KTX

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

Java

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

Détection de l'état de connexion

Pour de nombreuses fonctionnalités liées à la présence, il est utile que votre application sache quand elle est en ligne ou hors ligne. Firebase Realtime Database fournit un emplacement spécial dans /.info/connected qui est mis à jour chaque fois que l'état de connexion du client Firebase Realtime Database change. Voici un exemple:

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")
    }
})

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");
    }
});

/.info/connected est une valeur booléenne qui n'est pas synchronisée entre les clients Realtime Database car la valeur dépend de l'état du client. En d’autres termes, si un client lit /.info/connected comme faux, cela ne garantit pas qu’un client distinct lira également faux.

Sur Android, Firebase gère automatiquement l'état de la connexion pour réduire l'utilisation de la bande passante et de la batterie. Lorsqu'un client n'a aucun écouteur actif, aucune opération d'écriture ou onDisconnect en attente et n'est pas explicitement déconnecté par la méthode goOffline , Firebase ferme la connexion après 60 secondes d'inactivité.

Gestion de la latence

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é, combinée à onDisconnect , offre un moyen simple de noter de manière fiable l'heure à laquelle un client Realtime Database s'est déconnecté :

Kotlin+KTX

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

Java

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

Inclinaison 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 en temps réel Firebase. Vous pouvez joindre un rappel à l'emplacement /.info/serverTimeOffset pour obtenir la valeur, en millisecondes, que les clients de 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.

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")
    }
})

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");
    }
});

Exemple d'application de présence

En combinant les opérations de déconnexion avec la surveillance de l'état de connexion et les horodatages du serveur, vous pouvez créer un système de présence des utilisateurs. Dans ce système, chaque utilisateur stocke les données dans un emplacement de base de données pour indiquer si un client de base de données en temps réel est en ligne ou non. Les clients définissent cet emplacement sur vrai lorsqu'ils se connectent et un horodatage lorsqu'ils se déconnectent. Cet horodatage indique la dernière fois que l'utilisateur donné était en ligne.

Notez que votre application doit mettre en file d'attente les opérations de déconnexion avant qu'un utilisateur ne soit marqué en ligne, afin d'éviter toute situation de concurrence critique en cas de perte de la connexion réseau du client avant que les deux commandes puissent être envoyées au serveur.

Voici un système simple de présence des utilisateurs :

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")
    }
})

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");
    }
});