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

Uwierzytelnij się w Firebase na Androida przy użyciu 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 do logowania za pomocą numeru telefonu, a także logowanie oparte na haśle i federacyjne -w. W tym dokumencie opisano, jak zaimplementować proces logowania 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. Korzystając z narzędzia Firebase Android BoM , zadeklaruj zależność dla biblioteki Firebase Authentication dla systemu Android w pliku Gradle modułu (na poziomie aplikacji) (zwykle app/build.gradle ).

    Jawa

    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:27.0.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 BoM Firebase na Androida , Twoja aplikacja będzie zawsze używać zgodnych wersji bibliotek Firebase na Androida.

    (Alternatywnie) Zadeklaruj zależności bibliotek 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 wielu bibliotek Firebase w swojej aplikacji, zdecydowanie zalecamy korzystanie z 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:20.0.4'
    }
    

    Kotlin + KTX

    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:27.0.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 BoM Firebase na Androida , Twoja aplikacja będzie zawsze używać zgodnych wersji bibliotek Firebase na Androida.

    (Alternatywnie) Zadeklaruj zależności bibliotek 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 wielu bibliotek Firebase w swojej aplikacji, zdecydowanie zalecamy korzystanie z 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:20.0.4'
    }
    
  3. Jeśli nie połączyłeś jeszcze swojej 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. Zobacz Uwierzytelnianie klienta, aby uzyskać informacje na temat znajdowania skrótu SHA-1 aplikacji.

Obawy dotyczące bezpieczeństwa

Uwierzytelnianie za pomocą samego numeru telefonu, choć wygodne, jest mniej bezpieczne niż inne dostępne metody, ponieważ posiadanie numeru telefonu można łatwo przenosić między użytkownikami. Ponadto na urządzeniach z wieloma profilami użytkowników każdy użytkownik, który może odbierać wiadomości SMS, może zalogować się na konto przy użyciu numeru telefonu urządzenia.

Jeśli korzystasz z logowania na podstawie numeru telefonu w swojej aplikacji, powinieneś oferować je wraz z bezpieczniejszymi metodami logowania i informować użytkowników o kompromisach związanych z używaniem logowania za pomocą numeru telefonu.

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

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

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

Limit żądań logowania na numer telefonu w Firebase jest na tyle wysoki, że nie ma to wpływu na większość aplikacji. Jeśli jednak musisz zalogować bardzo dużą liczbę użytkowników za pomocą uwierzytelniania telefonicznego, może być konieczne uaktualnienie planu cenowego. Zobacz stronę z cenami .

Włącz weryfikację aplikacji

Aby korzystać z uwierzytelniania numeru telefonu, Firebase musi mieć możliwość zweryfikowania, czy żądania logowania na numer telefonu pochodzą z Twojej aplikacji. Uwierzytelnianie Firebase można to osiągnąć na dwa sposoby:

  • SafetyNet : jeśli użytkownik ma urządzenie z zainstalowanymi usługami Google Play, a uwierzytelnianie Firebase może zweryfikować urządzenie jako legalne w Android SafetyNet , logowanie na numer 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 interfejsu Firebase API, który należy zezwolić na dostęp do interfejsu API DeviceCheck.
    2. Jeśli nie określiłeś jeszcze odcisku palca SHA-256 swojej aplikacji, zrób to na stronie Ustawienia konsoli Firebase. Szczegółowe informacje na temat uzyskiwania odcisku palca SHA-256 aplikacji można znaleźć w sekcji Uwierzytelnianie klienta .
  • Weryfikacja reCAPTCHA : w przypadku, gdy nie można użyć SafetyNet, na przykład gdy użytkownik nie ma wsparcia dla usług Google Play lub podczas testowania aplikacji na emulatorze, uwierzytelnianie Firebase wykorzystuje weryfikację reCAPTCHA do 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, aby SHA-1 był powiązany z twoją aplikacją.

Wyślij kod weryfikacyjny na telefon użytkownika

