Google est engagé à faire progresser l'équité raciale pour les communautés noires. Regarde comment.
Cette page a été traduite par l'API Cloud Translation.
Switch to English

Récupération de données avec Firebase en temps réel pour la base de données C ++

Ce document couvre les bases de la récupération de données et comment commander et de filtrage des données Firebase.

Avant que tu commences

Assurez - vous que la configuration de votre application AVONS et peut accéder à la base de données couvertes dans le Get Started guide.

Récupération des données

Firebase données sont récupérées soit par un appel d'une durée de GetValue() ou de la fixation à un ValueListener sur un FirebaseDatabase référence. L'auditeur de valeur est appelée une fois pour l'état initial des données et à nouveau à tout moment les changements de données.

Obtenez un DatabaseReference

Pour les données d'écriture à la base de données, vous avez besoin d' une instance de DatabaseReference :

    // Get the root reference location of the database.
    firebase::database::DatabaseReference dbref = database->GetReference();

Lire les données une fois

Vous pouvez utiliser le GetValue() méthode pour lire un instantané statique du contenu à un chemin donné une fois. Le résultat de la tâche contiendra un instantané contenant toutes les données à cet endroit, y compris les données de l'enfant. S'il n'y a pas de données, l'instantané retournée est null .

  firebase::Future<firebase::database::DataSnapshot> result =
    dbRef.GetReference("Leaders").GetValue();

Au moment de la demande a été faite, mais nous devons attendre pour l'avenir de complet avant de pouvoir lire la valeur. Depuis les jeux fonctionnent généralement dans une boucle, et sont moins rappel que d'autres applications entraînées, vous aurez généralement de sondage pour l'achèvement.

  // In the game loop that polls for the result...

  if (result.status() != firebase::kFutureStatusPending) {
    if (result.status() != firebase::kFutureStatusComplete) {
      LogMessage("ERROR: GetValue() returned an invalid result.");
      // Handle the error...
    } else if (result.error() != firebase::database::kErrorNone) {
      LogMessage("ERROR: GetValue() returned error %d: %s", result.error(),
                 result.error_message());
      // Handle the error...
    } else {
      firebase::database::DataSnapshot snapshot = result.result();
      // Do something with the snapshot...
    }
  }

Cela montre une erreur de contrôle de base, voir le firebase :: Future référence pour plus d' informations sur la vérification des erreurs et des façons de déterminer quand le résultat est prêt.

Écouter les événements

Vous pouvez ajouter des écouteurs pour vous abonner sur les modifications des données:

ValueListener classe de base

Rappeler utilisation typique
OnValueChanged Lire et écouter les modifications apportées à l'ensemble du contenu d'un chemin.

OnChildListener classe de base

OnChildAdded Récupérer des listes d'éléments ou d'écouter des ajouts à la liste des articles. Utilisation suggérée avec OnChildChanged et OnChildRemoved pour surveiller les changements aux listes.
OnChildChanged Écouter les modifications apportées aux éléments d'une liste. Utilisation avec OnChildAdded et OnChildRemoved pour surveiller les changements aux listes.
OnChildRemoved Écoutez les articles étant retirés de la liste. Utilisation avec OnChildAdded et OnChildChanged aux changements du moniteur aux listes.
OnChildMoved Écouter les modifications apportées à l'ordre des éléments dans une liste ordonnée. OnChildMoved callbacks suivent toujours les OnChildChanged callbacks en raison de l' évolution ( en fonction de votre commande par méthode actuelle) l'ordre de l'élément.

classe ValueListener

Vous pouvez utiliser les OnValueChanged callbacks pour vous abonner à modifier le contenu à un chemin donné. Ce rappel est déclenchée une fois quand l'auditeur est attaché et à nouveau à chaque fois que les données, y compris les enfants, les changements. Le rappel est passé un instantané contenant toutes les données à cet endroit, y compris les données de l'enfant. S'il n'y a pas de données, l'instantané retournée est null .

L'exemple suivant montre un jeu de récupérer les scores d'un leaderboard de la base de données:

  class LeadersValueListener : public firebase::database::ValueListener {
   public:
    void OnValueChanged(
        const firebase::database::DataSnapshot& snapshot) override {
      // Do something with the data in snapshot...
    }
    void OnCancelled(const firebase::database::Error& error_code,
                     const char* error_message) override {
      LogMessage("ERROR: LeadersValueListener canceled: %d: %s", error_code,
                 error_message);
    }
  };

  // Elsewhere in the code...

  LeadersValueListener* listener = new LeadersValueListener();
  firebase::Future<firebase::database::DataSnapshot> result =
    dbRef.GetReference("Leaders").AddValueListener(listener);

L' Future&ltDataSnaphot&gt résultat contient les données à l'emplacement spécifié dans la base de données au moment de l'événement. Appel value() sur un rendement de l' instantané d' un Variant représentant les données.

