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

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

Aby umożliwić użytkownikom uwierzytelnianie przy użyciu: Firebase Authentication, Firebase za pomocą ich adresów e-mail i haseł oraz do zarządzania kont opartych na haśle.

Zanim zaczniesz

Dodaj Firebase do projektu C++.
Jeśli Twoja aplikacja nie jest jeszcze połączona z projektem Firebase, zrób to na stronie konsolę Firebase.
Włącz logowanie za pomocą adresu e-mail/hasła:
1. W konsoli Firebase otwórz sekcję Autoryzacja.
2. Na karcie Metoda logowania włącz logowanie Adres e-mail/hasło. i 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 opartego na haśle

Aby utworzyć nowe konto użytkownika z hasłem, wykonaj następujące czynności w sekcji kod logowania do aplikacji:

Gdy nowy użytkownik zarejestruje się za pomocą formularza rejestracji w aplikacji, wpisz wszystkie nowe weryfikacji konta wymaganych przez aplikację, takich jak sprawdzenie, czy nowe hasło do konta jest wpisane poprawnie i jest zgodne z Twoją złożonością .

Utwórz nowe konto, przekazując jego adres e-mail i hasło. do 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. przy 30 lub 60 sekundzie) razy na sekundę), możesz sprawdzić wyniki raz na każdą aktualizację, 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 za pomocą 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 oraz 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. przy 30 lub 60 sekundzie) razy na sekundę), możesz sprawdzić wyniki raz na każdą aktualizację, 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 sterowany zdarzeniami, możesz zarejestrować wywołanie zwrotne w obiekcie Future.

Rejestrowanie oddzwonienia w przyszłości

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 LastResultdo sprawdzania połączeń asynchronicznych. Jeśli jednak Twój program jest sterowany zdarzeniami, możesz użyć funkcji wywołania zwrotnego. Funkcja wywołania zwrotnego jest wywoływana po zakończeniu okresu przyszłego.

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ć lambdą.

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: ustaw zasady dotyczące haseł

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

Aby skonfigurować zasady dotyczące haseł w projekcie, otwórz Zasady dotyczące haseł na stronie Authentication Settings (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 jest znak liczbowy
Wymagany znak niealfanumeryczny

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

Wymuszanie stosowania 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.
Powiadomienie: użytkownicy mogą logować się 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, zalecamy nie włączanie trybu wymaganego, chyba że chcesz zablokować dostęp użytkownikom, których hasła nie są zgodne z Twoimi zasadami. Zamiast tego użyj trybu powiadomień, w którym użytkownicy mogą logować się przy użyciu haseł i poinformować ich o wymaganiach, których hasło nie spełnia.

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

Niektóre metody typu Firebase Authentication, które przyjmują adresy e-mail jako parametry, określone błędy, jeśli adres e-mail nie został zarejestrowany, a należało go zarejestrować; (np. podczas logowania się za pomocą adresu e-mail i hasła) lub gdy musi być nieużywany (na przykład podczas zmiany adresu e-mail użytkownika). Może to być przydatne do proponowania użytkownikom konkretnych rozwiązań, ale może też zostać wykorzystane przez osoby o złych zamiarach do wykrywania adresów e-mail zarejestrowanych przez Twoich użytkowników.

Aby ograniczyć to ryzyko, zalecamy włączenie ochrony przed wyliczeniem adresów e-mail. swojego projektu za pomocą narzędzia gcloud Google Cloud. Pamiętaj, że włączenie tej opcji zmienia działanie funkcji raportowania błędów w Firebase Authentication: upewnij się, że aplikacja nie polega 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 przy użyciu wielokrotnego uwierzytelniania. dostawców, łącząc dane logowania dostawcy uwierzytelniania z istniejącego konta użytkownika.

Aby wylogować użytkownika, wywołaj 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 opartego na haśle

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