Catch up on everthing we announced at this year's Firebase Summit. Learn more

Authentifizieren Sie sich mit Facebook Login und C++

Sie können Ihren Benutzern erlauben, sich mit ihren Facebook-Konten bei Firebase zu authentifizieren, indem Sie Facebook Login in Ihre App integrieren.

Bevor Sie beginnen

  1. In Firebase zu Ihrem C ++ Projekt .
  2. Auf der Facebook für Entwickler - Website, erhält die App - ID und ein App Geheimnis für Ihre App.
  3. Facebook-Anmeldung aktivieren:
    1. In der Firebase Konsole , öffnen Sie den Abschnitt Auth.
    2. Auf dem Anmelden Methode Registerkarte, aktivieren Sie die Facebook-Anmeldeverfahren und geben Sie die App - ID und App Geheimnis Sie von Facebook bekommen.
    3. Dann stellen Sie sicher , dass Ihr OAuth Umleitung URI (zB my-app-12345.firebaseapp.com/__/auth/handler ) als eine Ihrer OAuth Umleitung URIs in Ihrer Facebook - App - Einstellungen Seite auf der aufgeführt ist Facebook für Entwickler - Website im Produkt Einstellungen> Facebook Login - Konfiguration.

Besuchen Sie das firebase::auth::Auth Klasse

Die Auth - Klasse ist das Gateway für alle API - Aufrufe.
  1. Fügen Sie die Auth und App - Header - Dateien:
    #include "firebase/app.h"
    #include "firebase/auth.h"
    
  2. In Ihrem Initialisierungscode, erstellen Sie 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 firebase::auth::Auth - Klasse für Ihre firebase::App . Es gibt eine Eins-zu-Eins - Abbildung zwischen App und Auth .
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
    

Mit Firebase authentifizieren

  1. Folgen Sie den Anweisungen für Android und iOS + , um einen Zugang zu bekommen Token für die signierten in Facebook - Nutzer.
  2. Nachdem ein Benutzer erfolgreich anmeldet, den Zugang Austausch für einen Firebase Berechtigungs - Token und Authentifizieren mit Firebase die Firebase Berechtigungsnachweis verwenden:
    firebase::auth::Credential credential =
        firebase::auth::FacebookAuthProvider::GetCredential(access_token);
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithCredential(credential);
    
  3. Wenn Ihr Programm ein Update - Schleife hat , dass läuft regelmäßig (etwa bei 30 oder 60 mal pro Sekunde), können Sie die Ergebnisse überprüfen einmal pro Update mit Auth::SignInWithCredentialLastResult :
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithCredentialLastResult();
    if (result.status() == firebase::kFutureStatusComplete) {
      if (result.error() == firebase::auth::kAuthErrorNone) {
        firebase::auth::User* user = *result.result();
        printf("Sign in succeeded for `%s`\n", user->display_name().c_str());
      } else {
        printf("Sign in failed with error '%s'\n", result.error_message());
      }
    }
    
    Oder, wenn Ihr Programm ereignisgesteuert, können Sie es vorziehen um einen Rückruf über die Zukunft zu registrieren .

Registrieren Sie einen Rückruf auf einem Future

Einige Programme haben Update , die 30 oder 60 Mal pro Sekunde aufgerufen werden. Viele Spiele folgen beispielsweise diesem Modell. Diese Programme können den Anruf LastResult Funktionen asynchrone Aufrufe abzufragen. Wenn Ihr Programm jedoch ereignisgesteuert ist, können Sie es vorziehen, Callback-Funktionen zu registrieren. Eine Callback-Funktion wird nach Abschluss des Future 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::User*> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // `&my_program_context` is passed verbatim to OnCreateCallback().
  result.OnCompletion(OnCreateCallback, &my_program_context);
}
Die Callback - Funktion kann auch eine Lambda sein, wenn Sie es vorziehen.
void CreateUserUsingLambda(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  firebase::Future<firebase::auth::User*> 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 anmeldet, wird ein neues Benutzerkonto erstellt und mit den Anmeldeinformationen – d. h. Benutzername und Kennwort, Telefonnummer oder Authentifizierungsanbieterinformationen – verknüpft, mit denen sich der Benutzer angemeldet hat. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um einen Benutzer in jeder App in Ihrem Projekt zu identifizieren, unabhängig davon, wie sich der Benutzer anmeldet.

  • In Ihren Anwendungen können Sie die Benutzerprofilgrundinformationen aus dem erhaltenen firebase::auth::User

    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();
    }
    
  • In Ihrer Datenbank und Firebase Realtime Cloud Storage Sicherheitsregeln , können Sie die angemeldeten Nutzer die eindeutige Benutzer - ID aus der bekommen auth Variable, und es verwenden , um steuern kann ein Benutzer Zugriff , welche Daten.

Sie können Benutzer erlauben , durch mehrere Authentifizierungsanbieter anmelden, um Ihre App Verknüpfung Auth - Provider - Anmeldeinformationen zu einem vorhandenen Benutzerkonto.

Um einen Benutzer abzumelden, rufen SignOut() :

auth->SignOut();