Google is committed to advancing racial equity for Black communities. See how.
Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

Uwierzytelnij się w Firebase, używając 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 SDK Firebase.

Zanim zaczniesz

  1. Dodaj Firebase do swojego projektu w C ++ .
  2. Jeśli nie połączyłeś jeszcze swojej aplikacji z projektem Firebase, zrób to z konsoli Firebase .

W systemie iOS pamiętaj, że logowanie za pomocą numeru telefonu wymaga fizycznego urządzenia i nie będzie działać na symulatorze.

Obawy dotyczące bezpieczeństwa

Uwierzytelnianie za pomocą 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 używaniem logowania za pomocą numeru telefonu.

Włącz logowanie przy użyciu numeru telefonu do projektu Firebase

Aby logować użytkowników za pomocą wiadomości SMS, musisz najpierw włączyć metodę logowania przy użyciu numeru telefonu w projekcie Firebase:

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

Limit żądań logowania na numer telefonu w 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 stronę z cenami .

Zacznij otrzymywać powiadomienia APN (iOS)

Aby korzystać z uwierzytelniania numeru telefonu w iOS, Twoja aplikacja musi mieć możliwość odbierania powiadomień APN z Firebase. Gdy po raz pierwszy logujesz się na urządzeniu za pomocą numeru telefonu użytkownika, Uwierzytelnianie Firebase wysyła ciche powiadomienie wypychane na urządzenie, aby sprawdzić, czy żądanie logowania na 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 APN do Firebase. Jeśli nie masz jeszcze certyfikatu APNs, zobacz Udostępnianie certyfikatów SSL APNs .

    1. W projekcie w konsoli Firebase wybierz ikonę koła zębatego, wybierz opcję Ustawienia projektu , a następnie wybierz kartę Komunikacja w chmurze .

    2. Wybierz przycisk Prześlij certyfikat dla swojego 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 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, który monituje o podanie numeru telefonu, a następnie zadzwoń do PhoneAuthProvider::VerifyPhoneNumber aby zażądać od PhoneAuthProvider::VerifyPhoneNumber wysłania kodu uwierzytelniającego na telefon użytkownika za pomocą wiadomości SMS:

  1. Uzyskaj numer telefonu użytkownika.

    Wymagania prawne są różne, ale zgodnie z najlepszą praktyką i aby określić oczekiwania użytkowników, należy ich poinformować, że jeśli korzystają z logowania telefonicznego, mogą otrzymać wiadomość SMS do weryfikacji i zastosować standardowe stawki.

  2. Zadzwoń do PhoneAuthProvider::VerifyPhoneNumber , przekazując mu 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 , PhoneAuthProvider::VerifyPhoneNumber ,
    • (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 zakończenia. Aby zalogować użytkownika, będziesz potrzebować zarówno kodu weryfikacyjnego, jak i identyfikatora weryfikacyjnego.
  3. Zapisz identyfikator weryfikacyjny i przywróć go po załadowaniu aplikacji. W ten sposób możesz upewnić się, że nadal masz ważny identyfikator weryfikacyjny, jeśli aplikacja zostanie zamknięta, zanim użytkownik zakoń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 za pomocą platformy C ++ dla wielu platform, powinna ona zawierać powiadomienia dotyczące zakończenia i przywrócenia aplikacji. W przypadku tych zdarzeń można odpowiednio zapisać i przywrócić identyfikator weryfikacyjny.

Jeśli wywołanie VerifyPhoneNumber powoduje wywołanie VerifyPhoneNumber w Twoim Listener, możesz OnCodeSent 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 zakończyła się sukcesem i będziesz mieć teraz Credential z którego możesz korzystać w sposób opisany poniżej.

Zaloguj użytkownika za pomocą kodu weryfikacyjnego

Gdy użytkownik przekaże aplikacji kod weryfikacyjny z wiadomości SMS, zaloguj się, tworząc obiekt Credential z kodu weryfikacyjnego i identyfikatora weryfikacyjnego i 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 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 loguje się po raz pierwszy, tworzone jest nowe konto użytkownika i jest ono łączone z poświadczeniami - to jest z nazwą użytkownika i hasłem, numerem telefonu lub informacjami dostawcy uwierzytelniania - zalogowanym użytkownikiem. To nowe konto jest przechowywane jako część projektu Firebase i może służyć do identyfikacji użytkownika we wszystkich aplikacjach w Twoim projekcie, niezależnie od tego, w jaki sposób się on zaloguje.

  • W swoich aplikacjach możesz uzyskać podstawowe informacje o profilu firebase::auth::User 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 Firebase Realtime Database i Cloud Storage Rules możesz uzyskać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i używać go do kontrolowania, do jakich danych użytkownik ma dostęp.

Możesz zezwolić użytkownikom na logowanie się do 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();