Uwierzytelnij za pomocą logowania przez Google i języka C++

Możesz zezwolić użytkownikom na uwierzytelnianie w Firebase za pomocą kont Google, integrując logowanie przez Google z aplikacją.

Zanim zaczniesz

1. Dodaj Firebase do projektu C++.
2. Włącz Google jako metodę logowania w Firebasekonsoli:
   1. W Firebasekonsoli otwórz sekcję Uwierzytelnianie.
   2. Na karcie Metoda logowania włącz metodę logowania Google i kliknij Zapisz.
3. Gdy pojawi się odpowiedni komunikat w konsoli, pobierz zaktualizowany plik konfiguracyjny Firebase (google-services.json), który zawiera teraz informacje o kliencie OAuth wymagane do logowania przez Google.
4. Przenieś zaktualizowany plik konfiguracyjny do projektu Android Studio, zastępując nim nieaktualny plik konfiguracyjny. (Patrz Dodawanie Firebase do projektu aplikacji na Androida).

Otwórz zajęcia firebase::auth::Auth.

1. Dodaj pliki nagłówkowe Auth i App:

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

2. W kodzie inicjowania 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 dostęp do zajęć firebase::auth::Auth dla firebase::App. Istnieje bezpośrednie powiązanie między App a Auth.

   firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);

Uwierzytelnianie za pomocą Firebase

1. Aby uzyskać token identyfikatora logowania przez Google, postępuj zgodnie z instrukcjami dotyczącymi Androida i iOS.
2. Gdy użytkownik zaloguje się, wymień token identyfikatora na dane logowania Firebase i uwierzytelnij się w Firebase za pomocą tych danych:

   firebase::auth::Credential credential =
       firebase::auth::GoogleAuthProvider::GetCredential(google_id_token,
                                                         nullptr);
   firebase::Future<firebase::auth::AuthResult> result =
       auth->SignInAndRetrieveDataWithCredential(credential);

3. Jeśli program ma pętlę aktualizacji, która jest uruchamiana regularnie (np. 30 lub 60 razy na sekundę), możesz sprawdzać wyniki raz na aktualizację za pomocą funkcji 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 też zarejestrować wywołanie zwrotne w obiekcie Future.

Rejestrowanie wywołania zwrotnego w obiekcie 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);
}

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, 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 w ramach Twojego projektu w Firebase i może służyć do identyfikowania użytkownika we wszystkich aplikacjach 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 Firebase Realtime Database i Cloud Storage regułach bezpieczeństwa możesz pobrać unikalny identyfikator użytkownika zalogowanego ze zmiennej auth i użyć go do kontrolowania, do jakich danych użytkownik ma dostęp.

Możesz zezwolić użytkownikom na logowanie się w aplikacji za pomocą wielu dostawców uwierzytelniania, łącząc dane logowania dostawcy uwierzytelniania z istniejącym kontem użytkownika.

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

auth->SignOut();