Premiers pas avec l'authentification Firebase en C++

Vous pouvez utiliser l'authentification Firebase pour permettre aux utilisateurs de se connecter à votre application à l'aide d'une ou plusieurs méthodes de connexion, y compris la connexion par adresse e-mail et mot de passe, et les fournisseurs d'identité fédérés tels que Google Sign-in et Facebook Login. Ce didacticiel vous permet de démarrer avec Firebase Authentication en vous montrant comment ajouter une adresse e-mail et un mot de passe de connexion à votre application.

Connectez votre projet C++ à Firebase

Avant de pouvoir utiliser Firebase authentification , vous devez:

  • Enregistrez votre projet C++ et configurez-le pour utiliser Firebase.

    Si votre projet C++ utilise déjà Firebase, il est déjà enregistré et configuré pour Firebase.

  • Ajouter le Firebase C ++ SDK à votre projet C de.

Notez que l' ajout Firebase à votre projet C ++ implique des tâches à la fois dans la console Firebase et dans votre projet open C ++ (par exemple, vous téléchargez des fichiers de configuration Firebase de la console, puis les déplacer dans votre projet C ++).

Inscrivez de nouveaux utilisateurs

Créez un formulaire qui permet aux nouveaux utilisateurs de s'inscrire à votre application en utilisant leur adresse e-mail et un mot de passe. Lorsqu'un utilisateur remplit le formulaire, valider l'adresse e - mail et mot de passe fourni par l'utilisateur, puis les passer à la CreateUserWithEmailAndPassword méthode:

firebase::Future<firebase::auth::User*> result =
    auth->CreateUserWithEmailAndPassword(email, password);

Vous pouvez vérifier l'état de l'opération de création de compte , soit par l' enregistrement d' un rappel sur le CreateUserWithEmailAndPasswordLastResult objet futur, ou, si vous écrivez un jeu ou une application avec une sorte de boucle de mise à jour périodique, en interrogeant le statut dans la boucle de mise à jour.

Par exemple, en utilisant un futur :

firebase::Future<firebase::auth::User*> result =
    auth->CreateUserWithEmailAndPasswordLastResult();

// The lambda has the same signature as the callback function.
result.OnCompletion(
    [](const firebase::Future<firebase::auth::User*>& result,
       void* user_data) {
      // `user_data` is the same as &my_program_context, below.
      // Note that we can't capture this value in the [] because std::function
      // is not supported by our minimum compiler spec (which is pre C++11).
      MyProgramContext* program_context =
          static_cast<MyProgramContext*>(user_data);

      // Process create user result...
      (void)program_context;
    },
    &my_program_context);

Ou, pour utiliser le sondage, faites quelque chose comme l'exemple suivant dans la boucle de mise à jour de votre jeu :

firebase::Future<firebase::auth::User*> result =
    auth->CreateUserWithEmailAndPasswordLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    firebase::auth::User* user = *result.result();
    printf("Create user succeeded for email %s\n", user->email().c_str());
  } else {
    printf("Created user failed with error '%s'\n", result.error_message());
  }
}

Connectez-vous aux utilisateurs existants

Créez un formulaire permettant aux utilisateurs existants de se connecter à l'aide de leur adresse e-mail et de leur mot de passe. Lorsqu'un utilisateur remplit le formulaire, appelez la SignInWithEmailAndPassword méthode:

firebase::Future<firebase::auth::User*> result =
    auth->SignInWithEmailAndPassword(email, password);

Obtenez le résultat de l'opération de connexion de la même manière que vous avez obtenu le résultat de l'inscription.

Définir un écouteur d'état d'authentification et obtenir les données du compte

Pour répondre aux événements de connexion et de déconnexion, attachez un écouteur à l'objet d'authentification globale. Cet écouteur est appelé chaque fois que l'état de connexion de l'utilisateur change. Étant donné que l'écouteur s'exécute uniquement après l'initialisation complète de l'objet d'authentification et la fin des appels réseau, c'est le meilleur endroit pour obtenir des informations sur l'utilisateur connecté.

Créer l'auditeur en mettant en œuvre le firebase::auth::AuthStateListener classe abstraite. Par exemple, pour créer un écouteur qui obtient des informations sur l'utilisateur lorsqu'un utilisateur se connecte avec succès :

class MyAuthStateListener : public firebase::auth::AuthStateListener {
 public:
  void OnAuthStateChanged(firebase::auth::Auth* auth) override {
    firebase::auth::User* user = auth->current_user();
    if (user != nullptr) {
      // User is signed in
      printf("OnAuthStateChanged: signed_in %s\n", user->uid().c_str());
      const std::string displayName = user->DisplayName();
      const std::string emailAddress = user->Email();
      const std::string photoUrl = user->PhotoUrl();
    } else {
      // User is signed out
      printf("OnAuthStateChanged: signed_out\n");
    }
    // ...
  }
};

Attachez l'auditeur avec le firebase::auth::Auth de l' objet AddAuthStateListener méthode:

MyAuthStateListener state_change_listener;
auth->AddAuthStateListener(&state_change_listener);

Prochaines étapes

Découvrez comment ajouter la prise en charge d'autres fournisseurs d'identité et de comptes invités anonymes :