Aby zainicjować logowanie za pomocą numeru telefonu, należy przedstawić użytkownikowi interfejs, który monituje o wpisanie numeru telefonu. Wymagania prawne są różne, ale zgodnie z najlepszą praktyką i aby określić oczekiwania użytkowników, należy ich poinformować, że jeśli korzystają z logowania telefonicznego, mogą otrzymać wiadomość SMS do weryfikacji i zastosować standardowe stawki.

Następnie przekaż ich numer telefonu do metody PhoneAuthProvider.verifyPhoneNumber , aby zażądać od PhoneAuthProvider.verifyPhoneNumber zweryfikowania numeru telefonu użytkownika. Na przykład:

Jawa

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 ponownie wprowadzana: 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 verifyPhoneNumber 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 i przywróć flagę w onRestoreInstanceState . Na koniec, w metodzie onStart swojej Activity, sprawdź, czy weryfikacja już trwa, a jeśli tak, ponownie zadzwoń do verifyPhoneNumber . Pamiętaj, aby wyczyścić flagę po zakończeniu lub niepowodzeniu weryfikacji (zobacz wywołania zwrotne weryfikacji ).

Aby łatwo obsługiwać obrót ekranu i inne przypadki verifyPhoneNumber uruchamiania działania, przekaż swoje działanie do metody verifyPhoneNumber . Wywołania zwrotne zostaną automatycznie odłączone po zatrzymaniu działania, dzięki czemu można 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 uwierzytelniania.

Jawa

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()

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

Jawa

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

Weryfikacja połączeń zwrotnych

W większości aplikacji zaimplementujesz wywołania zwrotne onVerificationCompleted , onVerificationFailed i onCodeSent . Możesz również zaimplementować onCodeAutoRetrievalTimeOut , w zależności od wymagań 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ące weryfikacyjne wiadomości SMS i przeprowadzać weryfikację bez działania użytkownika. (Ta funkcja może być niedostępna w przypadku niektórych operatorów).
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ć się do użytkownika .

onVerificationFailed (FirebaseException)

Ta metoda jest wywoływana w odpowiedzi na nieprawidłowe żądanie weryfikacji, na przykład żądanie zawierające nieprawidłowy numer telefonu lub kod weryfikacyjny.

onCodeSent (String weryfikacjaId, PhoneAuthProvider.ForceResendingToken)

