Diese Seite wurde von der Cloud Translation API übersetzt.

Mit Google Log-in und C++ authentifizieren

Sie können Ihre Nutzer mit ihren Google-Konten bei Firebase authentifizieren, indem Sie Google Sign-In in Ihre App einbinden.

Hinweis

Fügen Sie Ihrem C++-Projekt Firebase hinzu.
Aktivieren Sie Google in der Firebase-Konsole als Anmeldemethode:
1. Öffne in der Firebase Console den Bereich Auth.
2. Aktivieren Sie auf dem Tab Anmeldemethode die Anmeldemethode Google und klicken Sie auf Speichern.
Laden Sie die aktualisierte Firebase-Konfigurationsdatei herunter, wenn Sie in der Console dazu aufgefordert werden. (google-services.json), die jetzt die Informationen zum OAuth-Client enthält für Google Log-in erforderlich.
Verschieben Sie diese aktualisierte Konfigurationsdatei in Ihr Android Studio-Projekt und ersetzen Sie sie dabei. die inzwischen veraltete Konfigurationsdatei. Weitere Informationen finden Sie unter Firebase zu meinem Android-Projekt hinzufügen.

Auf die Klasse `firebase::auth::Auth` zugreifen

Die Klasse Auth ist das Gateway für alle API-Aufrufe.

Fügen Sie die Auth- und App-Headerdateien hinzu:

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

Erstellen Sie in Ihrem Initialisierungscode einen Klasse 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__)

Erwerben Sie die Klasse „firebase::auth::Auth“ für Ihr Gerät „firebase::App“. Es gibt eine 1:1-Zuordnung zwischen App und Auth.
```
firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
```

Mit Firebase authentifizieren

Folgen Sie der Anleitung für Android und iOS +, um ein ID-Token für die Google-Anmeldung abzurufen.

Nachdem sich ein Nutzer erfolgreich angemeldet hat, tauschen Sie das ID-Token gegen Firebase-Anmeldedaten aus und authentifizieren Sie sich mit Firebase:

firebase::auth::Credential credential =
    firebase::auth::GoogleAuthProvider::GetCredential(google_id_token,
                                                      nullptr);
firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredential(credential);

Wenn Ihr Programm eine Update-Schleife hat, die regelmäßig ausgeführt wird (z. B. 30- oder 60-mal pro Sekunde), können Sie die Ergebnisse einmal pro Update mit Auth::SignInAndRetrieveDataWithCredentialLastResult prüfen:

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

Wenn Ihr Programm ereignisgesteuert ist, können Sie auch einen Callback für die Future-Funktion registrieren.

Callback für ein Future registrieren

Einige Programme haben Update-Funktionen, die 30 oder 60 Mal pro Sekunde aufgerufen werden. So folgen beispielsweise viele Spiele diesem Modell. Diese Programme können die LastResult-Funktionen aufrufen, um asynchrone Aufrufe abzufragen. Wenn Ihr Programm jedoch ereignisgesteuert ist, möchten Sie möglicherweise Callback-Funktionen registrieren. Nach Abschluss der Future wird eine Callback-Funktion aufgerufen.

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

Die Rückruffunktion kann auch eine Lambda-Funktion sein.

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

Nächste Schritte

Nachdem sich ein Nutzer zum ersten Mal angemeldet hat, wird ein neues Nutzerkonto erstellt und die mit den Anmeldedaten verknüpft sind, d. h. Nutzername und Passwort, oder Authentifizierungsanbieter-Informationen – also für den Nutzer, mit dem sich der Nutzer angemeldet hat. Diese neue -Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um in jeder App in Ihrem Projekt einen Nutzer erreichen, unabhängig davon, wie er sich anmeldet.

In Ihren Apps können Sie die grundlegenden Profilinformationen des Nutzers über das Objekt firebase::auth::User abrufen:

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

In Firebase Realtime Database und Cloud Storage Sicherheitsregeln können Sie die eindeutige Nutzer-ID des angemeldeten Nutzers aus der Variablen auth abrufen, und steuern, auf welche Daten ein Nutzer zugreifen kann.

Sie können Nutzern erlauben, sich über mehrere Authentifizierungsanbieter in Ihrer App anzumelden, indem Sie Anmeldedaten des Authentifizierungsanbieters mit einem vorhandenen Nutzerkonto verknüpfen.

Rufen Sie auf, um einen Nutzer abzumelden. SignOut():

auth->SignOut();