Uwierzytelnij się w Firebase na Androidzie za pomocą numeru telefonu

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.

Najłatwiejszym sposobem dodania logowania za pomocą numeru telefonu do aplikacji jest użycie FirebaseUI , który obejmuje widżet logowania typu drop-in, który implementuje przepływy logowania dla logowania za pomocą numeru telefonu, a także logowanie oparte na hasłach i sfederowane -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. Za pomocą Firebase Android BoM zadeklaruj zależność dla biblioteki Firebase Authentication Android w pliku Gradle modułu (na poziomie aplikacji) (zwykle app/build.gradle ).

    Java

    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:30.2.0')
    
        // Declare 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 używać zgodnych wersji bibliotek Firebase Android.

    (Alternatywnie) Zadeklaruj zależności biblioteki Firebase bez użycia BoM

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

    Pamiętaj, że jeśli korzystasz z wielu bibliotek Firebase w swojej aplikacji, zdecydowanie zalecamy używanie BoM do zarządzania wersjami bibliotek, co zapewnia zgodność wszystkich wersji.

    dependencies {
        // Declare 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:21.0.6'
    }
    

    Kotlin+KTX

    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:30.2.0')
    
        // Declare 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 używać zgodnych wersji bibliotek Firebase Android.

    (Alternatywnie) Zadeklaruj zależności biblioteki Firebase bez użycia BoM

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

    Pamiętaj, że jeśli korzystasz z wielu bibliotek Firebase w swojej aplikacji, zdecydowanie zalecamy używanie BoM do zarządzania wersjami bibliotek, co zapewnia zgodność wszystkich wersji.

    dependencies {
        // Declare 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:21.0.6'
    }
    
  3. Jeśli aplikacja nie została jeszcze połączona 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. Zobacz Uwierzytelnianie klienta , aby uzyskać informacje o znajdowaniu skrótu SHA-1 aplikacji.

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 .

Włącz weryfikację aplikacji

Aby korzystać z uwierzytelniania za pomocą numeru telefonu, Firebase musi mieć możliwość sprawdzenia, czy żądania logowania za pomocą numeru telefonu pochodzą z Twojej aplikacji. Uwierzytelnianie Firebase realizuje to na dwa sposoby:

  • SafetyNet : jeśli użytkownik ma urządzenie z zainstalowanymi Usługami Google Play, a uwierzytelnianie Firebase może zweryfikować, czy urządzenie jest legalne, za pomocą Android SafetyNet , logowanie za pomocą numeru telefonu może być kontynuowane.
  • Aby włączyć SafetyNet do użytku z Uwierzytelnianiem Firebase:

    1. W Google Cloud Console włącz Android DeviceCheck API dla swojego projektu. Zostanie użyty domyślny klucz Firebase API, który musi mieć dostęp do interfejsu DeviceCheck API.
    2. Jeśli nie określiłeś jeszcze odcisku palca SHA-256 swojej aplikacji, zrób to na stronie Ustawienia konsoli Firebase. Zapoznaj się z artykułem Uwierzytelnianie klienta , aby dowiedzieć się, jak uzyskać odcisk palca SHA-256 aplikacji.
  • Weryfikacja reCAPTCHA : w przypadku, gdy nie można użyć SafetyNet, na przykład gdy użytkownik nie obsługuje usług Google Play lub podczas testowania aplikacji na emulatorze, uwierzytelnianie Firebase używa weryfikacji reCAPTCHA w celu ukończenia procesu logowania przez telefon. Wyzwanie reCAPTCHA często można ukończyć bez konieczności rozwiązywania jakichkolwiek problemów przez użytkownika. Pamiętaj, że ten przepływ wymaga, aby z Twoją aplikacją był powiązany SHA-1.

Wyślij kod weryfikacyjny na telefon użytkownika

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

Następnie przekaż ich numer telefonu do metody PhoneAuthProvider.verifyPhoneNumber , aby poprosić Firebase o zweryfikowanie numeru telefonu użytkownika. Na przykład:

