Uwierzytelnij się w Firebase na Androidzie, używając numeru telefonu

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.

Najłatwiejszym sposobem dodania logowania za pomocą numeru telefonu do aplikacji jest użycie FirebaseUI , który zawiera widżet logowania, który implementuje przepływy logowania na potrzeby logowania się za pomocą numeru telefonu, a także logowanie oparte na hasłach i federacyjne -W. W tym dokumencie opisano, jak zaimplementować proces logowania się za pomocą numeru telefonu przy użyciu pakietu SDK Firebase.

Zanim zaczniesz

  1. Jeśli jeszcze tego nie zrobiłeś, dodaj Firebase do swojego projektu na Androida .
  2. W pliku Gradle modułu (na poziomie aplikacji) (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle ) dodaj zależność dla uwierzytelniania Firebase biblioteka dla Androida. Zalecamy używanie Firebase Android BoM do kontrolowania wersji bibliotek.
    dependencies {
        // Import the BoM for the Firebase platform
        implementation(platform("com.google.firebase:firebase-bom:32.7.2"))
    
        // Add the dependency for the Firebase Authentication library
        // When using the BoM, you don't specify versions in Firebase library dependencies
        implementation("com.google.firebase:firebase-auth")
    }
    

    Korzystając z Firebase Android BoM , Twoja aplikacja będzie zawsze korzystać z kompatybilnych wersji bibliotek Firebase Android.

    (Alternatywa) Dodaj zależności biblioteki Firebase bez użycia BoM

    Jeśli zdecydujesz się nie używać BoM Firebase, musisz określić każdą wersję biblioteki Firebase w jej wierszu zależności.

    Pamiętaj, że jeśli używasz w swojej aplikacji wielu bibliotek Firebase, zdecydowanie zalecamy używanie BoM do zarządzania wersjami bibliotek, co gwarantuje, że wszystkie wersje będą kompatybilne.

    dependencies {
        // Add the dependency for the Firebase Authentication library
        // When NOT using the BoM, you must specify versions in Firebase library dependencies
        implementation("com.google.firebase:firebase-auth:22.3.1")
    }
    
    Szukasz modułu bibliotecznego specyficznego dla Kotlina? Począwszy od października 2023 r. (Firebase BoM 32.5.0) zarówno programiści Kotlin, jak i Java mogą polegać na głównym module biblioteki (więcej informacji można znaleźć w często zadawanych pytaniach dotyczących tej inicjatywy ).
  3. Jeśli jeszcze nie połączyłeś aplikacji z projektem Firebase, zrób to z konsoli Firebase .
  4. Jeśli nie ustawiłeś jeszcze skrótu SHA-1 swojej aplikacji w konsoli Firebase , zrób to. Aby uzyskać informacje na temat znajdowania skrótu SHA-1 aplikacji, zobacz Uwierzytelnianie klienta .

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ć pomiędzy użytkownikami. Ponadto na urządzeniach z wieloma profilami użytkowników każdy użytkownik mogący odbierać wiadomości SMS może zalogować się na konto przy użyciu numeru telefonu urządzenia.

Jeśli w swojej aplikacji używasz logowania przy użyciu numeru telefonu, powinieneś zaoferować tę opcję obok bezpieczniejszych metod logowania i poinformować użytkowników o kompromisach w zakresie bezpieczeństwa, jakie wiążą się z logowaniem się za pomocą numeru telefonu.

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

Aby logować użytkowników za pomocą wiadomości SMS, musisz najpierw włączyć metodę logowania za pomocą numeru telefonu w swoim projekcie 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 na numer telefonu w Firebase jest na tyle wysoki, że nie będzie to miało wpływu na większość aplikacji. Jeśli jednak chcesz zalogować bardzo dużą liczbę użytkowników przy użyciu uwierzytelniania telefonicznego, może być konieczne uaktualnienie planu cenowego. Zobacz stronę z cenami .

Włącz weryfikację aplikacji

