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

Zacznij korzystać z uwierzytelniania Firebase w C++

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

Możesz użyć uwierzytelniania Firebase, aby umożliwić użytkownikom logowanie się do Twojej aplikacji przy użyciu co najmniej jednej metody logowania, w tym logowania za pomocą adresu e-mail i hasła oraz dostawców tożsamości federacyjnych, takich jak Logowanie przez Google i Logowanie przez Facebook. Ten samouczek umożliwia rozpoczęcie pracy z Uwierzytelnianiem 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 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 Firebase C++ SDK do projektu C++.

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

Zarejestruj nowych użytkowników

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

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

Stan operacji tworzenia konta można sprawdzić, rejestrując wywołanie zwrotne w obiekcie przyszłości CreateUserWithEmailAndPasswordLastResult lub, jeśli piszesz grę lub aplikację z jakąś pętlą okresowej aktualizacji, odpytując stan w pętli aktualizacji.

Na przykład, używając Przyszłości:

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 użyć sondowania, wykonaj coś takiego jak następujący przykład w pętli aktualizacji twojej 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 się 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 taki sam sposób, w jaki uzyskałeś wynik rejestracji.

Ustaw odbiornik stanu uwierzytelniania i uzyskaj dane konta

Aby odpowiedzieć na zdarzenia logowania i wylogowania, dołącz odbiornik 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 odbiornik, implementując klasę abstrakcyjną 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: