Uwierzytelnij się za pomocą GitHub i C ++

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

Dodaj Firebase do swojego projektu w C ++ .
W konsoli Firebase otwórz sekcję Auth .
Na karcie Metoda logowania włącz dostawcę GitHub .
Dodaj identyfikator klienta i klucz tajny klienta z konsoli programisty tego dostawcy do konfiguracji dostawcy:
1. Zarejestruj swoją aplikację jako aplikację deweloperską na GitHub i uzyskaj identyfikator klienta OAuth 2.0 oraz klucz tajny klienta .
2. Upewnij się, że identyfikator URI przekierowania my-app-12345.firebaseapp.com/__/auth/handler 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 .
Kliknij Zapisz .

Uzyskaj dostęp do klasy `firebase::auth::Auth`

Klasa Auth jest bramą dla wszystkich wywołań API.

Dodaj pliki nagłówkowe uwierzytelniania i aplikacji:

#include "firebase/app.h"
#include "firebase/auth.h"

W swoim 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__)

firebase::auth::Auth klasę firebase::auth::Auth dla swojego firebase::App . Istnieje mapowanie jeden do jednego między App a Auth .
```
firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
```

Uwierzytelnij się w Firebase

Postępuj zgodnie z instrukcjami dla Androida i iOS, aby uzyskać token dla zalogowanego użytkownika GitHub.

Po pomyślnym zalogowaniu się użytkownika wymień token na poświadczenie Firebase i uwierzytelnij się w Firebase, używając danych logowania Firebase:

firebase::auth::Credential credential =
    firebase::auth::GitHubAuthProvider::GetCredential(token);
firebase::Future<firebase::auth::User*> result =
    auth->SignInWithCredential(credential);

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 się zarejestrować oddzwonienie w sprawie przyszłości .

Zarejestruj oddzwonienie w Future

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 celu odpytywania wywołań asynchronicznych. Jeśli jednak Twój program jest sterowany zdarzeniami, możesz preferować rejestrację funkcji zwrotnych. Funkcja zwrotna jest wywoływana po ukoń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);
}

Jeśli wolisz, funkcja zwrotna może być również lambdą.

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 loguje się po raz pierwszy, tworzone jest nowe konto użytkownika i jest ono łączone z poświadczeniami - to jest z nazwą użytkownika i hasłem, numerem telefonu lub informacjami dostawcy uwierzytelniania - zalogowanym użytkownikiem. To nowe konto jest przechowywane jako część projektu Firebase i może służyć do identyfikacji użytkownika we wszystkich aplikacjach w Twoim projekcie, niezależnie od tego, w jaki sposób się on zaloguje.

W swoich aplikacjach możesz uzyskać podstawowe informacje o profilu firebase::auth::User 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 Firebase Realtime Database i Cloud Storage Rules możesz uzyskać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i używać go do kontrolowania, do jakich danych użytkownik ma dostęp.

Możesz zezwolić użytkownikom na logowanie się do 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();