Dans cet exemple, la OnCancelled méthode est également surchargée pour voir si la lecture est annulée. Par exemple, une lecture peut être annulée si le client n'a pas l'autorisation de lire à partir d'un emplacement de base de données Firebase. La database::Error de database::Error indique pourquoi l'échec.

classe ChildListener

Les événements d'enfants sont déclenchées en réponse à des opérations spécifiques qui se produisent aux enfants d'un noeud à partir d' une opération, comme un enfant nouveau ajouté par l'intermédiaire du PushChild() méthode ou un enfant d' être mis à jour par l'intermédiaire du UpdateChildren() méthode. Chacun de ces ensemble peut être utile pour écouter des modifications à un noeud spécifique dans une base de données. Par exemple, un jeu pourrait utiliser ces méthodes ainsi que pour surveiller l'activité dans les commentaires d'une session de jeu, comme indiqué ci-dessous:

  class SessionCommentsChildListener : public firebase::database::ChildListener {
   public:
    void OnChildAdded(const firebase::database::DataSnapshot& snapshot,
                      const char* previous_sibling) override {
      // Do something with the data in snapshot ...
    }
    void OnChildChanged(const firebase::database::DataSnapshot& snapshot,
                        const char* previous_sibling) override {
      // Do something with the data in snapshot ...
    }
    void OnChildRemoved(
        const firebase::database::DataSnapshot& snapshot) override {
      // Do something with the data in snapshot ...
    }
    void OnChildMoved(const firebase::database::DataSnapshot& snapshot,
                      const char* previous_sibling) override {
      // Do something with the data in snapshot ...
    }
    void OnCancelled(const firebase::database::Error& error_code,
                     const char* error_message) override {
      LogMessage("ERROR: SessionCommentsChildListener canceled: %d: %s",
                 error_code, error_message);
    }
  };

  // elsewhere ....

  SessionCommentsChildListener* listener = new SessionCommentsChildListener();
  firebase::Future<firebase::database::DataSnapshot> result =
    dbRef.GetReference("GameSessionComments").AddChildListener(listener);

Le OnChildAdded rappel est généralement utilisé pour récupérer une liste d'éléments dans une base de données Firebase. Le OnChildAdded rappel est appelée une fois pour chaque enfant existant, puis de nouveau à chaque fois qu'un nouvel enfant est ajouté au chemin d' accès spécifié. L'auditeur est passé un instantané contenant les données du nouvel enfant.

Le OnChildChanged rappel est appelé à chaque fois qu'un nœud enfant est modifié. Cela inclut toutes les modifications aux descendants du nœud enfant. Il est généralement utilisé conjointement avec les OnChildAdded et OnChildRemoved appels pour répondre aux modifications apportées à une liste d'éléments. L'instantané transmis à l'écouteur contient les données mises à jour pour l'enfant.

Le OnChildRemoved rappel est déclenchée lorsqu'un enfant est enlevé immédiatement. Il est généralement utilisé conjointement avec les OnChildAdded et OnChildChanged callbacks. L'instantané est passé à la fonction de rappel contient les données pour l'enfant enlevé.

Le OnChildMoved rappel est déclenché chaque fois que le OnChildChanged appel est soulevée par une mise à jour qui provoque réordonnancement de l'enfant. Il est utilisé avec des données qui est commandé avec OrderByChild ou OrderByValue .

Le tri et le filtrage des données

Vous pouvez utiliser la base de données en temps réel de Query de classe pour récupérer des données triées par clé, en valeur, ou valeur d'un enfant. Vous pouvez également filtrer le résultat à un nombre Sorted spécifique de résultats ou une gamme de clés ou des valeurs.

Trier les données

Pour récupérer les données triées, commencez en spécifiant un de l'ordre par des méthodes afin de déterminer comment les résultats sont triés:

Méthode Usage
OrderByChild() résultats Trier par la valeur d'une clé enfant spécifié.
OrderByKey() résultats Trier par clés enfants.
OrderByValue() résultats Trier par les valeurs de l'enfant.

Vous ne pouvez utiliser qu'un seul ordre par la méthode à la fois. Appeler un ordre par la méthode plusieurs fois dans la même requête renvoie une erreur.

L'exemple suivant montre comment vous pouvez souscrire à un leaderboard score commandé par le score.

  firebase::database::Query query =
    dbRef.GetReference("Leaders").OrderByChild("score");

  // To get the resulting DataSnapshot either use query.GetValue() and poll the
  // future, or use query.AddValueListener() and register to handle the
  // OnValueChanged callback.

Ceci définit un firebase::Query que lorsqu'il est combiné avec un ValueListener synchronise le client avec le leaderboard dans la base de données, commandé par le score de chaque entrée. Vous pouvez en savoir plus sur la structuration de vos données de manière efficace dans la structure de votre base de données .