Aby móc korzystać z uwierzytelniania za pomocą numeru telefonu, Firebase musi mieć możliwość sprawdzenia, czy prośby o zalogowanie się na numer telefonu pochodzą z Twojej aplikacji. Uwierzytelnianie Firebase realizuje to na trzy sposoby:

  • Play Integrity API : jeśli użytkownik ma urządzenie z zainstalowanymi usługami Google Play, a funkcja uwierzytelniania Firebase może zweryfikować, czy urządzenie jest legalne za pomocą interfejsu Play Integrity API , można kontynuować logowanie na numer telefonu. Interfejs Play Integrity API jest włączony w projekcie należącym do Google za pomocą uwierzytelniania Firebase, a nie w Twoim projekcie. Nie wpływa to na żadne limity interfejsu Play Integrity API w Twoim projekcie. Obsługa integralności Play jest dostępna w pakiecie Authentication SDK w wersji 21.2.0+ (Firebase BoM w wersji 31.4.0+).

    Aby skorzystać z Play Integrity, jeśli nie określiłeś jeszcze odcisku palca SHA-256 swojej aplikacji, zrób to w ustawieniach projektu w konsoli Firebase. Szczegółowe informacje na temat uzyskiwania odcisku palca SHA-256 aplikacji można znaleźć w artykule Uwierzytelnianie klienta .

  • Weryfikacja reCAPTCHA : w przypadku, gdy nie można użyć Play Integrity, na przykład gdy użytkownik ma urządzenie bez zainstalowanych usług Google Play, uwierzytelnianie Firebase wykorzystuje weryfikację reCAPTCHA w celu zakończenia procesu logowania przez telefon. Wyzwanie reCAPTCHA często można ukończyć bez konieczności rozwiązywania przez użytkownika czegokolwiek. Należy pamiętać, że ten przepływ wymaga skojarzenia algorytmu SHA-1 z aplikacją. Ten proces wymaga również, aby Twój klucz API był nieograniczony lub znajdował się na liście dozwolonych dla PROJECT_ID .firebaseapp.com .

    Niektóre scenariusze, w których uruchamiana jest funkcja reCAPTCHA:

    • Jeżeli na urządzeniu końcowym użytkownika nie są zainstalowane usługi Google Play.
    • Jeśli aplikacja nie jest dystrybuowana za pośrednictwem sklepu Google Play (w zestawie Authentication SDK v21.2.0+ ).
    • Jeśli uzyskany token SafetyNet był nieprawidłowy (w wersjach Authentication SDK < v21.2.0).

    Jeśli do weryfikacji aplikacji używana jest SafetyNet lub Play Integrity, pole %APP_NAME% w szablonie SMS jest wypełniane nazwą aplikacji ustaloną w sklepie Google Play. W scenariuszach, w których wyzwalana jest reCAPTCHA, %APP_NAME% jest wypełniany jako PROJECT_ID .firebaseapp.com .

Możesz wymusić przebieg weryfikacji reCAPTCHA za pomocą forceRecaptchaFlowForTesting Możesz wyłączyć weryfikację aplikacji (w przypadku korzystania z fikcyjnych numerów telefonów) za pomocą setAppVerificationDisabledForTesting .

Rozwiązywanie problemów

  • Błąd „Brak stanu początkowego” podczas używania reCAPTCHA do weryfikacji aplikacji

    Może się to zdarzyć, gdy przepływ reCAPTCHA zakończy się pomyślnie, ale nie przekieruje użytkownika z powrotem do aplikacji natywnej. Jeśli tak się stanie, użytkownik zostanie przekierowany na zastępczy adres URL PROJECT_ID .firebaseapp.com/__/auth/handler . W przeglądarkach Firefox otwieranie łączy do aplikacji natywnych jest domyślnie wyłączone. Jeśli widzisz powyższy błąd w przeglądarce Firefox, postępuj zgodnie z instrukcjami w Konfigurowanie przeglądarki Firefox dla Androida tak, aby otwierał łącza w aplikacjach natywnych, aby umożliwić otwieranie łączy do aplikacji.

Wyślij kod weryfikacyjny na telefon użytkownika

Aby zainicjować logowanie za pomocą numeru telefonu, wyświetl użytkownikowi interfejs, który poprosi go o wpisanie numeru telefonu. Wymagania prawne są różne, ale w ramach najlepszej praktyki i w celu ustalenia oczekiwań użytkowników należy poinformować ich, że w przypadku korzystania z logowania przez telefon mogą otrzymać wiadomość SMS w celu weryfikacji i obowiązywać będą standardowe stawki.

Następnie przekaż jego numer telefonu do metody PhoneAuthProvider.verifyPhoneNumber , aby zażądać, aby Firebase zweryfikował numer telefonu użytkownika. Na przykład:

Kotlin+KTX

val options = PhoneAuthOptions.newBuilder(auth)
    .setPhoneNumber(phoneNumber) // Phone number to verify
    .setTimeout(60L, TimeUnit.SECONDS) // Timeout and unit
    .setActivity(this) // Activity (for callback binding)
    .setCallbacks(callbacks) // OnVerificationStateChangedCallbacks
    .build()
PhoneAuthProvider.verifyPhoneNumber(options)

Java

PhoneAuthOptions options = 
  PhoneAuthOptions.newBuilder(mAuth) 
      .setPhoneNumber(phoneNumber)       // Phone number to verify
      .setTimeout(60L, TimeUnit.SECONDS) // Timeout and unit
      .setActivity(this)                 // (optional) Activity for callback binding
      // If no activity is passed, reCAPTCHA verification can not be used.
      .setCallbacks(mCallbacks)          // OnVerificationStateChangedCallbacks
      .build();
  PhoneAuthProvider.verifyPhoneNumber(options);     

Metoda verifyPhoneNumber jest metodą współbieżną: jeśli wywołasz ją wiele razy, na przykład w metodzie onStart działania, metoda verifyPhoneNumber nie wyśle ​​drugiej wiadomości SMS, chyba że upłynął limit czasu pierwotnego żądania.

Możesz użyć tego zachowania, aby wznowić proces logowania za pomocą numeru telefonu, jeśli aplikacja zostanie zamknięta, zanim użytkownik będzie mógł się zalogować (na przykład, gdy użytkownik korzysta z aplikacji do obsługi SMS-ów). Po wywołaniu verifyPhoneNumber ustaw flagę wskazującą, że weryfikacja jest w toku. Następnie zapisz flagę w metodzie onSaveInstanceState działania i przywróć flagę w onRestoreInstanceState . Na koniec w metodzie onStart działania sprawdź, czy weryfikacja już trwa, a jeśli tak, ponownie wywołaj funkcję verifyPhoneNumber . Pamiętaj, aby wyczyścić flagę, gdy weryfikacja zakończy się lub zakończy niepowodzeniem (patrz Wywołania zwrotne weryfikacji ).

Aby łatwo obsłużyć rotację ekranu i inne przypadki ponownego uruchomienia działania, przekaż aktywność do metody verifyPhoneNumber . Wywołania zwrotne zostaną automatycznie odłączone po zatrzymaniu działania, więc możesz swobodnie pisać kod przejścia interfejsu użytkownika w metodach wywołania zwrotnego.

Wiadomość SMS wysłaną przez Firebase można również zlokalizować, określając język uwierzytelniania za pomocą metody setLanguageCode w instancji Auth.

Kotlin+KTX

auth.setLanguageCode("fr")
// To apply the default app language instead of explicitly setting it.
// auth.useAppLanguage()

Java

auth.setLanguageCode("fr");
// To apply the default app language instead of explicitly setting it.
// auth.useAppLanguage();

Kiedy wywołujesz PhoneAuthProvider.verifyPhoneNumber , musisz także podać instancję OnVerificationStateChangedCallbacks , która zawiera implementacje funkcji wywołania zwrotnego, które obsługują wyniki żądania. Na przykład:

Kotlin+KTX

callbacks = object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

    override fun onVerificationCompleted(credential: PhoneAuthCredential) {
        // This callback will be invoked in two situations:
        // 1 - Instant verification. In some cases the phone number can be instantly
        //     verified without needing to send or enter a verification code.
        // 2 - Auto-retrieval. On some devices Google Play services can automatically
        //     detect the incoming verification SMS and perform verification without
        //     user action.
        Log.d(TAG, "onVerificationCompleted:$credential")
        signInWithPhoneAuthCredential(credential)
    }

    override fun onVerificationFailed(e: FirebaseException) {
        // This callback is invoked in an invalid request for verification is made,
        // for instance if the the phone number format is not valid.
        Log.w(TAG, "onVerificationFailed", e)

        if (e is FirebaseAuthInvalidCredentialsException) {
            // Invalid request
        } else if (e is FirebaseTooManyRequestsException) {
            // The SMS quota for the project has been exceeded
        } else if (e is FirebaseAuthMissingActivityForRecaptchaException) {
            // reCAPTCHA verification attempted with null Activity
        }

        // Show a message and update the UI
    }

    override fun onCodeSent(
        verificationId: String,
        token: PhoneAuthProvider.ForceResendingToken,
    ) {
        // The SMS verification code has been sent to the provided phone number, we
        // now need to ask the user to enter the code and then construct a credential
        // by combining the code with a verification ID.
        Log.d(TAG, "onCodeSent:$verificationId")

        // Save verification ID and resending token so we can use them later
        storedVerificationId = verificationId
        resendToken = token
    }
}

Java

mCallbacks = new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

    @Override
    public void onVerificationCompleted(@NonNull PhoneAuthCredential credential) {
        // This callback will be invoked in two situations:
        // 1 - Instant verification. In some cases the phone number can be instantly
        //     verified without needing to send or enter a verification code.
        // 2 - Auto-retrieval. On some devices Google Play services can automatically
        //     detect the incoming verification SMS and perform verification without
        //     user action.
        Log.d(TAG, "onVerificationCompleted:" + credential);

        signInWithPhoneAuthCredential(credential);
    }

    @Override
    public void onVerificationFailed(@NonNull FirebaseException e) {
        // This callback is invoked in an invalid request for verification is made,
        // for instance if the the phone number format is not valid.
        Log.w(TAG, "onVerificationFailed", e);

        if (e instanceof FirebaseAuthInvalidCredentialsException) {
            // Invalid request
        } else if (e instanceof FirebaseTooManyRequestsException) {
            // The SMS quota for the project has been exceeded
        } else if (e instanceof FirebaseAuthMissingActivityForRecaptchaException) {
            // reCAPTCHA verification attempted with null Activity
        }

        // Show a message and update the UI
    }

    @Override
    public void onCodeSent(@NonNull String verificationId,
                           @NonNull PhoneAuthProvider.ForceResendingToken token) {
        // The SMS verification code has been sent to the provided phone number, we
        // now need to ask the user to enter the code and then construct a credential
        // by combining the code with a verification ID.
        Log.d(TAG, "onCodeSent:" + verificationId);

        // Save verification ID and resending token so we can use them later
        mVerificationId = verificationId;
        mResendToken = token;
    }
};

Weryfikacyjne wywołania zwrotne

W większości aplikacji implementujesz wywołania zwrotne onVerificationCompleted , onVerificationFailed i onCodeSent . Możesz także zaimplementować onCodeAutoRetrievalTimeOut , w zależności od wymagań aplikacji.

onVerificationCompleted(PhoneAuthCredential)

Metodę tę wywołuje się w dwóch sytuacjach:

  • Natychmiastowa weryfikacja: w niektórych przypadkach numer telefonu można natychmiast zweryfikować, bez konieczności wysyłania lub wprowadzania kodu weryfikacyjnego.
  • Automatyczne pobieranie: na niektórych urządzeniach Usługi Google Play mogą automatycznie wykryć przychodzące SMS-y weryfikacyjne i przeprowadzić weryfikację bez podejmowania działań przez użytkownika. (Ta funkcja może być niedostępna w przypadku niektórych operatorów). Wykorzystuje interfejs API SMS Retriever , który na końcu wiadomości SMS zawiera 11-znakowy skrót.
W obu przypadkach numer telefonu użytkownika został pomyślnie zweryfikowany i możesz użyć obiektu PhoneAuthCredential przekazanego do wywołania zwrotnego, aby zalogować użytkownika .

onVerificationFailed (wyjątek Firebase)

Ta metoda jest wywoływana w odpowiedzi na nieprawidłowe żądanie weryfikacji, takie jak żądanie określające nieprawidłowy numer telefonu lub kod weryfikacyjny.

onCodeSent(Identyfikator weryfikacji ciągu, PhoneAuthProvider.ForceResendingToken)

Opcjonalny. Metoda ta wywoływana jest po wysłaniu kodu weryfikacyjnego SMS-em na podany numer telefonu.

Po wywołaniu tej metody większość aplikacji wyświetla interfejs użytkownika, który monituje użytkownika o wpisanie kodu weryfikacyjnego z wiadomości SMS. (Jednocześnie w tle może przebiegać automatyczna weryfikacja.) Następnie po wpisaniu przez użytkownika kodu weryfikacyjnego można wykorzystać kod weryfikacyjny i identyfikator weryfikacyjny przekazany do metody w celu utworzenia obiektu PhoneAuthCredential , który możesz z kolei użyć do zalogowania użytkownika. Jednak niektóre aplikacje mogą poczekać do wywołania funkcji onCodeAutoRetrievalTimeOut przed wyświetleniem interfejsu użytkownika z kodem weryfikacyjnym (niezalecane).

onCodeAutoRetrievalTimeOut (identyfikator weryfikacji ciągu)

Opcjonalny. Ta metoda jest wywoływana po upływie limitu czasu określonego dla verifyPhoneNumber bez uprzedniego wyzwolenia onVerificationCompleted . Na urządzeniach bez karty SIM ta metoda jest wywoływana natychmiast, ponieważ automatyczne pobieranie SMS-ów nie jest możliwe.

Niektóre aplikacje blokują wprowadzanie danych przez użytkownika do momentu upłynięcia okresu automatycznej weryfikacji i dopiero wtedy wyświetlają interfejs użytkownika, który prosi użytkownika o wpisanie kodu weryfikacyjnego z wiadomości SMS (niezalecane).

Utwórz obiekt PhoneAuthCredential

Gdy użytkownik wprowadzi kod weryfikacyjny wysłany przez Firebase na jego telefon, utwórz obiekt PhoneAuthCredential , korzystając z kodu weryfikacyjnego i identyfikatora weryfikacyjnego przesłanego do wywołania zwrotnego onCodeSent lub onCodeAutoRetrievalTimeOut . (Po wywołaniu onVerificationCompleted bezpośrednio otrzymasz obiekt PhoneAuthCredential , więc możesz pominąć ten krok).

Aby utworzyć obiekt PhoneAuthCredential , wywołaj PhoneAuthProvider.getCredential :

Kotlin+KTX

val credential = PhoneAuthProvider.getCredential(verificationId!!, code)

Java

PhoneAuthCredential credential = PhoneAuthProvider.getCredential(verificationId, code);

Zaloguj się

Po otrzymaniu obiektu PhoneAuthCredential w wywołaniu zwrotnym onVerificationCompleted lub wywołując PhoneAuthProvider.getCredential , zakończ proces logowania, przekazując obiekt PhoneAuthCredential do FirebaseAuth.signInWithCredential :

Kotlin+KTX

private fun signInWithPhoneAuthCredential(credential: PhoneAuthCredential) {
    auth.signInWithCredential(credential)
        .addOnCompleteListener(this) { task ->
            if (task.isSuccessful) {
                // Sign in success, update UI with the signed-in user's information
                Log.d(TAG, "signInWithCredential:success")

                val user = task.result?.user
            } else {
                // Sign in failed, display a message and update the UI
                Log.w(TAG, "signInWithCredential:failure", task.exception)
                if (task.exception is FirebaseAuthInvalidCredentialsException) {
                    // The verification code entered was invalid
                }
                // Update UI
            }
        }
}

Java

private void signInWithPhoneAuthCredential(PhoneAuthCredential credential) {
    mAuth.signInWithCredential(credential)
            .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                @Override
                public void onComplete(@NonNull Task<AuthResult> task) {
                    if (task.isSuccessful()) {
                        // Sign in success, update UI with the signed-in user's information
                        Log.d(TAG, "signInWithCredential:success");

                        FirebaseUser user = task.getResult().getUser();
                        // Update UI
                    } else {
                        // Sign in failed, display a message and update the UI
                        Log.w(TAG, "signInWithCredential:failure", task.getException());
                        if (task.getException() instanceof FirebaseAuthInvalidCredentialsException) {
                            // The verification code entered was invalid
                        }
                    }
                }
            });
}

Przetestuj z fikcyjnymi numerami telefonów

Możesz skonfigurować fikcyjne numery telefonów do programowania za pomocą konsoli Firebase. Testowanie z fikcyjnymi numerami telefonów zapewnia następujące korzyści:

  • Przetestuj uwierzytelnianie numeru telefonu bez zużywania limitu wykorzystania.
  • Przetestuj uwierzytelnianie numeru telefonu bez wysyłania wiadomości SMS.
  • Przeprowadzaj kolejne testy z tym samym numerem telefonu, nie ulegając ograniczeniom. Minimalizuje to ryzyko odrzucenia podczas procesu recenzji w App Store, jeśli recenzent użyje tego samego numeru telefonu do testów.
  • Możliwość łatwego testowania w środowiskach programistycznych bez dodatkowego wysiłku, takiego jak możliwość programowania w symulatorze iOS lub emulatorze Androida bez Usług Google Play.
  • Pisz testy integracyjne bez blokowania przez kontrole bezpieczeństwa zwykle stosowane w przypadku rzeczywistych numerów telefonów w środowisku produkcyjnym.

Fikcyjne numery telefonów muszą spełniać te wymagania:

  1. Upewnij się, że używasz numerów telefonów, które rzeczywiście są fikcyjne i jeszcze nie istnieją. Uwierzytelnianie Firebase nie pozwala na ustawienie istniejących numerów telefonów używanych przez prawdziwych użytkowników jako numerów testowych. Jedną z opcji jest użycie numerów 555 z prefiksem jako testowych numerów telefonów w USA, na przykład: +1 650-555-3434
  2. Numery telefonów muszą być poprawnie sformatowane pod kątem długości i innych ograniczeń. Nadal będą przechodzić tę samą weryfikację, co numer telefonu prawdziwego użytkownika.
  3. Możesz dodać do 10 numerów telefonów do celów rozwoju.
  4. Używaj testowych numerów telefonów/kodów, które są trudne do odgadnięcia i często je zmieniaj.

Twórz fikcyjne numery telefonów i kody weryfikacyjne

  1. W konsoli Firebase otwórz sekcję Uwierzytelnianie .
  2. Na karcie Metoda logowania włącz opcję Dostawca telefonu, jeśli jeszcze tego nie zrobiłeś.
  3. Otwórz menu Numery telefonów do testowania akordeonu.
  4. Podaj numer telefonu, który chcesz przetestować, na przykład: +1 650-555-3434 .
  5. Podaj 6-cyfrowy kod weryfikacyjny dla tego konkretnego numeru, na przykład: 654321 .
  6. Dodaj numer. Jeśli zajdzie taka potrzeba, możesz usunąć numer telefonu i jego kod, najeżdżając kursorem na odpowiedni wiersz i klikając ikonę kosza.

Testowanie ręczne

Możesz od razu zacząć używać fikcyjnego numeru telefonu w swojej aplikacji. Umożliwia to przeprowadzanie testów ręcznych na etapach programowania bez problemów z przydziałami i ograniczaniem przepustowości. Możesz także testować bezpośrednio z symulatora iOS lub emulatora Androida bez zainstalowanych Usług Google Play.

Gdy podasz fikcyjny numer telefonu i wyślesz kod weryfikacyjny, żadna wiadomość SMS nie zostanie wysłana. Zamiast tego musisz podać wcześniej skonfigurowany kod weryfikacyjny, aby dokończyć logowanie.

Po zakończeniu logowania tworzony jest użytkownik Firebase z tym numerem telefonu. Użytkownik ma takie same właściwości i zachowanie jak użytkownik prawdziwego numeru telefonu i może uzyskać dostęp do bazy danych Realtime/Cloud Firestore i innych usług w ten sam sposób. Token identyfikacyjny wybity podczas tego procesu ma taki sam podpis, jak użytkownik prawdziwego numeru telefonu.

Inną opcją jest ustawienie roli testowej za pomocą niestandardowych oświadczeń dla tych użytkowników, aby odróżnić ich od fałszywych użytkowników, jeśli chcesz jeszcze bardziej ograniczyć dostęp.

Aby ręcznie uruchomić przepływ reCAPTCHA do testów, użyj metody forceRecaptchaFlowForTesting() .

// Force reCAPTCHA flow
FirebaseAuth.getInstance().getFirebaseAuthSettings().forceRecaptchaFlowForTesting();

Testy integracyjne

Oprócz testów ręcznych, uwierzytelnianie Firebase udostępnia interfejsy API, które pomagają pisać testy integracyjne na potrzeby testowania uwierzytelniania telefonicznego. Te interfejsy API wyłączają weryfikację aplikacji, wyłączając wymaganie reCAPTCHA w powiadomieniach internetowych i cichych powiadomieniach push w systemie iOS. Dzięki temu możliwe jest testowanie automatyczne w tych przepływach i łatwiejsze do wdrożenia. Ponadto pomagają zapewnić możliwość testowania natychmiastowych procesów weryfikacji na Androidzie.

W systemie Android wywołaj setAppVerificationDisabledForTesting() przed wywołaniem signInWithPhoneNumber . Spowoduje to automatyczne wyłączenie weryfikacji aplikacji, umożliwiając przekazanie numeru telefonu bez konieczności ręcznego jego rozwiązywania. Mimo że funkcje Play Integrity i reCAPTCHA są wyłączone, użycie prawdziwego numeru telefonu nadal nie umożliwi dokończenia logowania. W tym interfejsie API można używać wyłącznie fikcyjnych numerów telefonów.

// Turn off phone auth app verification.
FirebaseAuth.getInstance().getFirebaseAuthSettings()
   .setAppVerificationDisabledForTesting();

Wywołanie funkcji verifyPhoneNumber z fikcyjnym numerem uruchamia wywołanie zwrotne onCodeSent , w którym należy podać odpowiedni kod weryfikacyjny. Umożliwia to testowanie w emulatorach Androida.

Java

String phoneNum = "+16505554567";
String testVerificationCode = "123456";

// Whenever verification is triggered with the whitelisted number,
// provided it is not set for auto-retrieval, onCodeSent will be triggered.
FirebaseAuth auth = FirebaseAuth.getInstance();
PhoneAuthOptions options = PhoneAuthOptions.newBuilder(auth)
        .setPhoneNumber(phoneNum)
        .setTimeout(60L, TimeUnit.SECONDS)
        .setActivity(this)
        .setCallbacks(new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
            @Override
            public void onCodeSent(@NonNull String verificationId,
                                   @NonNull PhoneAuthProvider.ForceResendingToken forceResendingToken) {
                // Save the verification id somewhere
                // ...

                // The corresponding whitelisted code above should be used to complete sign-in.
                MainActivity.this.enableUserManuallyInputCode();
            }

            @Override
            public void onVerificationCompleted(@NonNull PhoneAuthCredential phoneAuthCredential) {
                // Sign in with the credential
                // ...
            }

            @Override
            public void onVerificationFailed(@NonNull FirebaseException e) {
                // ...
            }
        })
        .build();
PhoneAuthProvider.verifyPhoneNumber(options);

Kotlin+KTX

val phoneNum = "+16505554567"
val testVerificationCode = "123456"

// Whenever verification is triggered with the whitelisted number,
// provided it is not set for auto-retrieval, onCodeSent will be triggered.
val options = PhoneAuthOptions.newBuilder(Firebase.auth)
    .setPhoneNumber(phoneNum)
    .setTimeout(30L, TimeUnit.SECONDS)
    .setActivity(this)
    .setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

        override fun onCodeSent(
            verificationId: String,
            forceResendingToken: PhoneAuthProvider.ForceResendingToken,
        ) {
            // Save the verification id somewhere
            // ...

            // The corresponding whitelisted code above should be used to complete sign-in.
            this@MainActivity.enableUserManuallyInputCode()
        }

        override fun onVerificationCompleted(phoneAuthCredential: PhoneAuthCredential) {
            // Sign in with the credential
            // ...
        }

        override fun onVerificationFailed(e: FirebaseException) {
            // ...
        }
    })
    .build()
PhoneAuthProvider.verifyPhoneNumber(options)

Ponadto możesz przetestować przepływy automatycznego pobierania w systemie Android, ustawiając fikcyjny numer i odpowiadający mu kod weryfikacyjny na potrzeby automatycznego pobierania, wywołując metodę setAutoRetrievedSmsCodeForPhoneNumber .

Wywołanie funkcji verifyPhoneNumber powoduje wywołanie onVerificationCompleted bezpośrednio z PhoneAuthCredential . Działa to tylko w przypadku fikcyjnych numerów telefonów.

Podczas publikowania aplikacji w sklepie Google Play upewnij się, że jest ona wyłączona i że w aplikacji nie są zakodowane na stałe żadne fikcyjne numery telefonów.

Java

// The test phone number and code should be whitelisted in the console.
String phoneNumber = "+16505554567";
String smsCode = "123456";

FirebaseAuth firebaseAuth = FirebaseAuth.getInstance();
FirebaseAuthSettings firebaseAuthSettings = firebaseAuth.getFirebaseAuthSettings();

// Configure faking the auto-retrieval with the whitelisted numbers.
firebaseAuthSettings.setAutoRetrievedSmsCodeForPhoneNumber(phoneNumber, smsCode);

PhoneAuthOptions options = PhoneAuthOptions.newBuilder(firebaseAuth)
        .setPhoneNumber(phoneNumber)
        .setTimeout(60L, TimeUnit.SECONDS)
        .setActivity(this)
        .setCallbacks(new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
            @Override
            public void onVerificationCompleted(@NonNull PhoneAuthCredential credential) {
                // Instant verification is applied and a credential is directly returned.
                // ...
            }

            // ...
        })
        .build();
PhoneAuthProvider.verifyPhoneNumber(options);

Kotlin+KTX

// The test phone number and code should be whitelisted in the console.
val phoneNumber = "+16505554567"
val smsCode = "123456"

val firebaseAuth = Firebase.auth
val firebaseAuthSettings = firebaseAuth.firebaseAuthSettings

// Configure faking the auto-retrieval with the whitelisted numbers.
firebaseAuthSettings.setAutoRetrievedSmsCodeForPhoneNumber(phoneNumber, smsCode)

val options = PhoneAuthOptions.newBuilder(firebaseAuth)
    .setPhoneNumber(phoneNumber)
    .setTimeout(60L, TimeUnit.SECONDS)
    .setActivity(this)
    .setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
        override fun onVerificationCompleted(credential: PhoneAuthCredential) {
            // Instant verification is applied and a credential is directly returned.
            // ...
        }

        // ...
    })
    .build()
PhoneAuthProvider.verifyPhoneNumber(options)

Następne kroki

Gdy użytkownik zaloguje się po raz pierwszy, zostanie utworzone nowe konto użytkownika i powiązane 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ęść Twojego projektu Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w Twoim projekcie, niezależnie od tego, w jaki sposób użytkownik się loguje.

  • W Twoich aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z obiektu FirebaseUser . Zobacz Zarządzanie użytkownikami .

  • W regułach bezpieczeństwa bazy danych Firebase Realtime 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 może uzyskać 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 funkcję signOut :

Kotlin+KTX

Firebase.auth.signOut()

Java

FirebaseAuth.getInstance().signOut();