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

Za pomocą Uwierzytelniania Firebase możesz zalogować się 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 projektu C ++ .
  2. Jeśli nie zostały jeszcze podłączone swoją aplikację do projektu Firebase, zrobić 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ć go 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ę uwierzytelniania.
  2. Na stronie logowania w metodzie, należy włączyć logowania metodą numer 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 cenową stronę.

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 za pomocą numeru 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łączyć powiadomienia push dla swojego projektu.
  2. Prześlij swój certyfikat APNs do Firebase. Jeżeli nie masz jeszcze certyfikatu APN upewnij się, aby utworzyć w Państwa firmy Apple Developer Center .

    1. Wewnątrz projektu w konsoli Firebase, wybierz ikonę koła zębatego, wybierz Ustawienia projektu, a następnie wybrać zakładkę Cloud Messaging.

    2. Wybierz przycisk Prześlij certyfikatów dla certyfikatu rozwoju, produkcji, certyfikatu lub oba. 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ć numer telefonu logowania, przedstawić użytkownikowi interfejs, który wyświetli monit o podanie swojego numeru telefonu, a następnie zadzwonić PhoneAuthProvider::VerifyPhoneNumber do wniosku, że Firebase wysłać kod uwierzytelniania użytkownika telefonu przez SMS:

  1. Uzyskaj numer telefonu użytkownika.

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

  2. Zadzwoń PhoneAuthProvider::VerifyPhoneNumber , przechodzą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);
    
    Po wywołaniu 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 zamknięta przed ukończeniem przez użytkownika procesu 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 wyników w OnCodeSent miano na słuchacza, można poprosi użytkownika o wpisanie kodu weryfikacyjnego, gdy otrzymują go w wiadomości SMS.

Z drugiej strony, jeżeli wezwanie do VerifyPhoneNumber skutkuje OnVerificationCompleted , następnie automatyczna weryfikacja udało i teraz masz Credential z których można korzystać w sposób opisany poniżej.

Zaloguj się użytkownika za pomocą kodu weryfikacyjnego

Gdy użytkownik udostępnia swoją aplikację z kodem weryfikacyjnym z wiadomości SMS, zaloguj użytkownika w poprzez tworzenie Credential obiekt z kodem weryfikacyjnym i ID weryfikacji i przejściu tego obiektu do Auth::SignInWithCredential .

  1. Uzyskaj kod weryfikacyjny od użytkownika.
  2. Tworzenie Credential obiekt z kodem weryfikacyjnym i ID weryfikacji.
    Credential credential = phone_auth_provider->GetCredential(
        verification_id_.c_str(), verification_code.c_str());
        
  3. Zaloguj się użytkownika z Credential obiektu:
    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 — przy użyciu 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 aplikacjach, można uzyskać podstawowe informacje o profilu użytkownika z firebase::auth::User obiektu:

    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 bazie danych Firebase Realtime i Cloud Storage zasad bezpieczeństwa , można uzyskać podpisanego w unikalnym identyfikatorem użytkownika użytkownika z auth zmiennej i użyć go do kontroli, jakie dane dostępu może użytkownik.

Można zezwolić użytkownikom na logowanie się do aplikacji przy użyciu wielu dostawców uwierzytelniania przez łączenie auth poświadczenia dostawcy do istniejącego konta użytkownika.

Aby wylogować użytkownika, zadzwoń SignOut() :

auth->SignOut();