Premiers pas avec Firebase Authentication en C++

Vous pouvez utiliser Firebase Authentication pour autoriser les utilisateurs à se connecter à votre appli avec une ou d'autres méthodes de connexion, y compris la connexion par adresse e-mail et par mot de passe, et d'identité fédérée tels que Google Sign-In et Facebook Login. Ce ce tutoriel vous montre comment ajouter Firebase Authentication adresse e-mail et mot de passe de connexion à votre application.

Associer votre projet C++ à Firebase

Avant de pouvoir utiliser Firebase Authentication, 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.

  • Ajoutez le SDK C++ Firebase à votre projet C++.

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

Inscrire de nouveaux utilisateurs

Créez un formulaire permettant aux nouveaux utilisateurs de s'inscrire à votre appli à l'aide de leur une adresse e-mail et un mot de passe. Lorsqu'un utilisateur remplit le formulaire, validez le l'adresse e-mail et le mot de passe fournis par l'utilisateur, puis transmettez-les au Méthode CreateUserWithEmailAndPassword:

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

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

Par exemple, à l'aide d'un "Future" :

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

// The lambda has the same signature as the callback function.
result.OnCompletion(
    [](const firebase::Future<firebase::auth::AuthResult>& 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);

Pour utiliser l'interrogation, procédez comme dans l'exemple suivant dans la boucle de mise à jour de votre jeu :

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

Se connecter à un compte existant

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

firebase::Future<firebase::auth::AuthResult> 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, associez un écouteur à l'objet d'authentification global. Cet écouteur est appelé dès que l'utilisateur se connecte les changements d'état. Comme l'écouteur ne s'exécute qu'une fois que l'objet d'authentification est entièrement initialisé. Une fois les appels réseau effectués, il est préférable pour obtenir des informations sur l'utilisateur connecté.

Créez l'écouteur en implémentant la classe abstraite firebase::auth::AuthStateListener. Par exemple, pour créer un écouteur qui obtient des informations sur l'utilisateur lorsqu'il se connecte :

class MyAuthStateListener : public firebase::auth::AuthStateListener {
 public:
  void OnAuthStateChanged(firebase::auth::Auth* auth) override {
    firebase::auth::User user = auth.current_user();
    if (user.is_valid()) {
      // 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");
    }
    // ...
  }
};

Associez l'écouteur au paramètre de l'objet firebase::auth::Auth. Méthode AddAuthStateListener:

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

Étapes suivantes

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