Uwierzytelniaj się za pomocą GitHub i C++

Możesz zezwolić użytkownikom na uwierzytelnianie w Firebase przy użyciu ich kont GitHub, integrując uwierzytelnianie GitHub ze swoją aplikacją.

Zanim zaczniesz

  1. Dodaj Firebase do projektu C ++ .
  2. W konsoli Firebase otwórz sekcję Auth.
  3. Na karcie Logowanie w metodzie umożliwienia usługodawcy GitHub.
  4. Dodaj identyfikator klienta oraz tajny z konsoli programisty dostawcy do konfiguracji operatora:
    1. Zarejestrować swoją aplikację jako aplikacja deweloperem na GitHub i zdobycie aplikacji OAuth 2.0 identyfikator klienta oraz tajne.
    2. Upewnij się, że Firebase OAuth przekierowanie URI (np my-app-12345.firebaseapp.com/__/auth/handler ) jest ustawiony jako odpowiedzialnego zwrotnego adresu URL strony w ustawieniach aplikacji na własną GitHub aplikacji config .
  5. Kliknij przycisk Zapisz.

Uzyskaj dostęp do firebase::auth::Auth klasę

Auth klasa jest bramą do wszystkich wywołań API.
  1. Dodaj pliki nagłówka uwierzytelniania i aplikacji:
    #include "firebase/app.h"
#include "firebase/auth.h"
  2. W kodzie inicjującym utwórz firebase::App klasy.
    #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. Nabyć firebase::auth::Auth klasę dla firebase::App . Istnieje odwzorowanie jeden do jednego między App i Auth .
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);

Uwierzytelnij się w Firebase

  1. Postępuj zgodnie z instrukcjami wyświetlanymi na Androida i iOS + dostać token dla zalogowanych GitHub użytkownika.
  2. Po użytkownik pomyślnie znaki, wymieniać token dla poświadczeń Firebase i uwierzytelniania Firebase używając Firebase poświadczenia:
    firebase::auth::Credential credential =
    firebase::auth::GitHubAuthProvider::GetCredential(token);
firebase::Future<firebase::auth::User*> result =
    auth->SignInWithCredential(credential);
  3. Jeśli program ma pętlę aktualizacji, który kursuje regularnie (powiedzmy na 30 lub 60 razy na sekundę), można sprawdzić wyniki raz w aktualizacji z 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());
  }
}
    lub, jeśli program jest sterowany zdarzeniami, może wolisz aby zarejestrować wywołania zwrotnego na przyszłość .

Zarejestruj oddzwonienie w przyszłości

Niektóre programy mają Update funkcje, które nazywane są 30 lub 60 razy na sekundę. Na przykład wiele gier podąża za tym modelem. Programy te mogą wywołać LastResult funkcje odpytywanie połączeń asynchronicznych. Jeśli jednak Twój program jest sterowany zdarzeniami, możesz chcieć zarejestrować funkcje wywołania zwrotnego. Funkcja wywołania zwrotnego jest wywoływana po zakończeniu przyszłości.
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);
}
Funkcja zwrotna może być również lambda, jeśli wolisz.
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);
}

Następne kroki

Gdy użytkownik zaloguje się po raz pierwszy, zostanie utworzone nowe konto użytkownika i połączone z poświadczeniami — czyli nazwą użytkownika i hasłem, numerem telefonu lub informacjami o dostawcy uwierzytelniania — przy użyciu których użytkownik się zalogował. To nowe konto jest przechowywane jako część projektu Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w projekcie, niezależnie od tego, jak się on loguje.

  • W aplikacjach, można uzyskać podstawowe informacje o profilu użytkownika z firebase::auth::User obiektu:

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

  • W bazie danych Firebase Realtime i Cloud Storage zasad bezpieczeństwa , można uzyskać podpisanego w unikalnym identyfikatorem użytkownika użytkownika z auth zmiennej i użyć go do kontroli, jakie dane dostępu może użytkownik.

Można zezwolić użytkownikom na logowanie się do aplikacji przy użyciu wielu dostawców uwierzytelniania przez łączenie auth poświadczenia dostawcy do istniejącego konta użytkownika.

Aby wylogować użytkownika, zadzwoń SignOut() :

auth->SignOut();