Diese Seite wurde von der Cloud Translation API übersetzt.

Nutzer in Firebase verwalten
Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Nutzer erstellen

Sie erstellen einen neuen Nutzer in Ihrem Firebase-Projekt, indem Sie die Methode CreateUserWithEmailAndPassword oder einen Nutzer zum ersten Mal mit einer föderierten Identität anmelden wie Google Log-in oder Facebook-Anmeldung.

Sie können neue passwortauthentifizierte Nutzer auch über die Seite „Nutzer“ im Bereich „Authentifizierung“ der Firebase-Konsole erstellen.

Derzeit angemeldeten Nutzer abrufen

Wir empfehlen, einen Listener für das Auth-Objekt festzulegen, um den aktuellen Nutzer abzurufen:

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 stellen Sie sicher, dass sich das Auth-Objekt nicht in einem Zwischen- z. B. Initialisierung, wenn Sie den aktuellen Nutzer abrufen.

Sie können den aktuell angemeldeten Nutzer auch über current_user abrufen. Wenn ein Nutzer nicht angemeldet ist, gibt die is_valid-Methode des Nutzers „falsch“ zurück.

Anmeldedaten eines Nutzers beibehalten

Die Anmeldedaten des Nutzers werden im lokalen Schlüsselspeicher gespeichert, nachdem er sich angemeldet hat. Sie können den lokalen Cache der Nutzeranmeldedaten löschen, indem Sie die Nutzenden verlassen. Der Schlüsselspeicher ist plattformspezifisch:

Apple-Plattformen: Schlüsselbundverwaltung
Android: Android Keystore
Windows: Credential Management API
OS X: Schlüsselbundverwaltung
Linux: libsecret, die der Nutzer installiert haben muss.

Nutzerprofil abrufen

Wenn Sie die Profilinformationen eines Nutzers abrufen möchten, verwenden Sie die Zugriffsmethoden einer Instanz von firebase::auth::User. 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

Mit der Methode ProviderData können Sie die Profilinformationen abrufen, die von den Anmeldeanbietern abgerufen wurden, die mit einem Nutzer verknüpft sind. 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 kannst du die allgemeinen Profilinformationen eines Nutzers aktualisieren, also seinen Anzeigenamen und die URL seines Profilbilds. 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

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

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

Bestätigungs-E-Mail an Nutzer senden

Sie können eine E-Mail zur Bestätigung der Adresse an einen Nutzer mit der SendEmailVerification-Methode. 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, die im Abschnitt „Authentifizierung“ der Firebase Console verwendet wird, auf der Seite „E-Mail-Vorlagen“ anpassen. Weitere Informationen finden Sie in der Firebase-Hilfe unter E-Mail-Vorlagen.

Nutzerpasswort festlegen

Sie können das Passwort eines Nutzers mit der UpdatePassword-Methode 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);
}

E-Mail zum Zurücksetzen des Passworts senden

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

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

Sie können die E-Mail-Vorlage anpassen, die im Abschnitt „Authentifizierung“ von in der Firebase-Konsole auf der Seite „E-Mail-Vorlagen“. Weitere Informationen finden Sie unter E-Mail-Vorlagen in Firebase-Hilfe.

Du kannst auch E-Mails zum Zurücksetzen des Passworts über die Firebase-Konsole senden.

Nutzer löschen

Sie können ein Nutzerkonto mit der Methode Delete 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);
}

Sie können Nutzer auch in der Firebase Console auf der Seite „Nutzer“ im Abschnitt „Authentifizierung“ löschen.

Nutzer neu authentifizieren

Einige sicherheitsrelevante Aktionen, z. B. Löschen eines Kontos, Festlegen einer primären E-Mail-Adresse und Passwort ändern: Der Nutzer muss angemeldet sind. Wenn Sie eine dieser Aktionen ausführen und sich der Nutzer angemeldet hat allzu lange her ist, schlägt die Aktion fehl.

Nutzer in diesem Fall durch Abrufen neuer Anmeldedaten noch einmal authentifizieren vom Nutzer und übergibt die Anmeldedaten 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("user@example.com",
                                                     "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

Sie können Nutzerkonten aus einer Datei in Ihr Firebase-Projekt importieren, indem Sie die Den Befehl auth:import der Firebase CLI Beispiel:

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