Nutzer in Firebase verwalten

Nutzer erstellen

Sie haben folgende Möglichkeiten, einen neuen Nutzer zu erstellen:

• Über Ihre App: Erstellen Sie einen neuen Nutzer in Ihrem Firebase-Projekt, indem Sie die CreateUserWithEmailAndPassword Methode aufrufen oder sich ein Nutzer zum ersten Mal mit einem föderierten Identitäts anbieter wie Google Log-in oder Facebook-Anmeldung anmeldet.

• In der Firebase Konsole: Erstellen Sie einen neuen Nutzer mit Passwortauthentifizierung auf dem Tab Sicherheit > Authentifizierung > Nutzer.

Aktuell angemeldeten Nutzer abrufen

Die empfohlene Methode zum Abrufen des aktuellen Nutzers besteht darin, einen Listener für das Auth-Objekt festzulegen:

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

Durch die Verwendung eines Listeners wird sichergestellt, dass sich das Auth-Objekt nicht in einem Zwischenzustand befindet, z. B. während der Initialisierung, wenn Sie den aktuellen Nutzer abrufen.

Sie können den aktuell angemeldeten Nutzer auch mit dem Aufruf von current_user abrufen. Wenn ein Nutzer nicht angemeldet ist, gibt die Methode is_valid des Nutzers „false“ zurück.

Hinweis: current_user ist möglicherweise ungültig, weil die Initialisierung des Auth-Objekts noch nicht abgeschlossen ist. Wenn Sie einen Listener verwenden, um den Anmeldestatus des Nutzers zu verfolgen, müssen Sie diesen Fall nicht berücksichtigen.

Anmeldedaten eines Nutzers beibehalten

Die Anmeldedaten des Nutzers werden nach der Anmeldung in der lokalen Keystore-Datei gespeichert. Der lokale Cache der Anmeldedaten kann gelöscht werden, indem Sie den Nutzer abmelden. Der Schlüsselspeicher ist plattformspezifisch:

• Apple-Plattformen: Keychain Services.
• Android: Android Keystore
• Windows: Credential Management API
• OS X: Keychain Services
• Linux: libsecret, das der Nutzer installiert haben muss

Profil eines Nutzers abrufen

Verwenden Sie die Accessormethoden einer Instanz von firebase::auth::User, um die Profilinformationen eines Nutzers abzurufen. Beispiel:

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

Anbieterspezifische Profilinformationen eines Nutzers abrufen

Verwenden Sie die Methode ProviderData, um die Profilinformationen abzurufen, die von den mit einem Nutzer verknüpften Anmeldeanbietern abgerufen wurden. Beispiel:

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

Profil eines Nutzers aktualisieren

Mit der Methode UpdateUserProfile können Sie die grundlegenden Profilinformationen eines Nutzers aktualisieren, z. B. den Anzeigenamen und die URL des Profilfotos. Beispiel:

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.
}

E-Mail-Adresse eines Nutzers festlegen

Mit der Methode UpdateEmail können Sie die E-Mail-Adresse eines Nutzers festlegen. Beispiel:

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

Wichtig: Damit Sie die E-Mail-Adresse eines Nutzers festlegen können, muss sich der Nutzer vor Kurzem angemeldet haben. Weitere Informationen finden Sie unter Nutzer neu authentifizieren.

Bestätigungs-E-Mail an einen Nutzer senden

Mit der Methode SendEmailVerification können Sie eine E-Mail zur Bestätigung der Adresse an einen Nutzer senden. Beispiel:

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

Sie können die E-Mail-Vorlage anpassen, die im Bereich „Authentifizierung“ von der Firebase Konsole auf der Seite „E-Mail-Vorlagen“ verwendet wird. Weitere Informationen finden Sie im Hilfeartikel E-Mail-Vorlagen in Firebase.

Passwort eines Nutzers festlegen

Mit der Methode UpdatePassword können Sie das Passwort eines Nutzers festlegen. Beispiel:

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

Wichtig: Damit Sie das Passwort eines Nutzers festlegen können, muss sich der Nutzer vor Kurzem angemeldet haben. Weitere Informationen finden Sie unter Nutzer neu authentifizieren.

E-Mail zum Zurücksetzen des Passworts senden

Mit der Methode SendPasswordResetEmail können Sie eine E-Mail zum Zurücksetzen des Passworts an einen Nutzer senden. Beispiel:

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

Sie können anpassen, welche E-Mail-Vorlage auf dem Sicherheit > Authentifizierung > Vorlagen Tab der Firebase Konsole verwendet wird. Weitere Informationen finden Sie im Hilfeartikel E-Mail-Vorlagen in Firebase.

Sie können E-Mails zum Zurücksetzen des Passworts auch über die Firebase Konsole senden.

Nutzer löschen

Mit der Methode Delete können Sie ein Nutzerkonto löschen. Beispiel:

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

Wichtig: Damit Sie einen Nutzer löschen können, muss sich der Nutzer vor Kurzem angemeldet haben. Weitere Informationen finden Sie unter Nutzer neu authentifizieren.

Sie können Nutzer auch in der Firebase Konsole auf dem Tab Sicherheit > Authentifizierung > Nutzer löschen.

Nutzer neu authentifizieren

Für einige sicherheitsrelevante Aktionen, z. B. das Löschen eines Kontos, das Festlegen einer primären E-Mail-Adresseund das Ändern eines Passworts, muss sich der Nutzer vor Kurzem angemeldet haben. Wenn Sie eine dieser Aktionen ausführen und die Anmeldung des Nutzers zu lange her ist, schlägt die Aktion fehl.

In diesem Fall müssen Sie den Nutzer neu authentifizieren. Rufen Sie dazu neue Anmeldedaten vom Nutzer ab und übergeben Sie sie an Reauthenticate. Beispiel:

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

Nutzerkonten importieren

Mit dem Befehl auth:import der Firebase CLI können Sie Nutzerkonten aus einer Datei in Ihr Firebase-Projekt importieren. Beispiel:

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