Catch up on everthing we announced at this year's Firebase Summit. Learn more

Authentification avec Firebase à l'aide de comptes basés sur un mot de passe à l'aide de C++

Vous pouvez utiliser l'authentification Firebase pour permettre à vos utilisateurs de s'authentifier auprès de Firebase à l'aide de leurs adresses e-mail et mots de passe, et pour gérer les comptes basés sur un mot de passe de votre application.

Avant que tu commences

  1. Ajouter Firebase à votre projet C ++ .
  2. Si vous n'êtes pas encore connecté votre application à votre projet Firebase, faites à partir de la console Firebase .
  3. Activer la connexion par e-mail/mot de passe :
    1. Dans la console Firebase , ouvrez la section Auth.
    2. Sur l'onglet Connexion méthode, activez l' ouverture de session Email / mot de passe et cliquez sur Enregistrer méthode.

Accédez au firebase::auth::Auth classe

La Auth classe est la passerelle pour tous les appels API.
  1. Ajoutez les fichiers d' en- tête et Auth App:
    #include "firebase/app.h"
    #include "firebase/auth.h"
    
  2. Dans votre code d'initialisation, créez un firebase::App classe.
    #if defined(__ANDROID__)
      firebase::App* app =
          firebase::App::Create(firebase::AppOptions(), my_jni_env, my_activity);
    #else
      firebase::App* app = firebase::App::Create(firebase::AppOptions());
    #endif  // defined(__ANDROID__)
    
  3. Acquérir les firebase::auth::Auth classe pour votre firebase::App . Il y a un à un entre les App et Auth .
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
    

Créer un compte basé sur un mot de passe

Pour créer un nouveau compte utilisateur avec un mot de passe, procédez comme suit dans le code de connexion de votre application :

  1. Lorsqu'un nouvel utilisateur s'inscrit à l'aide du formulaire d'inscription de votre application, effectuez toutes les étapes de validation de nouveau compte requises par votre application, par exemple en vérifiant que le mot de passe du nouveau compte a été correctement saisi et répond à vos exigences de complexité.
  2. Créer un nouveau compte en passant la nouvelle adresse e - mail de l' utilisateur et mot de passe Auth::CreateUserWithEmailAndPassword :
    firebase::Future<firebase::auth::User*> result =
        auth->CreateUserWithEmailAndPassword(email, password);
    
  3. Si votre programme est une boucle de mise à jour qui fonctionne régulièrement (disons à 30 ou 60 fois par seconde), vous pouvez vérifier les résultats une fois par jour avec Auth::CreateUserWithEmailAndPasswordLastResult :
    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());
      }
    }
    
    Ou, si votre programme est l' événement commandé, vous pouvez préférer pour enregistrer un rappel sur l'avenir .

Connectez-vous à un utilisateur avec une adresse e-mail et un mot de passe

Les étapes de connexion d'un utilisateur avec un mot de passe sont similaires aux étapes de création d'un nouveau compte. Dans la fonction de connexion de votre application, procédez comme suit :

  1. Lorsqu'un utilisateur se connecte à votre application, passer l'adresse e - mail de l' utilisateur et mot de passe firebase::auth::Auth::SignInWithEmailAndPassword :
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithEmailAndPassword(email, password);
    
  2. Si votre programme est une boucle de mise à jour qui fonctionne régulièrement (disons à 30 ou 60 fois par seconde), vous pouvez vérifier les résultats une fois par jour avec Auth::SignInWithEmailAndPasswordLastResult :
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithEmailAndPasswordLastResult();
    if (result.status() == firebase::kFutureStatusComplete) {
      if (result.error() == firebase::auth::kAuthErrorNone) {
        firebase::auth::User* user = *result.result();
        printf("Sign in succeeded for email %s\n", user->email().c_str());
      } else {
        printf("Sign in failed with error '%s'\n", result.error_message());
      }
    }
    
    Ou, si votre programme est l' événement commandé, vous pouvez préférer pour enregistrer un rappel sur l'avenir .

Enregistrer un rappel sur un Future

Certains programmes ont Update à Update des fonctions qui sont appelées 30 ou 60 fois par seconde. Par exemple, de nombreux jeux suivent ce modèle. Ces programmes peuvent appeler les LastResult fonctions au sondage des appels asynchrones. Cependant, si votre programme est piloté par des événements, vous préférerez peut-être enregistrer des fonctions de rappel. Une fonction de rappel est appelée à la fin du Future.
void OnCreateCallback(const firebase::Future<firebase::auth::User*>& result,
                      void* user_data) {
  // The callback is called when the Future enters the `complete` state.
  assert(result.status() == firebase::kFutureStatusComplete);

  // Use `user_data` to pass-in program context, if you like.
  MyProgramContext* program_context = static_cast<MyProgramContext*>(user_data);

  // Important to handle both success and failure situations.
  if (result.error() == firebase::auth::kAuthErrorNone) {
    firebase::auth::User* user = *result.result();
    printf("Create user succeeded for email %s\n", user->email().c_str());

    // Perform other actions on User, if you like.
    firebase::auth::User::UserProfile profile;
    profile.display_name = program_context->display_name;
    user->UpdateUserProfile(profile);

  } else {
    printf("Created user failed with error '%s'\n", result.error_message());
  }
}

void CreateUser(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  firebase::Future<firebase::auth::User*> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // `&my_program_context` is passed verbatim to OnCreateCallback().
  result.OnCompletion(OnCreateCallback, &my_program_context);
}
La fonction de rappel peut aussi être un lambda, si vous préférez.
void CreateUserUsingLambda(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  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);
}

Prochaines étapes

Une fois qu'un utilisateur se connecte pour la première fois, un nouveau compte d'utilisateur est créé et lié aux informations d'identification, c'est-à-dire le nom d'utilisateur et le mot de passe, le numéro de téléphone ou les informations du fournisseur d'autorisation, avec lesquelles l'utilisateur s'est connecté. Ce nouveau compte est stocké dans le cadre de votre projet Firebase et peut être utilisé pour identifier un utilisateur dans chaque application de votre projet, quel que soit le mode de connexion de l'utilisateur.

  • Dans vos applications, vous pouvez obtenir des informations de profil de base de l'utilisateur du firebase::auth::User objet:

    firebase::auth::User* user = auth->current_user();
    if (user != nullptr) {
      std::string name = user->display_name();
      std::string email = user->email();
      std::string photo_url = user->photo_url();
      // The user's ID, unique to the Firebase project.
      // Do NOT use this value to authenticate with your backend server,
      // if you have one. Use firebase::auth::User::Token() instead.
      std::string uid = user->uid();
    }
    
  • Dans votre base de données et en temps réel Firebase Cloud Storage Les règles de auth sécurité , vous pouvez obtenir la signature dans ID d'utilisateur unique de l' utilisateur de la auth variable et l' utiliser pour contrôler les données d' un accès utilisateur peut.

Vous pouvez permettre aux utilisateurs de se connecter à votre application à l' aide des fournisseurs d'authentification multiples en reliant les informations d' identification de fournisseur auth à un compte d'utilisateur existant.

Pour vous déconnecter un utilisateur, appelez SignOut() :

auth->SignOut();