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

Uwierzytelnij się w Firebase przy użyciu numeru telefonu i języka C++

Możesz użyć uwierzytelniania Firebase, aby zalogować użytkownika, wysyłając wiadomość SMS na telefon użytkownika. Użytkownik loguje się za pomocą jednorazowego kodu zawartego w wiadomości SMS.

W tym dokumencie opisano, jak zaimplementować proces logowania za pomocą numeru telefonu przy użyciu pakietu Firebase SDK.

Zanim zaczniesz

Dodaj Firebase do swojego projektu C++ .
Jeśli nie połączyłeś jeszcze swojej aplikacji z projektem Firebase, zrób to z poziomu konsoli Firebase .
Zapoznaj się z wymaganiami dotyczącymi platformy dotyczącymi logowania za pomocą numeru telefonu:
- Logowanie za pomocą numeru telefonu jest dostępne tylko na platformach mobilnych.
- W systemie iOS logowanie za pomocą numeru telefonu wymaga fizycznego urządzenia i nie będzie działać na symulatorze.

Względy bezpieczeństwa

Uwierzytelnianie przy użyciu samego numeru telefonu, choć wygodne, jest mniej bezpieczne niż inne dostępne metody, ponieważ posiadanie numeru telefonu można łatwo przenosić między użytkownikami. Ponadto na urządzeniach z wieloma profilami użytkowników każdy użytkownik, który może odbierać wiadomości SMS, może zalogować się na konto przy użyciu numeru telefonu urządzenia.

Jeśli korzystasz z logowania za pomocą numeru telefonu w swojej aplikacji, powinieneś oferować je wraz z bezpieczniejszymi metodami logowania i informować użytkowników o kompromisach w zakresie bezpieczeństwa związanych z logowaniem za pomocą numeru telefonu.

Aby logować użytkowników za pomocą SMS-ów, musisz najpierw włączyć metodę logowania za pomocą numeru telefonu w swoim projekcie Firebase:

W konsoli Firebase otwórz sekcję Uwierzytelnianie .
Na stronie Metoda logowania włącz metodę logowania Numer telefonu .

Limit żądań logowania do numeru telefonu Firebase jest wystarczająco wysoki, aby nie miało to wpływu na większość aplikacji. Jeśli jednak musisz zalogować bardzo dużą liczbę użytkowników za pomocą uwierzytelniania telefonicznego, może być konieczne uaktualnienie planu cenowego. Zobacz stronę z cennikiem .

Zacznij otrzymywać powiadomienia APN (platformy Apple)

Aby korzystać z uwierzytelniania numeru telefonu na platformach Apple, Twoja aplikacja musi mieć możliwość odbierania powiadomień APN z Firebase. Gdy po raz pierwszy logujesz użytkownika przy użyciu numeru telefonu na urządzeniu, uwierzytelnianie Firebase wysyła do urządzenia ciche powiadomienie push, aby zweryfikować, czy prośba o zalogowanie się na numer telefonu pochodzi z Twojej aplikacji. (Z tego powodu logowanie za pomocą numeru telefonu nie może być używane w symulatorze).

Aby włączyć powiadomienia APN do użytku z uwierzytelnianiem Firebase:

W Xcode włącz powiadomienia push dla swojego projektu.
Prześlij swój certyfikat APNs do Firebase. Jeśli nie masz jeszcze certyfikatu APNs, utwórz go w Apple Developer Member Center .
1. W swoim projekcie w konsoli Firebase wybierz ikonę koła zębatego, wybierz Ustawienia projektu , a następnie wybierz kartę Cloud Messaging .
2. Wybierz przycisk Prześlij certyfikat dla swojego certyfikatu programistycznego, certyfikatu produkcyjnego lub obu. Wymagany jest co najmniej jeden.
3. Dla każdego certyfikatu wybierz plik .p12 i podaj hasło, jeśli istnieje. Upewnij się, że identyfikator pakietu dla tego certyfikatu jest zgodny z identyfikatorem pakietu Twojej aplikacji. Wybierz Zapisz .

Wyślij kod weryfikacyjny na telefon użytkownika

Aby zainicjować logowanie za pomocą numeru telefonu, przedstaw użytkownikowi interfejs z prośbą o podanie numeru telefonu, a następnie zadzwoń do PhoneAuthProvider::VerifyPhoneNumber , aby poprosić Firebase o wysłanie SMS-em kodu uwierzytelniającego na telefon użytkownika:

Uzyskaj numer telefonu użytkownika.
Wymagania prawne są różne, ale w ramach najlepszych praktyk i określenia oczekiwań użytkowników należy poinformować ich, że jeśli korzystają z logowania przez telefon, mogą otrzymać wiadomość SMS w celu weryfikacji i obowiązują standardowe stawki.

Zadzwoń do PhoneAuthProvider::VerifyPhoneNumber , przekazując do niej numer telefonu użytkownika.

class PhoneListener : public PhoneAuthProvider::Listener {
 public:
  ~PhoneListener() override {}