Java

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

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)

Metoda verifyPhoneNumber jest wielokrotna: jeśli wywołasz ją wielokrotnie, 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 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 aktywności i przywróć flagę w onRestoreInstanceState . Na koniec w metodzie onStart Twojej aktywności sprawdź, czy weryfikacja jest już w toku, a jeśli tak, ponownie zadzwoń do verifyPhoneNumber . Pamiętaj, aby wyczyścić flagę, gdy weryfikacja zakończy się lub nie powiedzie (zobacz Wywołania zwrotne weryfikacji ).

Aby łatwo obsługiwać obracanie ekranu i inne przypadki ponownego uruchomienia Aktywności, przekaż Aktywność do metody verifyPhoneNumber . Wywołania zwrotne zostaną automatycznie odłączone po zatrzymaniu działania, dzięki czemu możesz swobodnie pisać kod przejścia interfejsu użytkownika w metodach wywołań zwrotnych.

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

Java

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

Kotlin+KTX

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

Gdy wywołujesz PhoneAuthProvider.verifyPhoneNumber , musisz również podać wystąpienie OnVerificationStateChangedCallbacks , które zawiera implementacje funkcji wywołania zwrotnego, które obsługują wyniki żądania. Na przykład:

Java

mCallbacks = new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

    @Override
    public void onVerificationCompleted(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(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
        }

        // 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;
    }
};

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
        }

        // 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
    }
}

Oddzwonienia weryfikacyjne

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

Ukończono weryfikację (poświadczenia uwierzytelniania telefonu)

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ące weryfikacyjne wiadomości SMS i przeprowadzać weryfikację bez działania użytkownika. (Ta funkcja może być niedostępna u niektórych operatorów). Korzysta z interfejsu API programu SMS Retriever , 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żesz użyć obiektu PhoneAuthCredential , który jest przekazywany do wywołania zwrotnego, aby zalogować się do 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 (Id weryfikacji ciągu, 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 prosi użytkownika o wpisanie kodu weryfikacyjnego z wiadomości SMS. (W tym samym czasie automatyczna weryfikacja może przebiegać w tle). Następnie, po wpisaniu przez użytkownika kodu weryfikacyjnego, można użyć kodu weryfikacyjnego i identyfikatora weryfikacyjnego, który został przekazany do metody, aby utworzyć obiekt PhoneAuthCredential , który możesz z kolei użyć do zalogowania użytkownika. Jednak niektóre aplikacje mogą czekać onCodeAutoRetrievalTimeOut przed wyświetleniem interfejsu użytkownika kodu weryfikacyjnego (niezalecane).

onCodeAutoRetrievalTimeOut (Id weryfikacji ciągu)

Opcjonalny. Ta metoda jest wywoływana po upływie limitu czasu określonego dla verifyPhoneNumber bez uprzedniego wyzwalania onVerificationCompleted . Na urządzeniach bez kart 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 czasu upływu czasu automatycznej weryfikacji, a dopiero potem wyświetlają interfejs użytkownika, który prosi użytkownika o wpisanie kodu weryfikacyjnego z wiadomości SMS (niezalecane).

Utwórz obiekt PhoneAuthCredential

Po wprowadzeniu przez użytkownika kodu weryfikacyjnego wysłanego przez Firebase na telefon użytkownika utwórz obiekt PhoneAuthCredential , używając kodu weryfikacyjnego i identyfikatora weryfikacyjnego przekazanego do wywołania zwrotnego onCodeSent lub onCodeAutoRetrievalTimeOut . (Po onVerificationCompleted otrzymujesz bezpośrednio obiekt PhoneAuthCredential , więc możesz pominąć ten krok).

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

Java

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

Kotlin+KTX

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

Zaloguj się użytkownika

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

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
                        }
                    }
                }
            });
}

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
                }
            }
}

