Authentifizieren Sie sich mit Facebook Login und C++

Sie können Ihren Benutzern die Authentifizierung bei Firebase über ihre Facebook-Konten ermöglichen, indem Sie Facebook Login in Ihre App integrieren.

Bevor Sie beginnen

  1. Fügen Sie Firebase zu Ihrem C++-Projekt hinzu .
  2. Rufen Sie auf der Website „Facebook für Entwickler“ die App-ID und ein App-Geheimnis für Ihre App ab.
  3. Facebook-Login aktivieren:
    1. Öffnen Sie in der Firebase-Konsole den Abschnitt „Auth“ .
    2. Aktivieren Sie auf der Registerkarte „Anmeldemethode“ die Facebook -Anmeldemethode und geben Sie die App-ID und das App-Geheimnis an, die Sie von Facebook erhalten haben.
    3. Stellen Sie dann sicher, dass Ihr OAuth-Umleitungs-URI (z. B. my-app-12345.firebaseapp.com/__/auth/handler ) als einer Ihrer OAuth-Umleitungs-URIs auf der Einstellungsseite Ihrer Facebook-App auf der Website „Facebook für Entwickler“ im Produkt aufgeführt ist Einstellungen > Facebook-Login- Konfiguration.

Greifen Sie auf die firebase::auth::Auth -Klasse zu

Die Auth Klasse ist das Gateway für alle API-Aufrufe.
  1. Fügen Sie die Auth- und App-Headerdateien hinzu:
    #include "firebase/app.h"
    #include "firebase/auth.h"
    
  2. Erstellen Sie in Ihrem Initialisierungscode eine firebase::App Klasse.
    #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__)
    
  3. Erwerben Sie die Klasse firebase::auth::Auth für Ihre firebase::App . Es gibt eine Eins-zu-Eins-Zuordnung zwischen App und Auth .
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
    

Authentifizieren Sie sich mit Firebase

  1. Befolgen Sie die Anweisungen für Android und iOS+ , um ein Zugriffstoken für den angemeldeten Facebook-Benutzer zu erhalten.
  2. Nachdem sich ein Benutzer erfolgreich angemeldet hat, tauschen Sie das Zugriffstoken gegen Firebase-Anmeldeinformationen aus und authentifizieren Sie sich bei Firebase mit den Firebase-Anmeldeinformationen:
    firebase::auth::Credential credential =
        firebase::auth::FacebookAuthProvider::GetCredential(access_token);
    firebase::Future<firebase::auth::AuthResult> result =
        auth->SignInAndRetrieveDataWithCredential(credential);
    
  3. Wenn Ihr Programm über eine Aktualisierungsschleife verfügt, die regelmäßig ausgeführt wird (z. B. 30 oder 60 Mal pro Sekunde), können Sie die Ergebnisse einmal pro Aktualisierung mit Auth::SignInAndRetrieveDataWithCredentialLastResult :
    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());
      }
    }
    
    überprüfen. Wenn Ihr Programm ereignisgesteuert ist, können Sie dies möglicherweise auch bevorzugen um einen Rückruf für die Zukunft zu registrieren .

Registrieren Sie einen Rückruf für einen Future

Einige Programme verfügen über Update Funktionen, die 30 oder 60 Mal pro Sekunde aufgerufen werden. Viele Spiele folgen beispielsweise 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 lieber Rückruffunktionen registrieren. Nach Abschluss der Zukunft 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 Callback-Funktion kann bei Bedarf auch ein Lambda 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 Benutzer zum ersten Mal angemeldet hat, wird ein neues Benutzerkonto erstellt und mit den Anmeldeinformationen – also dem Benutzernamen und dem Kennwort, der Telefonnummer oder den Informationen zum Authentifizierungsanbieter – verknüpft, mit denen sich der Benutzer angemeldet hat. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann zur Identifizierung eines Benutzers in jeder App in Ihrem Projekt verwendet werden, unabhängig davon, wie sich der Benutzer anmeldet.

  • In Ihren Apps können Sie die grundlegenden Profilinformationen des Benutzers aus dem firebase::auth::User Objekt 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 Ihren Firebase-Echtzeitdatenbank- und Cloud-Speicher- Sicherheitsregeln können Sie die eindeutige Benutzer-ID des angemeldeten Benutzers aus der auth abrufen und damit steuern, auf welche Daten ein Benutzer zugreifen kann.

Sie können Benutzern die Anmeldung bei Ihrer App mit mehreren Authentifizierungsanbietern ermöglichen, indem Sie die Anmeldeinformationen des Authentifizierungsanbieters mit einem vorhandenen Benutzerkonto verknüpfen.

Um einen Benutzer abzumelden, rufen Sie SignOut() auf:

auth->SignOut();