Fonctionnalités hors connexion sur les plates-formes Apple

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

Persistance sur disque

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

Lorsque vous activez la persistance sur disque, votre application écrit les données localement sur l' appareil. Elle peut ainsi conserver son état hors connexion, même si l'utilisateur ou le système d'exploitation la redémarre.

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

Swift

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
Database.database().isPersistenceEnabled = true

Objective-C

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
[FIRDatabase database].persistenceEnabled = YES;

Comportement de la persistance

En activant la persistance, toutes les données que le Firebase Realtime Database client synchronise en ligne sont conservées sur le disque et sont disponibles hors connexion, 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 d'écouteur continuent de 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 connexion. Lorsque la persistance est activée, cette file d'attente est également conservée sur le disque. Toutes vos écritures sont donc 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 Firebase Realtime Database serveur.

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

Actualiser les données

Le Firebase Realtime Database synchronise et stocke une copie locale des données pour les écouteurs actifs. De plus, vous pouvez synchroniser des emplacements spécifiques

Swift

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
let scoresRef = Database.database().reference(withPath: "scores")
scoresRef.keepSynced(true)

Objective-C

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
FIRDatabaseReference *scoresRef = [[FIRDatabase database] referenceWithPath:@"scores"];
[scoresRef keepSynced:YES];

Le client Firebase Realtime Database télécharge automatiquement les données à ces emplacements et les synchronise même si la référence ne comporte aucun écouteur actif. Vous pouvez désactiver la synchronisation avec la ligne de code suivante.

Swift

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
scoresRef.keepSynced(false)

Objective-C

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
[scoresRef keepSynced:NO];

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, le Firebase Realtime Database supprime les données les moins récemment utilisées. Les données synchronisées ne sont pas supprimées du cache.

Interroger les données hors connexion

Le Firebase Realtime Database stocke les données renvoyées par une requête pour une utilisation hors connexion. Pour les requêtes créées hors connexion, le Firebase Realtime Database continue de fonctionner pour les données précédemment chargées. Si les données demandées n'ont pas été chargées, le Firebase Realtime Database 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 Firebase Realtime Database de scores

Swift

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
let scoresRef = Database.database().reference(withPath: "scores")
scoresRef.queryOrderedByValue().queryLimited(toLast: 4).observe(.childAdded) { snapshot in
  print("The \(snapshot.key) dinosaur's score is \(snapshot.value ?? "null")")
}

Objective-C

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
FIRDatabaseReference *scoresRef = [[FIRDatabase database] referenceWithPath:@"scores"];
[[[scoresRef queryOrderedByValue] queryLimitedToLast:4]
    observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
      NSLog(@"The %@ dinosaur's score is %@", snapshot.key, snapshot.value);
    }];

Supposons que l'utilisateur perde la connexion, passe hors connexion et redémarre l'application. Toujours hors connexion, l'application interroge les deux derniers éléments du même emplacement. Cette requête renvoie les deux derniers éléments car l'application avait chargé les quatre éléments de la requête ci-dessus.

Swift

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
scoresRef.queryOrderedByValue().queryLimited(toLast: 2).observe(.childAdded) { snapshot in
  print("The \(snapshot.key) dinosaur's score is \(snapshot.value ?? "null")")
}

Objective-C

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
[[[scoresRef queryOrderedByValue] queryLimitedToLast:2]
    observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
      NSLog(@"The %@ dinosaur's score is %@", snapshot.key, snapshot.value);
    }];

Dans l'exemple précédent, le Firebase Realtime Database client déclenche des événements "enfant ajouté" pour les deux dinosaures ayant obtenu les meilleurs scores, à l'aide du cache conservé. Toutefois, il ne déclenche pas d'événement "valeur", car l'application n'a jamais exécuté cette requête en ligne.

Si l'application devait demander les six derniers éléments hors connexion, elle recevrait des événements "enfant ajouté" pour les quatre éléments mis en cache immédiatement. Lorsque l'appareil se reconnecte, le Firebase Realtime Database client se synchronise avec le serveur et reçoit les deux derniers événements « enfant ajouté » et l'événement « valeur » pour l'application.

Gérer les transactions hors connexion

Toutes les transactions effectuées lorsque l'application est hors connexion sont mises en file d'attente. Une fois que l'application retrouve la connectivité réseau, les transactions sont envoyées au serveur Realtime Database.

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 pouvez vouloir marquer un utilisateur comme "hors connexion" 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 correctement ou non, vous pouvez donc compter sur elles pour nettoyer les données, même si une connexion est interrompue ou qu'un client plante. Toutes les opérations d'écriture, y compris la définition, 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 d'une déconnexion à l'aide de la onDisconnect primitive :

Swift

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
let presenceRef = Database.database().reference(withPath: "disconnectmessage");
// Write a string when this client loses connection
presenceRef.onDisconnectSetValue("I disconnected!")

Objective-C

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
FIRDatabaseReference *presenceRef = [[FIRDatabase database] referenceWithPath:@"disconnectmessage"];
// Write a string when this client loses connection
[presenceRef onDisconnectSetValue:@"I disconnected!"];

Fonctionnement de onDisconnect

Lorsque vous établissez une opération onDisconnect(), celle-ci 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 ensuite la connexion. Si, à un moment donné, la connexion expire ou est fermée activement par le Realtime Database client, le serveur vérifie la sécurité une deuxième fois (pour s'assurer que l'opération est toujours valide), puis appelle l'événement.

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

Swift

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
presenceRef.onDisconnectRemoveValue { error, reference in
  if let error = error {
    print("Could not establish onDisconnect event: \(error)")
  }
}

Objective-C

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
[presenceRef onDisconnectRemoveValueWithCompletionBlock:^(NSError *error, FIRDatabaseReference *reference) {
  if (error != nil) {
    NSLog(@"Could not establish onDisconnect event: %@", error);
  }
}];

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

Swift

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
presenceRef.onDisconnectSetValue("I disconnected")
// some time later when we change our minds
presenceRef.cancelDisconnectOperations()

Objective-C

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
[presenceRef onDisconnectSetValue:@"I disconnected"];
// some time later when we change our minds
[presenceRef cancelDisconnectOperations];

Détecter l'état de la 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 connexion. Firebase Realtime Database fournit un emplacement spécial à /.info/connected qui est mis à jour chaque fois que l'état de la connexion du client Firebase Realtime Database change. Voici un exemple :

Swift

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
let connectedRef = Database.database().reference(withPath: ".info/connected")
connectedRef.observe(.value, with: { snapshot in
  if snapshot.value as? Bool ?? false {
    print("Connected")
  } else {
    print("Not connected")
  }
})

Objective-C

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
FIRDatabaseReference *connectedRef = [[FIRDatabase database] referenceWithPath:@".info/connected"];
[connectedRef observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
  if([snapshot.value boolValue]) {
    NSLog(@"connected");
  } else {
    NSLog(@"not connected");
  }
}];

/.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 "false", cela ne garantit pas qu'un autre client lira également "false".

Gérer la latence

Horodatages du serveur

Les serveurs Firebase Realtime Database fournissent un mécanisme permettant d'insérer des horodatages générés sur le serveur en tant que données. Combinée à onDisconnect, cette fonctionnalité permet de noter facilement et de manière fiable l'heure à laquelle un Realtime Database client s'est déconnecté :

Swift

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
let userLastOnlineRef = Database.database().reference(withPath: "users/morgan/lastOnline")
userLastOnlineRef.onDisconnectSetValue(ServerValue.timestamp())

Objective-C

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
FIRDatabaseReference *userLastOnlineRef = [[FIRDatabase database] referenceWithPath:@"users/morgan/lastOnline"];
[userLastOnlineRef onDisconnectSetValue:[FIRServerValue timestamp]];

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 de l'horloge du client par rapport aux serveurs de Firebase Realtime Database. Vous pouvez associer 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 de l'époque en millisecondes) afin d'estimer l'heure du serveur. Notez que la précision de ce décalage peut être affectée par la latence du réseau. Il est donc principalement utile pour détecter les écarts importants (> 1 seconde) dans l'heure de l'horloge.

Swift

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
let offsetRef = Database.database().reference(withPath: ".info/serverTimeOffset")
offsetRef.observe(.value, with: { snapshot in
  if let offset = snapshot.value as? TimeInterval {
    print("Estimated server time in milliseconds: \(Date().timeIntervalSince1970 * 1000 + offset)")
  }
})

Objective-C

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
FIRDatabaseReference *offsetRef = [[FIRDatabase database] referenceWithPath:@".info/serverTimeOffset"];
[offsetRef observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
  NSTimeInterval offset = [(NSNumber *)snapshot.value doubleValue];
  NSTimeInterval estimatedServerTimeMs = [[NSDate date] timeIntervalSince1970] * 1000.0 + offset;
  NSLog(@"Estimated server time: %0.3f", estimatedServerTimeMs);
}];

Exemple d'application de présence

En combinant les opérations de déconnexion avec la surveillance de l'état de la 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 des données à un emplacement de base de données pour indiquer si un Realtime Database client est en ligne ou non. Les clients définissent cet emplacement sur "true" lorsqu' ils se connectent et sur 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é comme étant en ligne, afin d'éviter toute condition de concurrence si la connexion réseau du client est perdue avant que les deux commandes puissent être envoyées au serveur.

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

Swift

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
// 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
let myConnectionsRef = Database.database().reference(withPath: "users/morgan/connections")

// stores the timestamp of my last disconnect (the last time I was seen online)
let lastOnlineRef = Database.database().reference(withPath: "users/morgan/lastOnline")

let connectedRef = Database.database().reference(withPath: ".info/connected")

connectedRef.observe(.value, with: { snapshot in
  // only handle connection established (or I've reconnected after a loss of connection)
  guard snapshot.value as? Bool ?? false else { return }

  // add this device to my connections list
  let con = myConnectionsRef.childByAutoId()

  // when this device disconnects, remove it.
  con.onDisconnectRemoveValue()

  // The onDisconnect() call is before the call to set() itself. This is to avoid a race condition
  // where you set the user's presence to true and the client disconnects before the
  // onDisconnect() operation takes effect, leaving a ghost user.

  // this value could contain info about the device or a timestamp instead of just true
  con.setValue(true)

  // when I disconnect, update the last time I was seen online
  lastOnlineRef.onDisconnectSetValue(ServerValue.timestamp())
})

Objective-C

Remarque : Ce produit Firebase n'est pas disponible sur la cible App Clip. 
// 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
FIRDatabaseReference *myConnectionsRef = [[FIRDatabase database] referenceWithPath:@"users/morgan/connections"];

// stores the timestamp of my last disconnect (the last time I was seen online)
FIRDatabaseReference *lastOnlineRef = [[FIRDatabase database] referenceWithPath:@"users/morgan/lastOnline"];

FIRDatabaseReference *connectedRef = [[FIRDatabase database] referenceWithPath:@".info/connected"];
[connectedRef observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
  if([snapshot.value boolValue]) {
    // connection established (or I've reconnected after a loss of connection)

    // add this device to my connections list
    FIRDatabaseReference *con = [myConnectionsRef childByAutoId];

    // when this device disconnects, remove it
    [con onDisconnectRemoveValue];

    // The onDisconnect() call is before the call to set() itself. This is to avoid a race condition
    // where you set the user's presence to true and the client disconnects before the
    // onDisconnect() operation takes effect, leaving a ghost user.

    // this value could contain info about the device or a timestamp instead of just true
    [con setValue:@YES];


    // when I disconnect, update the last time I was seen online
    [lastOnlineRef onDisconnectSetValue:[FIRServerValue timestamp]];
  }
}];