Join us in person and online for Firebase Summit on October 18, 2022. Learn how Firebase can help you accelerate app development, release your app with confidence, and scale with ease. Register now

Uwierzytelnianie za pomocą GitHub i C++

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Możesz pozwolić swoim 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 swojego projektu C++ .
  2. W konsoli Firebase otwórz sekcję Auth .
  3. Na karcie Metoda logowania włącz dostawcę GitHub .
  4. Dodaj identyfikator klienta i klucz tajny klienta z konsoli programisty tego dostawcy do konfiguracji dostawcy:
    1. Zarejestruj swoją aplikację jako aplikację deweloperską w GitHub i uzyskaj identyfikator klienta OAuth 2.0 oraz klucz tajny klienta .
    2. Upewnij się, że identyfikator URI przekierowania Firebase OAuth (np my-app-12345.firebaseapp.com/__/auth/handler ) jest ustawiony jako adres URL wywołania zwrotnego autoryzacji na stronie ustawień aplikacji w konfiguracji aplikacji GitHub .
  5. Kliknij Zapisz .

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

Klasa Auth jest bramą dla wszystkich wywołań API.
  1. Dodaj pliki nagłówkowe Auth i App:
    #include "firebase/app.h"
    #include "firebase/auth.h"
    
  2. W kodzie inicjującym utwórz klasę 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 klasę firebase::auth::Auth dla swojej firebase::App . Istnieje mapowanie 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 dla Androida i iOS+ , aby uzyskać token dla zalogowanego użytkownika GitHub.
  2. Po pomyślnym zalogowaniu się użytkownika wymień token na poświadczenia Firebase i uwierzytelnij się w Firebase przy użyciu poświadczeń Firebase:
    firebase::auth::Credential credential =
        firebase::auth::GitHubAuthProvider::GetCredential(token);
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithCredential(credential);
    
  3. Jeśli Twój program ma pętlę aktualizacji, która działa regularnie (powiedzmy 30 lub 60 razy na sekundę), możesz sprawdzić wyniki raz na aktualizację za pomocą 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 Twój program jest sterowany zdarzeniami, możesz preferować aby zarejestrować oddzwonienie w przyszłości .

Zarejestruj oddzwonienie 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 jest zgodnych z tym modelem. Te programy mogą wywoływać funkcje LastResult w celu odpytywania wywołań 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 wywołania zwrotnego może być również lambdą, 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 — za pomocą 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 swoich aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z obiektu 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();
    }
    
  • W regułach bezpieczeństwa bazy danych czasu rzeczywistego i usługi Cloud Storage Firebase możesz uzyskać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i używać go do kontrolowania, do jakich danych użytkownik może uzyskać dostęp.

Możesz zezwolić użytkownikom na logowanie się do Twojej aplikacji przy użyciu wielu dostawców uwierzytelniania, łącząc poświadczenia dostawcy uwierzytelniania z istniejącym kontem użytkownika.

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

auth->SignOut();