Ta strona została przetłumaczona przez Cloud Translation API.

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

Za pomocą Firebase Authentication możesz zezwolić użytkownikom na uwierzytelnianie się w Firebase przy użyciu adresów e-mail i haseł oraz zarządzać kontami opartymi na hasłach w aplikacji.

Zanim zaczniesz

Dodaj Firebase do projektu w C++.
Jeśli nie masz jeszcze połączonej aplikacji z projektem Firebase, zrób to w konsoli Firebase.
Włącz logowanie za pomocą adresu e-mail i hasła:
1. W konsoli Firebase otwórz sekcję Autoryzacja.
2. Na karcie Metoda logowania włącz metodę logowania Adres e-mail i hasło, a następnie kliknij Zapisz.

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

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

Dodaj pliki nagłówka Auth i App:

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

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

Uzyskaj dostęp do zajęć firebase::auth::Auth dla firebase::App. Wartości App i Auth są ze sobą powiązane jeden do jednego.
```
firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
```

Tworzenie konta z hasłem

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

Gdy nowy użytkownik zarejestruje się w aplikacji, wykonaj nowe czynności weryfikacyjne konta wymagane przez aplikację, np. sprawdź, czy hasło do nowego konta zostało poprawnie wpisane 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 funkcji Auth::CreateUserWithEmailAndPassword:
```
firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPassword(email, password);
```

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

Aby chronić Twój projekt przed nadużyciami, Firebase ogranicza liczbę nowych rejestracji za pomocą adresu e-mail i hasła oraz rejestracji anonimowych, które mogą docierać do aplikacji z tego samego adresu IP w krótkim czasie. Możesz poprosić o tymczasową zmianę limitu i zaplanować ją w konsoli Firebase.

Logowanie użytkownika przy użyciu adresu e-mail i hasła

Procedura logowania się użytkownika za pomocą hasła jest podobna do procedury tworzenia nowego konta. W funkcji logowania w aplikacji:

Gdy użytkownik zaloguje się w Twojej 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 działa regularnie (np. 30 lub 60 razy na sekundę), możesz sprawdzać wyniki raz na aktualizację za pomocą funkcji 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 opiera się na zdarzeniach, możesz zarejestrować wywołanie zwrotne w przyszłości.

Rejestrowanie wywołania zwrotnego w przypadku funkcji Future

Niektóre programy mają funkcje Update, które są wywoływane 30 lub 60 razy na sekundę. Taki model stosuje się na przykład w przypadku wielu gier. Te programy mogą wywoływać funkcje LastResultdo sprawdzania połączeń asynchronicznych. Jeśli jednak Twój program jest sterowany zdarzeniami, możesz użyć funkcji wywołania zwrotnego. Po zakończeniu działania funkcji Future wywoływana jest funkcja wywołania zwrotnego.

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 też być 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: skonfiguruj zasady dotyczące haseł

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

Aby skonfigurować zasadę dotyczącą haseł w projekcie, otwórz kartę Zasady dotyczące haseł na stronie Ustawienia uwierzytelniania w konsoli Firebase:

Ustawienia uwierzytelniania

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

Wymagane są małe litery
Wymagana jest duża litera
Wymagany znak liczbowy
Wymagany znak niealfanumeryczny

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

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

Wymagaj: próby rejestracji nie będą się udawać, dopóki użytkownik nie zmieni hasła zgodnie z Twoimi zasadami.
Powiadomienie: użytkownicy mogą się rejestrować przy użyciu hasła, które nie spełnia wymogów. Korzystając z tego trybu, sprawdź, czy hasło użytkownika jest zgodne z zasadami po stronie klienta, i poproś użytkownika o zmianę hasła, jeśli nie jest ono zgodne z zasadami.

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

Jeśli masz aktywnych użytkowników, nie zalecamy włączania wymuszania aktualizacji podczas logowania, chyba że zamierzasz zablokować dostęp użytkownikom, których hasła nie są zgodne z Twoimi zasadami. Zamiast tego użyj trybu informowania, który pozwala użytkownikom na logowanie się za pomocą bieżących haseł i informuje ich o wymaganiach, których ich hasło nie spełnia.

Zalecane: włącz ochronę przed wyliczaniem adresów e-mail

Niektóre metody Firebase Authentication, które przyjmują adresy e-mail jako parametry, zgłaszają określone błędy, jeśli adres e-mail jest niezarejestrowany, gdy musi być zarejestrowany (np. podczas logowania się za pomocą adresu e-mail i hasła), lub zarejestrowany, gdy musi być nieużywany (np. podczas zmiany adresu e-mail użytkownika). Może to być przydatne, jeśli chcesz zaproponować użytkownikom konkretne rozwiązania, ale może też zostać wykorzystane przez osoby o złych zamiarach do wykrycia 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 gcloud Google Cloud. Pamiętaj, że włączenie tej funkcji zmienia działanie raportowania błędów w Firebase Authentication: dopilnuj, aby Twoja aplikacja nie polegała na bardziej szczegółowych błędach.

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 dostawcy uwierzytelniania, za pomocą których użytkownik się zalogował. To nowe konto jest przechowywane w projekcie Firebase i może służyć do identyfikowania użytkownika we wszystkich aplikacjach w projekcie, niezależnie od tego, jak użytkownik się loguje.

W swoich aplikacjach możesz pobrać 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 Firebase Realtime Database i Cloud Storage Regułach bezpieczeństwa możesz pobrać z zmiennej auth unikalny identyfikator zalogowanego użytkownika i używać go do kontrolowania dostępu użytkownika do danych.

Możesz zezwolić użytkownikom na logowanie się w aplikacji za pomocą danych uwierzytelniających od różnych dostawców, łącząc je z dotychczasowym kontem użytkownika.

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

auth->SignOut();

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

Zanim zaczniesz

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

Tworzenie konta z hasłem

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