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

Możesz umożliwić użytkownikom uwierzytelnianie się w Firebase za pomocą kont GitHub, integrując uwierzytelnianie GitHub z aplikacją.

Zanim zaczniesz

  1. Dodaj Firebase do projektu C++.
  2. W konsoli Firebase otwórz Zabezpieczenia > Uwierzytelnianie.
  3. Na karcie Metoda logowania włącz dostawcę logowania GitHub.
  4. Dodaj identyfikator klienta i tajny klucz klienta z konsoli dewelopera tego dostawcy do konfiguracji dostawcy:
    1. Zarejestruj aplikację jako aplikację dewelopera na GitHubie i uzyskaj OAuth 2.0 identyfikator klienta oraz tajny klucz klienta.
    2. Upewnij się, że 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 w konfiguracji aplikacji na GitHubie.
  5. Kliknij Zapisz.

Dostęp do zajęć firebase::auth::Auth

Klasa Auth jest bramą do wszystkich wywołań interfejsu API.
  1. Dodaj pliki nagłówkowe Auth i App: 
    #include "firebase/app.h"
#include "firebase/auth.h"
  2. W kodzie inicjującym utwórz a firebase::App klasę. 
    #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. Pobierz zajęcia firebase::auth::Auth dla firebase::App. Istnieje mapowanie 1:1 między App a Auth. 
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);

Uwierzytelnianie w Firebase

  1. Postępuj zgodnie z instrukcjami dotyczącymi Androida i iOS+ , aby uzyskać token dla zalogowanego użytkownika GitHub.
  2. Gdy użytkownik zaloguje się, wymień token na dane logowania Firebase i uwierzytelnij się w Firebase za pomocą tych danych: 
    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 jest wykonywana regularnie (np. 30 lub 60 razy na sekundę), możesz sprawdzać wyniki raz na aktualizację za pomocą 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());
  }
}
     Jeśli Twój program jest oparty na zdarzeniach, możesz zarejestrować wywołanie zwrotne w obiekcie Future.

Rejestrowanie wywołania zwrotnego w obiekcie Future

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ć funkcje LastResult, aby sondować wywołania asynchroniczne. Jeśli jednak Twój program jest oparty na zdarzeniach, możesz zarejestrować funkcje wywołania zwrotnego. Funkcja wywołania zwrotnego jest wywoływana po zakończeniu obiektu Future. 
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 być też wyrażeniem lambda. 
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, zostanie utworzone nowe konto użytkownika i połączone z danymi logowania – nazwą użytkownika i hasłem, numerem telefonu lub informacjami o dostawcy uwierzytelniania – za pomocą których użytkownik się zalogował. To nowe konto jest przechowywane jako część projektu w Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w projekcie, niezależnie od sposobu logowania.

  • W aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z obiektu 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();
}

  • W regułach bezpieczeństwa Firebase Realtime Database i Cloud Storage bazy danych czasu rzeczywistego Firebase i Cloud Storage, możesz uzyskać unikalny identyfikator zalogowanego użytkownika z zmiennej auth, i użyć go do kontrolowania, do jakich danych użytkownik może mieć dostęp.

Możesz zezwolić użytkownikom na logowanie się w aplikacji za pomocą wielu dostawców uwierzytelniania przez połączenie danych logowania dostawcy uwierzytelniania z istniejącym kontem użytkownika.

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

auth->SignOut();