Gérer les utilisateurs dans Firebase

Créer un compte utilisateur

Pour créer un utilisateur dans votre projet Firebase, appelez la méthode CreateUserWithEmailAndPassword ou connectez un utilisateur pour la première fois à l'aide d'un fournisseur d'identité fédérée, tel que Google Sign-In ou Facebook Login.

Vous pouvez également créer des utilisateurs authentifiés par mot de passe dans la section "Authentification" de la console Firebase, sur la page "Utilisateurs".

Obtenir l'utilisateur actuellement connecté

La méthode recommandée pour obtenir l'utilisateur actuel consiste à définir un écouteur sur l'objet Auth :

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());
    } else {
      // User is signed out
      printf("OnAuthStateChanged: signed_out\n");
    }
    // ...
  }
};
// ... initialization code
// Test notification on registration.
MyAuthStateListener state_change_listener;
auth->AddAuthStateListener(&state_change_listener);

En utilisant un écouteur, vous vous assurez que l'objet Auth ne se trouve pas dans une classe intermédiaire de l'utilisateur, comme l'initialisation, lorsque vous obtenez l'utilisateur actuel.

Vous pouvez également obtenir l'utilisateur actuellement connecté en appelant current_user. Si un utilisateur n'est pas connecté, la méthode is_valid de l'utilisateur renvoie la valeur false.

Remarque :current_user n'est peut-être pas valide parce que l'objet Auth n'est pas terminé lors de l'initialisation. Si vous utilisez un écouteur pour suivre l'état de connexion de l'utilisateur, vous n'avez pas besoin de vous occuper de ce cas.

Persister les identifiants d'un utilisateur

Les identifiants de l'utilisateur seront stockés dans le keystore local une fois qu'il est connecté. Le cache local des identifiants utilisateur peut être supprimé en déconnectant l'utilisateur. Le keystore est spécifique à la plate-forme :

• Plates-formes Apple : Services Keychain
• Android : Android Keystore
• Windows : API Credential Management.
• OS X : Services Keychain.
• Linux : libsecret, que l'utilisateur doit avoir installé.

Obtenir le profil d'un utilisateur

Pour obtenir les informations de profil d'un utilisateur, utilisez les méthodes d'accesseur d'une instance de firebase::auth::User Exemple :

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();
}

Obtenir les informations de profil spécifiques au fournisseur d'un utilisateur

Pour obtenir les informations de profil récupérées auprès des fournisseurs de connexion associés à un utilisateur, utilisez la méthode ProviderData. Exemple :

firebase::auth::User user = auth->current_user();
if (user.is_valid()) {
  for (auto it = user.provider_data().begin();
       it != user.provider_data().end(); ++it) {
    firebase::auth::UserInfoInterface profile = *it;
    // Id of the provider (ex: google.com)
    std::string providerId = profile.provider_id();

    // UID specific to the provider
    std::string uid = profile.uid();

    // Name, email address, and profile photo Url
    std::string name = profile.display_name();
    std::string email = profile.email();
    std::string photoUrl = profile.photo_url();
  }
}

Mettre à jour le profil d'un utilisateur

Vous pouvez mettre à jour les informations de profil de base d'un utilisateur (son nom à afficher et l'URL de sa photo de profil) à l'aide de la méthode UpdateUserProfile. Exemple :

firebase::auth::User user = auth->current_user();
if (user.is_valid()) {
  firebase::auth::User::UserProfile profile;
  profile.display_name = "Jane Q. User";
  profile.photo_url = "https://example.com/jane-q-user/profile.jpg";
  user.UpdateUserProfile(profile).OnCompletion(
      [](const firebase::Future<void>& completed_future, void* user_data) {
        // We are probably in a different thread right now.
        if (completed_future.error() == 0) {
          printf("User profile updated.");
        }
      },
      nullptr);  // pass user_data here.
}

Définir l'adresse e-mail d'un utilisateur

Vous pouvez définir l'adresse e-mail d'un utilisateur avec la méthode UpdateEmail. Exemple :

firebase::auth::User user = auth->current_user();
if (user.is_valid()) {
  user.UpdateEmail("[e-mail]")
      .OnCompletion(
          [](const firebase::Future<void>& completed_future,
             void* user_data) {
            // We are probably in a different thread right now.
            if (completed_future.error() == 0) {
              printf("User email address updated.");
            }
          },
          nullptr);
}

Important :Pour que vous puissiez définir l'adresse e-mail d'un utilisateur, celui-ci doit s'être connecté récemment. Consultez Réauthentifier un utilisateur.

Envoyer un e-mail de validation à un utilisateur

