Check out what’s new from Firebase at Google I/O 2022. Learn more

Uwierzytelnij się w Firebase za pomocą numeru telefonu i C++

Za pomocą Uwierzytelniania Firebase możesz zalogować użytkownika, wysyłając wiadomość SMS na jego telefon. Użytkownik loguje się za pomocą kodu jednorazowego 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

  1. Dodaj Firebase do swojego projektu C++ .
  2. Jeśli aplikacja nie została jeszcze połączona z projektem Firebase, zrób to z konsoli Firebase .

Pamiętaj, że na platformach Apple logowanie za pomocą numeru telefonu wymaga urządzenia fizycznego i nie będzie działać na symulatorze.

Obawy dotyczące 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 na podstawie numeru telefonu w swojej aplikacji, powinieneś oferować je wraz z bezpieczniejszymi metodami logowania i informować użytkowników o kompromisach związanych z bezpieczeństwem korzystania z logowania za pomocą numeru telefonu.

Włącz logowanie za pomocą numeru telefonu w projekcie Firebase

Aby logować użytkowników przez SMS, musisz najpierw włączyć metodę logowania za pomocą numeru telefonu dla swojego projektu Firebase:

  1. W konsoli Firebase otwórz sekcję Uwierzytelnianie .
  2. Na stronie Metoda logowania włącz metodę logowania za pomocą numeru telefonu .

Limit żądań logowania za pomocą numeru telefonu Firebase jest na tyle wysoki, że nie ma 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 cennik .

Zacznij otrzymywać powiadomienia APNs (platformy Apple)

Aby korzystać z uwierzytelniania numeru telefonu na platformach Apple, Twoja aplikacja musi mieć możliwość odbierania powiadomień APNs z Firebase. Gdy logujesz użytkownika przy użyciu jego numeru telefonu po raz pierwszy na urządzeniu, Uwierzytelnianie Firebase wysyła na urządzenie ciche powiadomienie push, aby sprawdzić, czy żądanie logowania pod numer telefonu pochodzi z Twojej aplikacji. (Z tego powodu w symulatorze nie można używać logowania za pomocą numeru telefonu).

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

  1. W Xcode włącz powiadomienia push dla swojego projektu.
  2. 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ę Wiadomości w chmurze .

    2. Wybierz przycisk Prześlij certyfikat dla certyfikatu deweloperskiego, certyfikatu produkcyjnego lub obu. Wymagany jest co najmniej jeden.

    3. Dla każdego certyfikatu wybierz plik .p12 i podaj hasło, jeśli jest. 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, pokaż użytkownikowi interfejs, który prosi o podanie numeru telefonu, a następnie zadzwoń do PhoneAuthProvider::VerifyPhoneNumber , aby poprosić Firebase o wysłanie kodu uwierzytelniającego na telefon użytkownika SMS-em:

  1. Uzyskaj numer telefonu użytkownika.

    Wymagania prawne są różne, ale najlepszą praktyką i określeniem oczekiwań wobec użytkowników jest poinformowanie ich, że jeśli korzystają z logowania przez telefon, mogą otrzymać wiadomość SMS w celu weryfikacji i obowiązują standardowe stawki.

  2. Zadzwoń do PhoneAuthProvider::VerifyPhoneNumber , przekazując do niego numer telefonu użytkownika.
    class PhoneListener : public PhoneAuthProvider::Listener {
     public:
      ~PhoneListener() override {}
    
      void OnVerificationCompleted(Credential 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;
    PhoneAuthProvider& phone_provider = PhoneAuthProvider::GetInstance(auth);
    phone_provider->VerifyPhoneNumber(phone_number, kAutoVerifyTimeOut, null,
                                      &phone_listener);
    
    Gdy dzwonisz do 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 realizacji. Do zalogowania użytkownika będą potrzebne zarówno kod weryfikacyjny, jak i identyfikator weryfikacyjny.
  3. Zapisz identyfikator weryfikacyjny i przywróć go po załadowaniu aplikacji. W ten sposób możesz upewnić się, że nadal masz prawidłowy identyfikator weryfikacyjny, jeśli Twoja aplikacja zostanie zakończona, zanim użytkownik zakończy proces logowania (na przykład podczas przełączania do aplikacji SMS).

    Możesz zachować identyfikator weryfikacyjny w dowolny sposób. Jeśli piszesz z wieloplatformowym frameworkiem C++, powinien on udostępniać 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 na Twoim Listener, możesz poprosić użytkownika o wpisanie kodu weryfikacyjnego, gdy otrzyma go w wiadomości SMS.

Z drugiej strony, jeśli wywołanie VerifyPhoneNumber skutkuje OnVerificationCompleted , oznacza to, że automatyczna weryfikacja powiodła się i będziesz teraz mieć Credential , z którego możesz korzystać w sposób opisany poniżej.

Zaloguj się użytkownika za pomocą kodu weryfikacyjnego

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

  1. Uzyskaj kod weryfikacyjny od użytkownika.
  2. Utwórz obiekt Credential z kodu weryfikacyjnego i identyfikatora weryfikacyjnego.
    Credential credential = phone_auth_provider->GetCredential(
        verification_id_.c_str(), verification_code.c_str());
        
  3. Zaloguj się 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.
            const 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, zostanie utworzone nowe konto użytkownika i połą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ę zalogował. To nowe konto jest przechowywane jako część projektu Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w projekcie, niezależnie od tego, jak się on loguje.

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

    firebase::auth::User* user = auth->current_user();
    if (user != nullptr) {
      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 bazy danych czasu rzeczywistego i usługi Cloud Storage Firebase możesz uzyskać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i używać go do kontrolowania, do jakich danych użytkownik może uzyskać 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();