Opcjonalny. Ta metoda jest wywoływana po przesł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. (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 przekazanego do metody, aby utworzyć obiekt PhoneAuthCredential , który możesz z kolei użyć do zalogowania się użytkownika. Jednak niektóre aplikacje mogą czekać na onCodeAutoRetrievalTimeOut przed wyświetleniem interfejsu użytkownika kodu weryfikacyjnego (niezalecane).

onCodeAutoRetrievalTimeOut (String weryfikacjaId)

Opcjonalny. Ta metoda jest wywoływana po upływie limitu czasu określonego w celu verifyPhoneNumber bez onVerificationCompleted wyzwalania onVerificationCompleted . Na urządzeniach bez karty 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 czasu wygaśnięcia okresu automatycznej weryfikacji i dopiero wtedy wyświetlają interfejs użytkownika, który monituje użytkownika o wpisanie kodu weryfikacyjnego z wiadomości SMS (niezalecane).

Utwórz obiekt PhoneAuthCredential

Po wprowadzeniu przez użytkownika kodu weryfikacyjnego, który Firebase wysłał na telefon użytkownika, utwórz obiekt PhoneAuthCredential , używając kodu weryfikacyjnego i identyfikatora weryfikacyjnego, który został przekazany do wywołania zwrotnego onCodeSent lub onCodeAutoRetrievalTimeOut . (Gdy onVerificationCompleted jest onVerificationCompleted PhoneAuthCredential bezpośrednio PhoneAuthCredential obiekt PhoneAuthCredential , dzięki czemu można pominąć ten krok).

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

Jawa

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

Kotlin + KTX

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

Zarejestruj użytkownika

Po dostać PhoneAuthCredential obiektu, czy w onVerificationCompleted zwrotnego lub dzwoniąc PhoneAuthProvider.getCredential , wypełnij logowania przepływu przez przepuszczenie PhoneAuthCredential obiekt do FirebaseAuth.signInWithCredential :

Jawa

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

W 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żytkowania.
  • Przetestuj uwierzytelnianie numeru telefonu bez wysyłania faktycznej wiadomości SMS.
  • Uruchom kolejne testy z tym samym numerem telefonu bez dławienia. Minimalizuje to ryzyko odrzucenia podczas procesu przeglądu App Store, jeśli recenzent użyje tego samego numeru telefonu do testów.
  • Testuj z łatwością w środowiskach programistycznych bez dodatkowego wysiłku, takiego jak możliwość tworzenia 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 są rzeczywiście fikcyjne i jeszcze nie istnieją. Uwierzytelnianie Firebase nie pozwala ustawić istniejących numerów telefonów używanych przez rzeczywistych użytkowników jako numerów testowych. Jedną z opcji jest użycie 555 numerów z prefiksem jako numerów telefonów testowych w USA, na przykład: +1 650-555-3434
  2. Numery telefonów muszą być poprawnie sformatowane pod względem długości i innych ograniczeń. Będą nadal przechodzić tę samą weryfikację, co numer telefonu rzeczywistego użytkownika.
  3. Możesz dodać do 10 numerów telefonów do programowania.
  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ę 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 bezpośrednio zacząć używać fikcyjnego numeru telefonu w swojej aplikacji. Pozwala to na wykonywanie ręcznych testów na etapach programowania bez problemów z przydziałami 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, SMS nie zostanie wysłany. Zamiast tego musisz podać wcześniej skonfigurowany kod weryfikacyjny, aby ukończyć logowanie.

Po zakończeniu logowania zostaje utworzony użytkownik Firebase z tym numerem telefonu. Użytkownik ma takie samo zachowanie i właściwości, jak prawdziwy użytkownik numeru telefonu i może uzyskać dostęp do bazy danych czasu rzeczywistego / Cloud Firestore i innych usług w ten sam sposób. Identyfikator 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 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 integracyjnych na potrzeby testów uwierzytelniania przez telefon. Te interfejsy API wyłączają weryfikację aplikacji, wyłączając wymaganie reCAPTCHA w sieci i ciche powiadomienia push w iOS. Dzięki temu testowanie automatyzacji jest możliwe w tych przepływach i jest łatwiejsze do wdrożenia. Ponadto pomagają zapewnić możliwość testowania przepływów natychmiastowej weryfikacji w systemie Android.

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 tego problemu. Pamiętaj, że nawet jeśli reCAPTCHA i / lub SafetyNet są wyłączone, logowanie się za pomocą prawdziwego numeru telefonu nie powiedzie się. 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 z fikcyjnym numerem uruchamia wywołanie zwrotne onCodeSent , w którym należy podać odpowiedni kod weryfikacyjny. Pozwala to na testowanie w emulatorach Androida.

Jawa

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żna przetestować przepływy automatycznego pobierania w systemie Android, ustawiając numer fikcyjny i odpowiadający mu kod weryfikacyjny na potrzeby automatycznego pobierania, wywołując setAutoRetrievedSmsCodeForPhoneNumber .

Gdy verifyPhoneNumber jest onVerificationCompleted PhoneAuthCredential bezpośrednio wyzwala onVerificationCompleted z właściwością PhoneAuthCredential . Działa to tylko w przypadku fikcyjnych numerów telefonów.

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

Jawa

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

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

  • W Firebase Realtime Database i Cloud Storage Rules możesz uzyskać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i używać go do kontrolowania, do jakich danych użytkownik ma dostęp.

Możesz zezwolić użytkownikom na logowanie się do aplikacji przy użyciu wielu dostawców uwierzytelniania, łącząc poświadczenia dostawcy uwierzytelniania z istniejącym kontem użytkownika.

Aby wylogować użytkownika, wywołaj signOut :

Jawa

FirebaseAuth.getInstance().signOut();

Kotlin + KTX

Firebase.auth.signOut()