Vous pouvez envoyer un e-mail de validation d'adresse à un utilisateur à l'aide de la méthode SendEmailVerification. Exemple :

firebase::auth::User user = auth->current_user();
if (user.is_valid()) {
  user.SendEmailVerification().OnCompletion(
      [](const firebase::Future<void>& completed_future, void* user_data) {
        // We are probably in a different thread right now.
        if (completed_future.error() == 0) {
          printf("Email sent.");
        }
      },
      nullptr);
}

Vous pouvez personnaliser le modèle d'e-mail utilisé dans la section "Authentification" de la console Firebase, sur la page "Modèles d'e-mails". Consultez la section Modèles d'e-mails dans le centre d'aide Firebase.

Définir le mot de passe d'un utilisateur

Vous pouvez définir le mot de passe d'un utilisateur avec la méthode UpdatePassword. Exemple :

firebase::auth::User user = auth->current_user();
std::string newPassword = "SOME-SECURE-PASSWORD";

if (user.is_valid()) {
  user.UpdatePassword(newPassword.c_str())
      .OnCompletion(
          [](const firebase::Future<void>& completed_future,
             void* user_data) {
            // We are probably in a different thread right now.
            if (completed_future.error() == 0) {
              printf("password updated.");
            }
          },
          nullptr);
}

Important :Pour définir un mot de passe, l'utilisateur doit s'être connecté récemment. Voir Réauthentifiez un utilisateur.

Envoyer un e-mail de réinitialisation de mot de passe

Vous pouvez envoyer un e-mail de réinitialisation du mot de passe à un utilisateur à l'aide du SendPasswordResetEmail. . Exemple :

std::string emailAddress = "[e-mail]";

auth->SendPasswordResetEmail(emailAddress.c_str())
    .OnCompletion(
        [](const firebase::Future<void>& completed_future,
           void* user_data) {
          // We are probably in a different thread right now.
          if (completed_future.error() == 0) {
            // Email sent.
          } else {
            // An error happened.
            printf("Error %d: %s", completed_future.error(),
                   completed_future.error_message());
          }
        },
        nullptr);

Vous pouvez personnaliser le modèle d'e-mail utilisé dans la section "Authentification" de la console Firebase, sur la page "Modèles d'e-mails". Consultez la section Modèles d'e-mail dans Centre d'aide Firebase.

Vous pouvez également envoyer des e-mails de réinitialisation du mot de passe depuis la console Firebase.

Supprimer un compte utilisateur

Vous pouvez supprimer un compte utilisateur avec la méthode Delete. Exemple :

firebase::auth::User user = auth->current_user();
if (user.is_valid()) {
  user.Delete().OnCompletion(
      [](const firebase::Future<void>& completed_future, void* user_data) {
        if (completed_future.error() == 0) {
          // User deleted.
        } else {
          // An error happened.
          printf("Error %d: %s", completed_future.error(),
                 completed_future.error_message());
        }
      },
      nullptr);
}

Important : Pour supprimer un utilisateur, celui-ci doit s'être connecté récemment. Voir Réauthentifiez un utilisateur.

Vous pouvez également supprimer des utilisateurs depuis la section "Authentification" Console Firebase, sur la page "Utilisateurs".

Réauthentifier un utilisateur

Certaines actions sensibles en termes de sécurité, telles que la suppression d'un compte, la définition d'une adresse e-mail principale et la modification d'un mot de passe, nécessitent que l'utilisateur se soit récemment connecté. Si vous effectuez l'une de ces actions et que l'utilisateur s'est connecté il y a trop longtemps, l'action échoue.

Dans ce cas, réauthentifiez l'utilisateur en récupérant de nouveaux identifiants de connexion et en les transmettant à Reauthenticate. Exemple :

firebase::auth::User user = auth->current_user();

// Get auth credentials from the user for re-authentication. The example
// below shows email and password credentials but there are multiple
// possible providers, such as GoogleAuthProvider or FacebookAuthProvider.
firebase::auth::Credential credential =
    firebase::auth::EmailAuthProvider::GetCredential("[e-mail]",
                                                     "password1234");

if (user.is_valid()) {
  user.Reauthenticate(credential)
      .OnCompletion(
          [](const firebase::Future<void>& completed_future,
             void* user_data) {
            if (completed_future.error() == 0) {
              printf("User re-authenticated.");
            }
          },
          nullptr);
}

Importer des comptes utilisateur

Vous pouvez importer des comptes utilisateur dans votre projet Firebase à partir d'un fichier à l'aide de la méthode la commande auth:import de la CLI Firebase. Exemple :

firebase auth:import users.json --hash-algo=scrypt --rounds=8 --mem-cost=14