Uwierzytelnij się z użyciem GitHuba i języka C++

Możesz zezwolić użytkownikom na uwierzytelnianie w Firebase za pomocą ich kont GitHub przez integrację uwierzytelniania GitHub z aplikacją.

Zanim zaczniesz

  1. Dodaj Firebase do projektu C++.
  2. W konsoli Firebase otwórz sekcję Uwierzytelnianie.
  3. Na karcie Metoda logowania włącz dostawcę GitHub.
  4. Dodaj Client ID (Identyfikator klienta) i Client Secret (Tajny klucz klienta) z konsoli programisty tego dostawcy do konfiguracja dostawcy:
    1. Rejestrowanie aplikacji jako programistę w GitHubie i uzyskaj identyfikator klienta OAuth 2.0 swojej aplikacji. i Client Secret (Tajny klucz klienta).
    2. Sprawdź, czy identyfikator URI przekierowania OAuth Firebase (np. my-app-12345.firebaseapp.com/__/auth/handler) jest ustawiony jako URL wywołania zwrotnego autoryzacji na stronie ustawień aplikacji Konfiguracja aplikacji GitHub.
  5. Kliknij Zapisz.

Uzyskaj dostęp do zajęć firebase::auth::Auth

Klasa Auth jest bramą dla wszystkich wywołań interfejsu API.
  1. Dodaj pliki nagłówka Auth i App: 
    #include "firebase/app.h"
#include "firebase/auth.h"
  2. W kodzie inicjowania utwórz 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__)
  3. Uzyskaj zajęcia firebase::auth::Auth związane z urządzeniem firebase::App. Między App a Auth występuje mapowanie 1:1. 
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);

Uwierzytelnij za pomocą Firebase

  1. Postępuj zgodnie z instrukcjami dotyczącymi: Androida, oraz iOS+ aby uzyskać token dla zalogowanego użytkownika GitHuba.
  2. Gdy użytkownik się zaloguje, zamień token na dane logowania do Firebase i uwierzytelnienie w Firebase za pomocą tej platformy. dane logowania: 
    firebase::auth::Credential credential =
    firebase::auth::GitHubAuthProvider::GetCredential(token);
firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredential(credential);
  3. Jeśli Twój program ma pętlę aktualizacji, która działa regularnie (np. przy 30 lub 60 sekundzie) razy na sekundę), możesz sprawdzić wyniki raz na każdą aktualizację, 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());
  }
}
    A jeśli Twój program jest oparty na zdarzeniach, możesz preferować zarejestruj się na oddzwonienie Przyszłość.

Rejestrowanie oddzwonienia w przyszłości

Niektóre programy mają funkcje Update, które są wywoływane 30 lub 60 razy na sekundę. Na przykład wiele gier korzysta z tego modelu. Te programy mogą wywoływać LastResult do sondowania wywołań asynchronicznych. Jeśli jednak Twój program jest oparty na zdarzeniach, możesz zarejestrować funkcje wywołań zwrotnych. Funkcja wywołania zwrotnego jest wywoływana po zakończeniu okresu przyszłego. 
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);
}
Jeśli wolisz, funkcja wywołania zwrotnego może też być lambdą. 
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);
}

Dalsze kroki

Gdy użytkownik zaloguje się po raz pierwszy, tworzone jest nowe konto użytkownika. powiązane z danymi logowania, czyli z nazwą użytkownika, hasłem i numerem telefonu, numer telefonu lub informacje o dostawcy uwierzytelniania – użytkownik zalogowany. Ten nowy jest przechowywane w ramach projektu Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w projekcie, niezależnie od tego, jak się loguje.

  • W swoich aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z Obiekt firebase::auth::User:

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

  • Na liście Firebase Realtime Database i Cloud Storage regułami zabezpieczeń, pobierz ze zmiennej auth unikalny identyfikator zalogowanego użytkownika, i używać ich do kontrolowania, do jakich danych użytkownik ma dostęp.

Możesz zezwolić użytkownikom na logowanie się w aplikacji przy użyciu wielokrotnego uwierzytelniania. dostawców, łącząc dane logowania dostawcy uwierzytelniania z istniejącego konta użytkownika.

Aby wylogować użytkownika, wywołaj SignOut():

auth->SignOut();