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

Vous pouvez utiliser Firebase Authentication pour permettre à vos utilisateurs de s'authentifier auprès de à l'aide de leurs adresses e-mail et mots de passe, et pour gérer de mots de passe.

Avant de commencer

1. Ajoutez Firebase à votre projet C++.
2. Si vous n'avez pas encore associé votre application à votre projet Firebase, faites-le depuis la console Firebase.
3. Activez la connexion par adresse e-mail/mot de passe :
   1. Dans la console Firebase, ouvrez dans la section Authentification.
   2. Dans l'onglet Mode de connexion, activez la connexion Adresse e-mail/Mot de passe. , puis cliquez sur Save (Enregistrer).

Accéder à la classe firebase::auth::Auth

La classe Auth sert de passerelle pour tous les appels d'API.

1. Ajoutez les fichiers d'en-tête Auth et App:

   #include "firebase/app.h"
   #include "firebase/auth.h"
   

2. Dans votre code d'initialisation, créez une classe firebase::App.

   #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. Procurez-vous la classe firebase::auth::Auth pour votre firebase::App. Il existe un mappage de type "un à un" entre App et Auth.

   firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
   

Créer un compte avec mot de passe

Pour créer un 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, remplissez les étapes de validation du compte requises par votre application, telles que la vérification le mot de passe du nouveau compte a été correctement saisi et répond à votre complexité exigences.
2. Créez un compte en transmettant l'adresse e-mail et le mot de passe du nouvel utilisateur vers Auth::CreateUserWithEmailAndPassword:

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

3. Si votre programme comporte une boucle de mise à jour qui s'exécute régulièrement (par exemple à 30 ou 60 fois par seconde), vous pouvez vérifier les résultats une fois par mise à jour avec Auth::CreateUserWithEmailAndPasswordLastResult:

   firebase::Future<firebase::auth::AuthResult> result =
       auth->CreateUserWithEmailAndPasswordLastResult();
   if (result.status() == firebase::kFutureStatusComplete) {
     if (result.error() == firebase::auth::kAuthErrorNone) {
       const 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());
     }
   }
   

   Si votre programme est axé sur des événements, vous pouvez enregistrer un rappel sur la À venir.

Pour protéger votre projet contre les utilisations abusives, Firebase limite le nombre adresse e-mail/mot de passe et inscriptions anonymes que votre application peut enregistrer depuis le la même adresse IP en peu de temps. Vous pouvez demander et programmer des modifications temporaires à ce quota Console Firebase.

Connecter un utilisateur avec une adresse e-mail et un mot de passe

La procédure de connexion pour un utilisateur avec un mot de passe est similaire à la procédure pour en créant un compte. Dans la fonction de connexion de votre application, procédez comme suit:

1. Lorsqu'un utilisateur se connecte à votre application, transmettez son adresse e-mail et mot de passe pour firebase::auth::Auth::SignInWithEmailAndPassword:

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

2. Si votre programme comporte une boucle de mise à jour qui s'exécute régulièrement (par exemple à 30 ou 60 fois par seconde), vous pouvez vérifier les résultats une fois par mise à jour avec Auth::SignInWithEmailAndPasswordLastResult:

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

   Si votre programme est axé sur des événements, vous pouvez enregistrer un rappel sur la À venir.

Enregistrer un rappel sur un Future

Certains programmes ont des fonctions Update appelées 30 ou 60 fois par seconde. Par exemple, de nombreux jeux suivent ce modèle. Ces programmes peuvent appeler le LastResult pour interroger les appels asynchrones. Toutefois, si votre programme est basé sur des événements, vous préférerez peut-être enregistrer des fonctions de rappel. Une fonction de rappel est appelée à la fin de l'objet 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::AuthResult> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // `&my_program_context` is passed verbatim to OnCreateCallback().
  result.OnCompletion(OnCreateCallback, &my_program_context);
}

Si vous préférez, la fonction de rappel peut également être un lambda.

void CreateUserUsingLambda(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::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::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);
}

Recommandé : Activer la protection contre l'énumération d'adresses e-mail

Certaines méthodes Firebase Authentication qui utilisent des adresses e-mail comme paramètres génèrent des erreurs spécifiques si l'adresse e-mail n'est pas enregistrée alors qu'elle doit l'être. (par exemple, lorsque vous vous connectez avec une adresse e-mail et un mot de passe), ou enregistrés lorsqu'elle ne doit pas être utilisée (par exemple, lors de la modification de l'adresse e-mail d'un utilisateur). Bien que cela puisse être utile pour suggérer des solutions spécifiques aux utilisateurs, cela peut également être utilisé de manière abusive par des acteurs malveillants pour découvrir les adresses e-mail enregistrées par vos utilisateurs.

Pour atténuer ce risque, nous vous recommandons d'activer la protection contre l'énumération des adresses e-mail pour votre projet à l'aide de l'outil gcloud de Google Cloud. Notez que l'activation de cette cette fonctionnalité modifie le comportement de Firebase Authentication dans les rapports d'erreurs: assurez-vous que votre application ne s'appuie pas sur les erreurs plus spécifiques.

Étapes suivantes

Lorsqu'un utilisateur se connecte pour la première fois, un compte utilisateur est créé et associés aux identifiants, c'est-à-dire au nom d'utilisateur et au mot de passe, ou des informations sur le fournisseur d'authentification, c'est-à-dire l'utilisateur avec lequel il s'est connecté. Cette nouvelle est stocké dans votre projet Firebase et peut servir à identifier un utilisateur dans toutes les applications de votre projet, quelle que soit la façon dont l'utilisateur se connecte.

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

  firebase::auth::User user = auth->current_user();
  if (user.is_valid()) {
    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 Firebase Realtime Database et votre Cloud Storage Règles de sécurité, vous pouvez obtenez l'ID utilisateur unique de l'utilisateur connecté à partir de la variable auth et l'utiliser pour contrôler les données auxquelles un utilisateur peut accéder.

Vous pouvez autoriser les utilisateurs à se connecter à votre appli à l'aide de plusieurs authentifications fournisseurs en associant leurs identifiants compte utilisateur existant.

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

auth->SignOut();