  void OnVerificationCompleted(PhoneAuthCredential credential) override {
    // Auto-sms-retrieval or instant validation has succeeded (Android only).
    // No need for the user to input the verification code manually.
    // `credential` can be used instead of calling GetCredential().
  }

  void OnVerificationFailed(const std::string& error) override {
    // Verification code not sent.
  }

  void OnCodeSent(const std::string& verification_id,
                  const PhoneAuthProvider::ForceResendingToken&
                      force_resending_token) override {
    // Verification code successfully sent via SMS.
    // Show the Screen to enter the Code.
    // Developer may want to save that verification_id along with other app states in case
    // the app is terminated before the user gets the SMS verification code.
  }
};

PhoneListener phone_listener;
PhoneAuhtOptions options;
options.timeout_milliseconds = kAutoVerifyTimeOut;
options.phone_number = phone_number;
PhoneAuthProvider& phone_provider = PhoneAuthProvider::GetInstance(auth);
phone_provider->VerifyPhoneNumber(options, &phone_listener);

Kiedy wywołujesz PhoneAuthProvider::VerifyPhoneNumber , Firebase,

(na iOS) wysyła ciche powiadomienie push do Twojej aplikacji,
wysyła wiadomość SMS zawierającą kod uwierzytelniający na podany numer telefonu i przekazuje identyfikator weryfikacyjny do funkcji uzupełniania. Aby zalogować użytkownika, będziesz potrzebować zarówno kodu weryfikacyjnego, jak i identyfikatora weryfikacyjnego.
Uwaga: w zależności od planu rozliczeniowego możesz być ograniczony do dziennego limitu wysyłanych wiadomości SMS. Zobacz Limity uwierzytelniania Firebase .

Zapisz identyfikator weryfikacyjny i przywróć go po załadowaniu aplikacji. W ten sposób możesz mieć pewność, że nadal masz ważny identyfikator weryfikacyjny, jeśli Twoja aplikacja zostanie zamknięta, zanim użytkownik ukończy proces logowania (na przykład podczas przełączania się do aplikacji SMS).
Możesz zachować identyfikator weryfikacyjny w dowolny sposób. Jeśli piszesz przy użyciu wieloplatformowej struktury C++, powinna ona zapewniać powiadomienia o zakończeniu i przywróceniu aplikacji. W przypadku tych zdarzeń można odpowiednio zapisać i przywrócić identyfikator weryfikacyjny.

Jeśli wywołanie VerifyPhoneNumber spowoduje wywołanie OnCodeSent w słuchaczu, możesz poprosić użytkownika o wpisanie kodu weryfikacyjnego, gdy otrzyma go w wiadomości SMS.

Z drugiej strony, jeśli wywołanie VerifyPhoneNumber spowoduje OnVerificationCompleted , oznacza to, że automatyczna weryfikacja zakończyła się pomyślnie i będziesz mieć PhoneAuthCredential , z którym możesz korzystać, jak opisano poniżej.

Gdy użytkownik dostarczy aplikacji kod weryfikacyjny z wiadomości SMS, zaloguj się, tworząc obiekt PhoneAuthCredential z kodu weryfikacyjnego i identyfikatora weryfikacyjnego i przekazując ten obiekt do Auth::SignInWithCredential .

Uzyskaj kod weryfikacyjny od użytkownika.

Utwórz obiekt Credential na podstawie kodu weryfikacyjnego i identyfikatora weryfikacyjnego.

PhoneAuthCredential credential = phone_auth_provider->GetCredential(
    verification_id_.c_str(), verification_code.c_str());

Zaloguj użytkownika za pomocą obiektu Credential :

Future<User> future = auth_->SignInWithCredential(credential);
future.OnCompletion(
    [](const Future<User*>& result, void*) {
      if (result.error() == kAuthErrorNone) {
        // Successful.
        // User is signed in.
        User user = *result.result();

        // This should display the phone number.
        printf("Phone number: %s", user.phone_number().c_str());

        // The phone number provider UID is the phone number itself.
        printf("Phone provider uid: %s", user.uid().c_str());

        // The phone number providerID is 'phone'
        printf("Phone provider ID: %s", user.provider_id().c_str());
      } else {
        // Error.
        printf("Sign in error: %s", result.error_message().c_str());
      }
    },
    nullptr);

Następne kroki

Gdy użytkownik zaloguje się po raz pierwszy, tworzone jest nowe konto użytkownika, które jest łączone z poświadczeniami — czyli nazwą użytkownika i hasłem, numerem telefonu lub informacjami o dostawcy uwierzytelniania — za pomocą których użytkownik się logował. To nowe konto jest przechowywane jako część Twojego projektu Firebase i może służyć do identyfikacji użytkownika w każdej aplikacji w Twoim projekcie, niezależnie od tego, jak użytkownik się loguje.

W swoich aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z firebase::auth::User object:

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 możesz uzyskać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i użyć go do kontrolowania, do jakich danych użytkownik ma dostęp.

Możesz zezwolić użytkownikom na logowanie się do Twojej aplikacji przy użyciu wielu dostawców uwierzytelniania, łącząc poświadczenia dostawcy uwierzytelniania z istniejącym kontem użytkownika.

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

auth->SignOut();