Save the date - Google I/O returns May 18-20. Register to get the most out of the digital experience: Build your schedule, reserve space, participate in Q&As, earn Google Developer profile badges, and more. Register now
Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

Zacznij korzystać z uwierzytelniania Firebase w języku C ++

Możesz użyć uwierzytelniania Firebase, aby umożliwić użytkownikom logowanie się do Twojej aplikacji przy użyciu jednej lub kilku metod logowania, w tym logowania za pomocą adresu e-mail i hasła, oraz dostawców tożsamości federacyjnych, takich jak Google Sign-in i Facebook Login. Z tego samouczka dowiesz się, jak zacząć korzystać z uwierzytelniania Firebase, pokazując, jak dodać adres e-mail i hasło logowania do aplikacji.

Połącz swój projekt C ++ z Firebase

Aby móc korzystać z uwierzytelniania Firebase , musisz:

  • Zarejestruj swój projekt w C ++ i skonfiguruj go do korzystania z Firebase.

    Jeśli Twój projekt C ++ korzysta już z Firebase, oznacza to, że jest już zarejestrowany i skonfigurowany dla Firebase.

  • Dodaj pakiet SDK Firebase C ++ do projektu w języku C ++.

Pamiętaj, że dodanie Firebase do projektu C ++ obejmuje zadania zarówno w konsoli Firebase, jak iw otwartym projekcie C ++ (na przykład pobierasz pliki konfiguracyjne Firebase z konsoli, a następnie przenosisz je do projektu w C ++).

Zarejestruj nowych użytkowników

Utwórz formularz, który pozwoli nowym użytkownikom zarejestrować się w Twojej aplikacji przy użyciu adresu e-mail i hasła. Gdy użytkownik wypełni formularz, zweryfikuj adres e-mail i hasło podane przez użytkownika, a następnie przekaż je do metody CreateUserWithEmailAndPassword :

firebase::Future<firebase::auth::User*> result =
    auth->CreateUserWithEmailAndPassword(email, password);

Możesz sprawdzić stan operacji tworzenia konta, rejestrując wywołanie zwrotne w obiekcie CreateUserWithEmailAndPasswordLastResult Future lub, jeśli piszesz grę lub aplikację z pewnego rodzaju okresową pętlą aktualizacji, sondując stan w pętli aktualizacji.

Na przykład używając 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);

Lub, aby skorzystać z odpytywania, zrób coś podobnego do następującego przykładu w pętli aktualizacji gry:

firebase::Future<firebase::auth::User*> result =
    auth->CreateUserWithEmailAndPasswordLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    firebase::auth::User* user = *result.result();
    printf("Create user succeeded for email %s\n", user->email().c_str());
  } else {
    printf("Created user failed with error '%s'\n", result.error_message());
  }
}

Zaloguj istniejących użytkowników

Utwórz formularz, który umożliwi istniejącym użytkownikom logowanie się przy użyciu ich adresu e-mail i hasła. Gdy użytkownik wypełni formularz, wywołaj metodę SignInWithEmailAndPassword :

firebase::Future<firebase::auth::User*> result =
    auth->SignInWithEmailAndPassword(email, password);

Uzyskaj wynik operacji logowania w ten sam sposób, w jaki otrzymałeś wynik rejestracji.

Ustaw odbiornik stanu uwierzytelniania i pobierz dane konta

Aby odpowiedzieć na zdarzenia logowania i wylogowania, dołącz detektor do globalnego obiektu uwierzytelniania. Ten odbiornik jest wywoływany za każdym razem, gdy zmienia się stan logowania użytkownika. Ponieważ odbiornik działa dopiero po pełnym zainicjowaniu obiektu uwierzytelniania i po zakończeniu wszelkich wywołań sieciowych, jest to najlepsze miejsce do uzyskania informacji o zalogowanym użytkowniku.

Utwórz detektor, implementując abstrakcyjną klasę firebase::auth::AuthStateListener . Na przykład, aby utworzyć odbiornik, który pobiera informacje o użytkowniku, gdy użytkownik pomyślnie się zaloguje:

class MyAuthStateListener : public firebase::auth::AuthStateListener {
 public:
  void OnAuthStateChanged(firebase::auth::Auth* auth) override {
    firebase::auth::User* user = auth->current_user();
    if (user != nullptr) {
      // User is signed in
      printf("OnAuthStateChanged: signed_in %s\n", user->uid().c_str());
      const std::string displayName = user->DisplayName();
      const std::string emailAddress = user->Email();
      const std::string photoUrl = user->PhotoUrl();
    } else {
      // User is signed out
      printf("OnAuthStateChanged: signed_out\n");
    }
    // ...
  }
};

Dołącz detektor za pomocą metody AddAuthStateListener obiektu firebase::auth::Auth :

MyAuthStateListener state_change_listener;
auth->AddAuthStateListener(&state_change_listener);

Następne kroki

Dowiedz się, jak dodać obsługę innych dostawców tożsamości i anonimowych kont gości: