Uwierzytelnij się w Firebase na Androidzie za pomocą 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 interfejsu FirebaseUI , który zawiera widżet logowania, który implementuje przepływy logowania na potrzeby logowania za pomocą numeru telefonu, a także podpis oparty na haśle i federacyjny -W. W tym dokumencie opisano, jak zaimplementować proces logowania za pomocą numeru telefonu przy użyciu pakietu Firebase SDK.

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 Androida. Zalecamy używanie Firebase Android BoM do kontrolowania wersji bibliotek.

    Kotlin+KTX

    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:32.3.1"))

    // 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-ktx")
}

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

    (Alternatywnie) Dodaj zależności biblioteki Firebase bez korzystania z 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 korzystanie z BoM do zarządzania wersjami bibliotek, co zapewnia zgodność wszystkich wersji.

    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-ktx:22.1.2")
}

    Java

    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:32.3.1"))

    // 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ć ze zgodnych wersji bibliotek Firebase Android.

    (Alternatywnie) Dodaj zależności biblioteki Firebase bez korzystania z 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 korzystanie z BoM do zarządzania wersjami bibliotek, co zapewnia zgodność wszystkich wersji.

    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.1.2")
}
  3. Jeśli nie połączyłeś jeszcze swojej aplikacji z projektem Firebase, zrób to z poziomu konsoli Firebase .
  4. Jeśli jeszcze nie ustawiłeś skrótu SHA-1 swojej aplikacji w konsoli Firebase , zrób to. Zobacz Uwierzytelnianie klienta , aby uzyskać informacje o znajdowaniu skrótu SHA-1 aplikacji.

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.

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

Aby logować użytkowników za pomocą SMS-ów, 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 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 .

Włącz weryfikację aplikacji

Aby korzystać z uwierzytelniania za pomocą numeru telefonu, Firebase musi być w stanie zweryfikować, czy żądania logowania za pomocą numeru telefonu pochodzą z Twojej aplikacji. Uwierzytelnianie Firebase umożliwia to na trzy sposoby:

  • Interfejs Play Integrity API : jeśli użytkownik ma urządzenie z zainstalowanymi usługami Google Play, a uwierzytelnianie Firebase może zweryfikować zgodność urządzenia z interfejsem Play Integrity API , logowanie za pomocą numeru telefonu może być kontynuowane. Interfejs Play Integrity API jest włączony w projekcie należącym do Google przez uwierzytelnianie Firebase, a nie w Twoim projekcie. Nie wpływa to na żadne limity Play Integrity API w Twoim projekcie. Obsługa integralności Play jest dostępna w pakiecie SDK uwierzytelniania w wersji 21.2.0+ (Firebase BoM v31.4.0+).

    Aby korzystać 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. Zapoznaj się z artykułem Uwierzytelnianie klienta , aby uzyskać szczegółowe informacje na temat uzyskiwania odcisku palca SHA-256 aplikacji.

  • Weryfikacja reCAPTCHA : w przypadku, gdy nie można użyć integralności Play, na przykład gdy użytkownik ma urządzenie bez zainstalowanych usług Google Play, uwierzytelnianie Firebase korzysta z weryfikacji reCAPTCHA, aby dokończyć proces logowania przez telefon. Wyzwanie reCAPTCHA często można ukończyć bez konieczności rozwiązywania czegokolwiek przez użytkownika. Należy pamiętać, że ten przepływ wymaga skojarzenia SHA-1 z aplikacją. Ten przepływ 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 pakiecie SDK uwierzytelniania w wersji 21.2.0+ ).
    • Jeśli uzyskany token SafetyNet był nieprawidłowy (w wersjach SDK uwierzytelniania < v21.2.0).

    Gdy SafetyNet lub Play Integrity jest używany do weryfikacji aplikacji, pole %APP_NAME% w szablonie SMS jest wypełniane nazwą aplikacji określoną w sklepie Google Play. W scenariuszach, w których uruchamiana jest reCAPTCHA, %APP_NAME% jest wypełniane jako PROJECT_ID .firebaseapp.com .

Możesz wymusić przepływ weryfikacji reCAPTCHA za pomocą forceRecaptchaFlowForTesting Możesz wyłączyć weryfikację aplikacji (podczas 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. W takim przypadku użytkownik jest przekierowywany do zastępczego adresu URL PROJECT_ID .firebaseapp.com/__/auth/handler . W przeglądarkach Firefox otwieranie linków aplikacji natywnych jest domyślnie wyłączone. Jeśli widzisz powyższy błąd w Firefoksie, postępuj zgodnie z instrukcjami w Ustaw Firefox dla Androida, aby otwierał linki w aplikacjach natywnych, aby umożliwić otwieranie linków do aplikacji.

Wyślij kod weryfikacyjny na telefon użytkownika

Aby zainicjować logowanie za pomocą numeru telefonu, przedstaw użytkownikowi interfejs z monitem o wpisanie numeru telefonu. 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 opłaty.

Następnie przekaż ich numer telefonu do metody PhoneAuthProvider.verifyPhoneNumber , aby poprosić Firebase o zweryfikowanie numeru 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)
PhoneAuthActivity.kt

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);     
PhoneAuthActivity.java

Metoda verifyPhoneNumber jest wielokrotna: jeśli wywołasz ją wiele razy, na przykład w metodzie onStart działania, metoda verifyPhoneNumber nie wyśle ​​drugiego SMS-a, chyba że upłynął limit czasu pierwotnego żądania.

Możesz użyć tego zachowania, aby wznowić proces logowania numeru telefonu, jeśli Twoja aplikacja zostanie zamknięta, zanim użytkownik będzie mógł się zalogować (na przykład, gdy użytkownik korzysta z aplikacji SMS). 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 jest już w toku, a jeśli tak, ponownie wywołaj verifyPhoneNumber . Pamiętaj, aby wyczyścić flagę, gdy weryfikacja zakończy się lub zakończy się niepowodzeniem (zobacz Wywołania zwrotne weryfikacyjne ).

Aby łatwo obsłużyć obracanie ekranu i inne przypadki ponownego uruchamiania działania, przekaż swoje działanie 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 autoryzacji 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()
MainActivity.kt

Java

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

Gdy wywołujesz PhoneAuthProvider.verifyPhoneNumber , musisz również 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
    }
}
PhoneAuthActivity.kt

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;
    }
};
PhoneAuthActivity.java

Wezwania zwrotne weryfikacyjne

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ń Twojej aplikacji.

onVerificationCompleted(PhoneAuthCredential)

Ta metoda jest wywoływana 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 wykrywać przychodzącą weryfikacyjną wiadomość SMS i przeprowadzać weryfikację bez działania użytkownika. (Ta funkcja może być niedostępna u niektórych operatorów.) Korzysta z interfejsu SMS Retriever API , który zawiera 11-znakowy skrót na końcu wiadomości SMS.
W obu przypadkach numer telefonu użytkownika został pomyślnie zweryfikowany i można użyć obiektu PhoneAuthCredential przekazanego do wywołania zwrotnego, aby zalogować użytkownika .

onVerificationFailed(FirebaseException)

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(ciąg identyfikator weryfikacji, PhoneAuthProvider.ForceResendingToken)

Opcjonalny. Ta metoda jest wywoływana 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 działać automatyczna weryfikacja). Następnie, po wpisaniu przez użytkownika kodu weryfikacyjnego, można użyć kodu weryfikacyjnego i identyfikatora weryfikacyjnego przekazanego metodzie w celu utworzenia obiektu PhoneAuthCredential , który możesz z kolei użyć do zalogowania użytkownika. Jednak niektóre aplikacje mogą czekać na wywołanie onCodeAutoRetrievalTimeOut przed wyświetleniem interfejsu użytkownika kodu weryfikacyjnego (niezalecane).

onCodeAutoRetrievalTimeOut (identyfikator weryfikacji ciągu znaków)

Opcjonalny. Ta metoda jest wywoływana po upłynięciu limitu czasu określonego dla verifyPhoneNumber bez uprzedniego wyzwolenia onVerificationCompleted . Na urządzeniach bez kart SIM ta metoda jest wywoływana natychmiast, ponieważ automatyczne pobieranie wiadomości SMS nie jest możliwe.

Niektóre aplikacje blokują wprowadzanie danych przez użytkownika do momentu upływu limitu czasu automatycznej weryfikacji, a dopiero potem wyświetlają interfejs użytkownika, który monituje użytkownika o wpisanie kodu weryfikacyjnego z wiadomości SMS (niezalecane).

Utwórz obiekt PhoneAuthCredential

Gdy użytkownik wprowadzi kod weryfikacyjny, który Firebase wysłał na telefon użytkownika, utwórz obiekt PhoneAuthCredential , używając kodu weryfikacyjnego i identyfikatora weryfikacyjnego, które zostały przekazane do wywołania zwrotnego onCodeSent lub onCodeAutoRetrievalTimeOut . (Kiedy onVerificationCompleted jest wywoływana, otrzymujesz bezpośrednio 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)
PhoneAuthActivity.kt

Java

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

Zaloguj użytkownika

Po uzyskaniu obiektu PhoneAuthCredential w wywołaniu zwrotnym onVerificationCompleted lub przez wywołanie PhoneAuthProvider.getCredential zakończ przepływ 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
            }
        }
}
PhoneAuthActivity.kt

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
                        }
                    }
                }
            });
}
PhoneAuthActivity.java

Test 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 użytkowania.
  • Przetestuj uwierzytelnianie numeru telefonu bez wysyłania rzeczywistej wiadomości SMS.
  • Przeprowadzaj kolejne testy z tym samym numerem telefonu bez ograniczania. Minimalizuje to ryzyko odrzucenia podczas procesu recenzji w App Store, jeśli recenzent użyje tego samego numeru telefonu do testów.
  • Łatwo testuj 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 na rzeczywistych numerach 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 ustawić 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 z prefiksem 555 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 programowania.
  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 dostawcę 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. W razie potrzeby 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ąć korzystać z fikcyjnego numeru telefonu w swojej aplikacji. Pozwala to na przeprowadzanie testów ręcznych na etapach opracowywania bez problemów z limitami lub 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, żaden SMS nie zostanie wysłany. 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 zachowanie i właściwości jak prawdziwy użytkownik numeru telefonu i może uzyskiwać dostęp do bazy danych czasu rzeczywistego/Cloud Firestore i innych usług w ten sam sposób. Token identyfikacyjny wybity podczas tego procesu ma taki sam podpis jak prawdziwy użytkownik numeru telefonu.

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

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

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

Testy integracyjne

Oprócz testów ręcznych usługa Firebase Authentication udostępnia interfejsy API ułatwiające pisanie testów integracyjnych na potrzeby testowania uwierzytelniania przez telefon. Te interfejsy API wyłączają weryfikację aplikacji, wyłączając wymaganie reCAPTCHA w sieciowych i cichych powiadomieniach push w iOS. Dzięki temu testowanie automatyzacji jest możliwe w tych przepływach i łatwiejsze do wdrożenia. Ponadto pomagają zapewnić możliwość testowania przepływów natychmiastowej 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 ręcznego rozwiązywania problemu. Mimo że Play Integrity i reCAPTCHA są wyłączone, logowanie przy użyciu prawdziwego numeru telefonu nie powiedzie się. Z tym interfejsem API można używać tylko fikcyjnych numerów telefonów.

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

Wywołanie verifyPhoneNumber z fikcyjnym numerem uruchamia wywołanie zwrotne onCodeSent , w którym musisz podać odpowiedni kod weryfikacyjny. Pozwala to na 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);
MainActivity.java

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)
MainActivity.kt

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

Gdy wywoływana jest verifyPhoneNumber , jest ona wyzwalana onVerificationCompleted bezpośrednio z PhoneAuthCredential . Działa to tylko z fikcyjnymi numerami telefonów.

Upewnij się, że ta funkcja jest wyłączona, a podczas publikowania aplikacji w sklepie Google Play żadne fikcyjne numery telefonów nie są zakodowane na stałe w Twojej aplikacji.

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);
MainActivity.java

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)
MainActivity.kt

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 obiektu FirebaseUser . Zobacz Zarządzanie użytkownikami .

  • 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 :

Kotlin+KTX

Firebase.auth.signOut()
MainActivity.kt

Java

FirebaseAuth.getInstance().signOut();
MainActivity.java