Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Uwierzytelniaj za pomocą Firebase za pomocą kont opartych na haśle w C++

Za pomocą usługi Firebase Authentication możesz umożliwić użytkownikom uwierzytelnianie się w Firebase przy użyciu adresów e-mail i haseł oraz zarządzać kontami w aplikacji, które są chronione hasłem.

Zanim zaczniesz

Dodaj Firebase do projektu C++.
Jeśli nie masz jeszcze połączonej aplikacji z projektem w Firebase, zrób to w Firebase konsoli.
Włącz logowanie za pomocą adresu e-mail i hasła jako dostawcę logowania w projekcie w Firebase:
1. W konsoli Firebase kliknij Bezpieczeństwo > Uwierzytelnianie.
2. Na karcie Metoda logowania włącz dostawcę logowania Adres e-mail/hasło.
3. Kliknij Zapisz.
Wskazówka: jeśli wolisz używać Firebase CLI, uruchom firebase init auth aby skonfigurować dostawców uwierzytelniania, a następnie uruchom firebase deploy --only auth aby wdrożyć zmiany w projekcie.

Dostęp do zajęć `firebase::auth::Auth`

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

Dodaj pliki nagłówkowe Auth i App:

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

W kodzie inicjującym utwórz a firebase::App klasę.

#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__)

Pobierz zajęcia firebase::auth::Auth dla firebase::App. Istnieje mapowanie 1:1 między App a Auth.
```
firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
```

Tworzenie konta chronionego hasłem

Aby utworzyć nowe konto użytkownika z hasłem, wykonaj te czynności w kodzie logowania aplikacji:

Gdy nowy użytkownik zarejestruje się za pomocą formularza rejestracji w aplikacji, wykonaj wszystkie wymagane przez aplikację kroki weryfikacji nowego konta, np. sprawdź, czy hasło nowego konta zostało wpisane prawidłowo i czy spełnia wymagania dotyczące złożoności.

Utwórz nowe konto, przekazując adres e-mail i hasło nowego użytkownika do Auth::CreateUserWithEmailAndPassword:

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

Jeśli Twój program ma pętlę aktualizacji, która jest wykonywana regularnie (np. 30 lub 60 razy na sekundę), możesz sprawdzać wyniki raz na aktualizację za pomocą Auth::CreateUserWithEmailAndPasswordLastResult:

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

Jeśli Twój program jest oparty na zdarzeniach, możesz zarejestrować wywołanie zwrotne w obiekcie Future.

Logowanie użytkownika za pomocą adresu e-mail i hasła

Czynności związane z logowaniem użytkownika za pomocą hasła są podobne do czynności związanych z tworzeniem nowego konta. W funkcji logowania aplikacji wykonaj te czynności:

Gdy użytkownik zaloguje się w aplikacji, przekaż jego adres e-mail i hasło do firebase::auth::Auth::SignInWithEmailAndPassword:
```
firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithEmailAndPassword(email, password);
```

Jeśli Twój program ma pętlę aktualizacji, która jest wykonywana regularnie (np. 30 lub 60 razy na sekundę), możesz sprawdzać wyniki raz na aktualizację za pomocą Auth::SignInWithEmailAndPasswordLastResult:

firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithEmailAndPasswordLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    const firebase::auth::AuthResult auth_result = *result.result();
    printf("Sign in succeeded for email %s\n",
           auth_result.user.email().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 zarejestrować wywołanie zwrotne w obiekcie Future.

Rejestrowanie wywołania zwrotnego w obiekcie Future

Niektóre programy mają funkcje Update, które są wywoływane 30 lub 60 razy na sekundę. Na przykład wiele gier korzysta z tego modelu. Te programy mogą wywoływać funkcje LastResult, aby sondować wywołania asynchroniczne. Jeśli jednak Twój program jest oparty na zdarzeniach, możesz zarejestrować funkcje wywołania zwrotnego. Funkcja wywołania zwrotnego jest wywoływana po zakończeniu obiektu 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);
}

Jeśli wolisz, funkcja wywołania zwrotnego może być też wyrażeniem lambda.

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);
}

Zalecane: ustawienie zasad dotyczących haseł

Możesz zwiększyć bezpieczeństwo kont, egzekwując wymagania dotyczące złożoności haseł.

Aby skonfigurować zasady dotyczące haseł w projekcie, otwórz sekcję Zasady dotyczące haseł na karcie Bezpieczeństwo > Uwierzytelnianie > Ustawienia w konsoli Firebase:

Ustawienia uwierzytelniania

Firebase Authentication zasady dotyczące haseł obsługują te wymagania dotyczące haseł:

Wymagany jest znak pisany małą literą.
Wymagany jest znak pisany wielką literą.
Wymagany jest znak numeryczny.
Wymagany jest znak niealfanumeryczny.

Wymaganie dotyczące znaku niealfanumerycznego spełniają te znaki: ^ $ * . [ ] { } ( ) ? " ! @ # % & / \ , > < ' : ; | _ ~
Minimalna długość hasła (od 6 do 30 znaków; domyślnie 6).
Maksymalna długość hasła (maksymalnie 4096 znaków).

Egzekwowanie zasad dotyczących haseł możesz włączyć w 2 trybach:

Wymagaj: logowanie nie będzie możliwe, dopóki użytkownik nie zmieni hasła zgodnie z zasadami.
Powiadom: użytkownicy mogą się rejestrować za pomocą hasła niezgodnego z zasadami. W tym trybie musisz sprawdzić po stronie klienta, czy hasło użytkownika jest zgodne z zasadami, i w jakiś sposób poprosić użytkownika o zaktualizowanie hasła, jeśli nie jest ono zgodne.

Nowi użytkownicy zawsze muszą wybrać hasło zgodne z zasadami.

Jeśli masz aktywnych użytkowników, zalecamy, aby nie włączać wymuszania aktualizacji przy logowaniu, chyba że chcesz zablokować dostęp użytkownikom, których hasła nie są zgodne z zasadami. Zamiast tego użyj trybu powiadamiania, który umożliwia użytkownikom logowanie się za pomocą bieżących haseł, i poinformuj ich o wymaganiach, których ich hasła nie spełniają.

Zalecane: włączenie ochrony przed wyliczaniem adresów e-mail

Niektóre metody Firebase Authentication przyjmujące adresy e-mail jako parametry zgłaszają określone błędy, jeśli adres e-mail nie jest zarejestrowany, gdy powinien być zarejestrowany (np. podczas logowania się za pomocą adresu e-mail i hasła), lub jest zarejestrowany gdy nie powinien być używany (np. podczas zmiany adresu e-mail użytkownika). Może to być przydatne do sugerowania użytkownikom konkretnych rozwiązań, ale może też zostać wykorzystane przez złośliwych użytkowników do odkrywania adresów e-mail zarejestrowanych przez Twoich użytkowników.

Aby zmniejszyć to ryzyko, zalecamy włączenie ochrony przed wyliczaniem adresów e-mail w projekcie za pomocą narzędzia Google Cloud gcloud. Pamiętaj, że włączenie tej funkcji zmienia sposób raportowania błędów przez usługę Firebase Authentication. Upewnij się, że Twoja aplikacja nie korzysta z bardziej szczegółowych błędów.

Dalsze kroki

Gdy użytkownik zaloguje się po raz pierwszy, zostanie utworzone nowe konto użytkownika i połączone z danymi logowania – 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 projekcie w Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji 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 regułach bezpieczeństwa Firebase Realtime Database i Cloud Storage bazy danych czasu rzeczywistego Firebase i Cloud Storage, możesz uzyskać unikalny identyfikator zalogowanego użytkownika z zmiennej auth, i użyć go do kontrolowania, do jakich danych użytkownik może mieć dostęp.

Możesz zezwolić użytkownikom na logowanie się w aplikacji za pomocą wielu dostawców uwierzytelniania przez połączenie danych logowania dostawcy uwierzytelniania z istniejącym kontem użytkownika.

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

auth->SignOut();