L'appel à la OrderByChild() méthode spécifie la clé de l' enfant à l' ordre par les résultats. Dans ce cas, les résultats sont triés par la valeur du "score" valeur de chaque enfant. Pour plus d' informations sur d' autres types de données sont ordonnées, voir comment la requête des données est ordonnée .

filtrage des données

Pour filtrer les données, vous pouvez combiner des méthodes limites ou plage avec un ordre par la méthode lors de la construction d'une requête.

Méthode Usage
LimitToFirst() Définit le nombre maximum d'éléments pour revenir dès le début de la liste ordonnée des résultats.
LimitToLast() Définit le nombre maximum d'éléments pour revenir de la fin de la liste ordonnée des résultats.
StartAt() éléments de retour supérieure ou égale à la clé spécifiée ou une valeur en fonction de l'ordre par la méthode choisie.
EndAt() éléments de retour inférieure ou égale à la clé spécifiée ou une valeur en fonction de l'ordre par la méthode choisie.
EqualTo() éléments de retour égale à la clé spécifiée ou une valeur en fonction de l'ordre par la méthode choisie.

Contrairement à l'ordre par des méthodes, vous pouvez combiner plusieurs limites ou fonctions gamme. Par exemple, vous pouvez combiner les StartAt() et EndAt() méthodes pour limiter les résultats à une plage de valeurs.

Même quand il n'y a qu'une seule pour la requête, l'instantané est toujours une liste; il contient un seul élément.

Limiter le nombre de résultats

Vous pouvez utiliser le LimitToFirst() et LimitToLast() méthodes pour définir un nombre maximum d'enfants pour être synchronisés un rappel donné. Par exemple, si vous utilisez LimitToFirst() pour définir une limite de 100, vous recevez d' abord que jusqu'à 100 OnChildAdded callbacks. Si vous avez moins de 100 éléments stockés dans la base de données Firebase, un OnChildAdded feux de rappel pour chaque élément.

Comme éléments changent, vous recevez OnChildAdded callbacks pour les éléments qui entrent dans la requête et OnChildRemoved callbacks pour les articles qui abandonnent pour que le nombre total de séjours à 100.

Par exemple, le code ci-dessous renvoie le haut score de d'un leaderboard:

  firebase::database::Query query =
    dbRef.GetReference("Leaders").OrderByChild("score").LimitToLast(1);

  // To get the resulting DataSnapshot either use query.GetValue() and poll the
  // future, or use query.AddValueListener() and register to handle the
  // OnValueChanged callback.

Filtrer par clé ou valeur

Vous pouvez utiliser StartAt() , EndAt() , et EqualTo() choisir départ arbitraire, la fin et les points d'équivalence pour les requêtes. Cela peut être utile pour les données ou paginant trouver des articles avec des enfants qui ont une valeur spécifique.

Comment les données de requête est commandé

Cette section explique comment les données sont triées par chacun de l'ordre par des méthodes dans la Query classe.

OrderByChild

Lors de l' utilisation OrderByChild() , les données qui contient la clé de l' enfant spécifié est ordonné comme suit:

  1. Les enfants ayant une null valeur de la clé de l' enfant spécifié viennent en premier.
  2. Les enfants ayant une valeur de false pour la clé de l' enfant spécifié viennent ensuite. Si plusieurs enfants ont une valeur de false , ils sont triés lexicographique par clé.
  3. Les enfants ayant une valeur de true pour la clé de l' enfant spécifié viennent ensuite. Si plusieurs enfants ont une valeur de true , ils sont classés par ordre lexicographique clé.
  4. Les enfants ayant une valeur numérique viennent ensuite, triées par ordre croissant. Si plusieurs enfants ont la même valeur numérique pour le noeud enfant spécifié, ils sont classés par clé.
  5. Les chaînes viennent après les chiffres et sont classés lexicographique dans l'ordre croissant. Si plusieurs enfants ont la même valeur pour le noeud enfant spécifié, ils sont commandés lexicographique par clé.
  6. Les objets viennent en dernier et sont classés par ordre lexicographique clé dans l'ordre croissant.

OrderByKey

Lors de l' utilisation OrderByKey() pour trier vos données, les données sont renvoyées en ordre croissant par clé.

  1. Les enfants avec une clé qui peut être analysé comme un entier de 32 bits viennent d'abord, classés par ordre croissant.
  2. Les enfants ayant une valeur de chaîne comme clé viennent ensuite, triées lexicographique dans l'ordre croissant.

OrderByValue

Lorsque vous utilisez OrderByValue() , les enfants sont classés par leur valeur. Les critères de classement sont les mêmes que dans OrderByChild() , à l' exception de la valeur du nœud est utilisé au lieu de la valeur d'une clé enfant spécifié.

Prochaines étapes