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

Authentifizieren mit Twitter und C++

Sie können Ihre Benutzer mit ihren Twitter-Konten bei Firebase authentifizieren, indem Sie die Twitter-Authentifizierung in Ihre App integrieren.

Bevor Sie beginnen

  1. In Firebase zu Ihrem C ++ Projekt .
  2. In der Firebase Konsole , öffnen Sie den Abschnitt Auth.
  3. Auf dem Anmelden Methode Registerkarte, aktivieren Sie den Twitter - Anbieter.
  4. Fügen Sie den API - Schlüssel und API Geheimnis von den betreffenden Anbieter Entwickler - Konsole an die Provider - Konfiguration:
    1. Registrieren Sie Ihre App als Entwickler - Anwendung auf Twitter und erhalten Sie Ihre App-OAuth - API - Schlüssel und API Geheimnis.
    2. Stellen Sie sicher , dass Ihre Firebase OAuth Umleitung URI (zB my-app-12345.firebaseapp.com/__/auth/handler ) , wird als Ihre URL Authorization Rückrufs in Ihrem App - Einstellungen Seite auf Ihrem Twitter - App config .
  5. Klicken Sie auf Speichern.

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 die Anmeldung mit Twitter Dokumentation eine OAuth - Zugriffstoken und ein OAuth Geheimnis zu bekommen.
  2. Nachdem ein Benutzer erfolgreich in Zeichen, tauscht das Token und Geheimnis für eine Firebase Berechtigungsnachweis und Authentifizieren mit Firebase der Firebase mit Berechtigungsnachweis:
    firebase::auth::Credential credential =
        firebase::auth::TwitterAuthProvider::GetCredential(token, secret);
    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();