Testuj z fikcyjnymi numerami telefonów

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

  • Przetestuj uwierzytelnianie numeru telefonu bez zużywania limitu użycia.
  • Przetestuj uwierzytelnianie numeru telefonu bez wysyłania wiadomości SMS.
  • Przeprowadzaj kolejne testy z tym samym numerem telefonu bez dławienia. Minimalizuje to ryzyko odrzucenia podczas procesu recenzji App Store, jeśli recenzent użyje tego samego numeru telefonu do testów.
  • Łatwe testowanie w środowiskach programistycznych bez dodatkowego wysiłku, na przykład możliwość programowania w symulatorze systemu iOS lub emulatorze systemu Android bez usług Google Play.
  • Twórz testy integracyjne bez blokowania przez kontrole bezpieczeństwa stosowane zwykle w przypadku prawdziwych 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 są rzeczywiście 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 555 numerów 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ń. Będą nadal przechodzić tę samą weryfikację, co numer telefonu prawdziwego użytkownika.
  3. Możesz dodać maksymalnie 10 numerów telefonów do rozwoju.
  4. Używaj testowych numerów/kodów telefonó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ę usług telefonicznych, 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 bezpośrednio zacząć używać fikcyjnego numeru telefonu w swojej aplikacji. Umożliwia to ręczne testowanie na etapach opracowywania bez problemów z przydziałem lub ograniczania 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, rzeczywisty SMS nie zostanie wysłany. Zamiast tego musisz podać wcześniej skonfigurowany kod weryfikacyjny, aby zakończyć logowanie.

Po zakończeniu logowania zostanie utworzony użytkownik Firebase z tym numerem telefonu. Użytkownik zachowuje się tak samo i ma takie same właściwości jak użytkownik z prawdziwym numerem telefonu i może w ten sam sposób uzyskiwać dostęp do Bazy danych czasu rzeczywistego/Cloud Firestore i innych usług. Token ID wybity podczas tego procesu ma taki sam podpis jak użytkownik z prawdziwym numerem telefonu.

Inną opcją jest ustawienie roli testowej za pomocą oświadczeń niestandardowych 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 wyzwolić przepływ reCAPTCHA do testowania, 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 ułatwiające pisanie testów integracji na potrzeby testowania uwierzytelniania telefonicznego. Te interfejsy API wyłączają weryfikację aplikacji, wyłączając wymaganie reCAPTCHA w Internecie i ciche powiadomienia push w systemie iOS. Umożliwia to testowanie automatyzacji w tych przepływach i łatwiejsze do wdrożenia. Ponadto zapewniają możliwość testowania przepływów natychmiastowej weryfikacji w systemie Android.

W systemie Android wywołaj setAppVerificationDisabledForTesting() przed wywołaniem signInWithPhoneNumber . Wyłącza to automatycznie weryfikację aplikacji, umożliwiając przekazanie numeru telefonu bez ręcznego rozwiązywania go. Pamiętaj, że nawet jeśli reCAPTCHA i/lub SafetyNet są wyłączone, użycie prawdziwego numeru telefonu nadal nie zakończy logowania. W tym interfejsie API można używać tylko fikcyjnych numerów telefonów.

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

Wywołanie verifyPhoneNumber fikcyjnym numerem uruchamia wywołanie zwrotne onCodeSent , w którym należy 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(String verificationId,
                                   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(PhoneAuthCredential phoneAuthCredential) {
                // Sign in with the credential
                // ...
            }

            @Override
            public void onVerificationFailed(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 do automatycznego pobierania, wywołując setAutoRetrievedSmsCodeForPhoneNumber .

Po verifyPhoneNumber wyzwala onVerificationCompleted bezpośrednio z PhoneAuthCredential . Działa to tylko z fikcyjnymi numerami telefonów.

Upewnij się, że ta opcja jest wyłączona i że podczas publikowania aplikacji w sklepie Google Play w Twojej aplikacji nie są zakodowane ż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(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 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 FirebaseUser . Zobacz Zarządzanie użytkownikami .

  • 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, zadzwoń do signOut :

Java

FirebaseAuth.getInstance().signOut();

Kotlin+KTX

Firebase.auth.signOut()