Cette page a été traduite par l'API Cloud Translation.
Switch to English

Gérer les utilisateurs dans Firebase

Créer un utilisateur

Vous créez un nouvel utilisateur dans votre projet Firebase en appelant la méthode CreateUserWithEmailAndPassword ou en vous connectant pour la première fois à un utilisateur à l'aide d'un fournisseur d'identité fédéré, tel que Google Sign-In ou Facebook Login .

Vous pouvez également créer de nouveaux 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 != nullptr) {
      // 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 n'est pas dans un état intermédiaire (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é, current_user renvoie nullptr.

Conserver les informations d'identification d'un utilisateur

Les informations d'identification de l'utilisateur seront stockées dans le fichier de clés local après la connexion d'un utilisateur. Le cache local des informations d'identification de l'utilisateur peut être supprimé en déconnectant l'utilisateur. Le keystore est spécifique à la plate-forme:

Obtenir le profil d'un utilisateur

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

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

Obtenir des 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 liés à un utilisateur, utilisez la méthode ProviderData . Par exemple:

firebase::auth::User* user = auth->current_user();
if (user != nullptr) {
  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 - le nom d'affichage de l'utilisateur et l'URL de la photo de profil - avec la méthode UpdateUserProfile . Par exemple:

firebase::auth::User* user = auth->current_user();
if (user != nullptr) {
  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 . Par exemple:

firebase::auth::User* user = auth->current_user();
if (user != nullptr) {
  user->UpdateEmail("user@example.com")
      .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);
}

Envoyer un e-mail de vérification à un utilisateur

Vous pouvez envoyer un e-mail de vérification d'adresse à un utilisateur avec la méthode SendEmailVerification . Par exemple:

firebase::auth::User* user = auth->current_user();
if (user != nullptr) {
  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 de courrier électronique utilisé dans la section Authentification de la console Firebase , sur la page Modèles de courrier électronique. Voir Modèles d'e - mail 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 . Par exemple:

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

if (user != nullptr) {
  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);
}

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

Vous pouvez envoyer un e-mail de réinitialisation de mot de passe à un utilisateur avec la méthode SendPasswordResetEmail . Par exemple:

std::string emailAddress = "user@example.com";

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 de courrier électronique utilisé dans la section Authentification de la console Firebase , sur la page Modèles de courrier électronique. Voir Modèles d'e - mail dans le centre d'aide Firebase.

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

Supprimer un utilisateur

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

firebase::auth::User* user = auth->current_user();
if (user != nullptr) {
  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);
}

Vous pouvez également supprimer des utilisateurs de la section Authentification de la console Firebase , sur la page Utilisateurs.

Ré-authentifier un utilisateur

Certaines actions sensibles à la 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, exigent 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, le l'action échoue.

Lorsque cela se produit, ré-authentifiez l'utilisateur en obtenant de nouvelles informations d'identification de l'utilisateur et en transmettant les informations d'identification à Reauthenticate . Par 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("user@example.com",
                                                     "password1234");

if (user != nullptr) {
  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 d'utilisateurs

Vous pouvez importer des comptes utilisateur à partir d'un fichier dans votre projet Firebase à l'aide de la commande auth:import l'interface de ligne de commande Firebase. Par exemple:

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