Uwierzytelniaj w Firebase na urządzeniu z Androidem przy użyciu numeru telefonu

Możesz użyć uwierzytelniania Firebase, aby zalogować użytkownika, wysyłając SMS-a do telefonu użytkownika. Użytkownik loguje się za pomocą jednorazowego kodu zawartego w SMS.

Najprostszym sposobem dodania logowania przez numer telefonu do aplikacji jest użycie FirebaseUI, który zawiera widżet logowania, który obsługuje proces logowania się na telefonie logowania numerycznego oraz sfederowanego i za pomocą hasła. Ten dokument opisuje, jak wdrożyć proces logowania przez numer telefonu za pomocą pakietu SDK Firebase.

Zanim zaczniesz

  1. Jeśli jeszcze nie masz tego za sobą, dodaj Firebase do swojego projektu na Androida.
  2. w pliku Gradle (na poziomie aplikacji) modułu, (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle), dodaj zależność z biblioteką uwierzytelniania Firebase na Androida. Zalecamy użycie metody Funkcja BoM Firebase na Androida aby kontrolować obsługę wersji biblioteki. 
    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.1.2"))

    // Add the dependency for the Firebase Authentication library
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-auth")
}

    Korzystając z BM Firebase Android BoM, Twoja aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.

    (Wersja alternatywna) Dodawanie zależności biblioteki Firebase bez korzystania z BM

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

    Pamiętaj, że jeśli używasz wielu bibliotek Firebase w aplikacji, zalecamy korzystanie z BoM do zarządzania wersjami biblioteki, dzięki czemu wszystkie wersje 

    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:23.0.0")
}
    Szukasz modułu biblioteki korzystającego z usługi Kotlin? Zaczyna się za Październik 2023 r. (Firebase BoM 32.5.0), programiści, zarówno w języku Kotlin, jak i w języku Java, zależą od modułu biblioteki głównej (więcej informacji znajdziesz w Najczęstsze pytania na temat tej inicjatywy).
  3. Jeśli Twoja aplikacja nie jest jeszcze połączona z projektem Firebase, zrób to na stronie w konsoli Firebase.
  4. Jeśli nie masz jeszcze ustawionego skrótu SHA-1 swojej aplikacji w konsoli Firebase, to zrobić. Zobacz Uwierzytelnianie klienta – w przypadku informacji o znalezieniu SHA-1 aplikacji za pomocą skrótu.

Potencjalne problemy z bezpieczeństwem

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

Jeśli w aplikacji korzystasz z logowania się na podstawie numeru telefonu, z bezpieczniejszymi metodami logowania oraz informować użytkowników logowanie się przy użyciu numeru telefonu.

Włączanie logowania się za pomocą numeru telefonu w projekcie Firebase

Aby logować użytkowników za pomocą SMS-ów, musisz najpierw włączyć logowanie się przy użyciu numeru telefonu do swojego projektu Firebase:

  1. W konsoli Firebase otwórz sekcję Uwierzytelnianie.
  2. Na stronie Sign-in Method (Metoda logowania) włącz Phone Number. metody logowania się.

Limit próśb o zalogowanie się za pomocą numeru telefonu w Firebase jest tak wysoki, że większość aplikacji nie będzie mieć wpływu na dane. Jeśli jednak musisz logować się bardzo dużo użytkowników uwierzytelnianie przez telefon może wymagać przejścia na wyższy abonament. Zobacz cennik.

Włącz weryfikację aplikacji

Aby korzystać z uwierzytelniania przez numer telefonu, Firebase musi mieć możliwość potwierdzenia, że: z aplikacji pochodzą prośby o zalogowanie się na numer telefonu. Są 3 sposoby Umożliwia to Uwierzytelnianie Firebase:

  • Play Integrity API: jeśli użytkownik ma urządzenie z zainstalowanymi Usługami Google Play, i Uwierzytelnianie Firebase mogą potwierdzić wiarygodność urządzenia przy użyciu Interfejs Play Integrity API możemy kontynuować logowanie się na numer telefonu. Interfejs Play Integrity API został włączony w projekcie należącym do Google Uwierzytelniania Firebase, a nie w projekcie. Nie wpływa to na interfejs Play Integrity API i ograniczeniami w projekcie. Zespół pomocy Play Integrity jest dostępny Pakiet SDK do uwierzytelniania w wersji 21.2.0 lub nowszej (Firebase BoM w wersji 31.4.0 lub nowszej).

    Jeśli chcesz korzystać z Play Integrity, musisz określić odcisk cyfrowy SHA-256 swojej aplikacji. z Projekt konsoli Firebase. Więcej informacji: Uwierzytelnianie Klient, który zawiera szczegółowe informacje o tym, jak pobrać odcisk cyfrowy SHA-256 aplikacji.

  • Weryfikacja reCAPTCHA: jeśli nie można korzystać z Play Integrity, np. gdy użytkownik ma urządzenie bez zainstalowanych Usług Google Play, Uwierzytelnianie Firebase korzysta z weryfikacji reCAPTCHA do ukończenia procesu logowania telefonicznego. Zadanie reCAPTCHA można wykonać często są realizowane bez konieczności rozwiązania problemu. Pamiętaj, że ten proces wymaga: z Twoją aplikacją jest powiązany SHA-1. Ten proces wymaga również bez ograniczeń lub na liście dozwolonych w domenie PROJECT_ID.firebaseapp.com.

    Oto przykładowe sytuacje, w których reCAPTCHA jest uruchamiany:

    • Jeśli na urządzeniu użytkownika nie ma zainstalowanych Usług Google Play.
    • Jeśli aplikacja nie jest rozpowszechniana w Sklepie Google Play (w przypadku pakietu Authentication SDK w wersji 21.2.0 lub nowszej).
    • Jeśli uzyskany token SafetyNet był nieprawidłowy (w pakiecie SDK do uwierzytelniania w wersji < 21.2.0),

    Jeśli do weryfikacji aplikacji używana jest usługa SafetyNet lub Play Integrity, pole %APP_NAME% w szablonie SMS jest zapełniane nazwą aplikacji określoną ze Sklepu Google Play. W sytuacjach, gdy reCAPTCHA jest uruchamiany, pole %APP_NAME% jest zapełniane wartością PROJECT_ID.firebaseapp.com.

    .
. Proces weryfikacji reCAPTCHA możesz wymusić za pomocą forceRecaptchaFlowForTesting. Do wyłączenia weryfikacji aplikacji (w przypadku fikcyjnych numerów telefonu) możesz użyć funkcji setAppVerificationDisabledForTesting

Rozwiązywanie problemów

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

    Ten błąd może wystąpić, gdy przepływ reCAPTCHA zostanie ukończony, ale użytkownik nie przekieruje użytkownika z powrotem do aplikacji natywnej. W takim przypadku użytkownik zostanie przekierowany na zastępczy adres URL PROJECT_ID.firebaseapp.com/__/auth/handler. W przeglądarkach Firefox otwieranie linków do aplikacji natywnych jest domyślnie wyłączone. Jeśli ten błąd pojawia się w Firefoksie, wykonaj czynności opisane w artykule Ustawianie przeglądarki Firefox na Androida do otwierania linków w aplikacjach natywnych, aby umożliwić otwieranie linków do aplikacji.

Wysyłanie kodu weryfikacyjnego na telefon użytkownika

Aby rozpocząć logowanie za pomocą numeru telefonu, użyj interfejsu z prośbą o wyświetlenie prośby żeby wpisać swój numer telefonu. Wymagania prawne są różne, ale jest to sprawdzona metoda i określać oczekiwania użytkowników, należy ich poinformować, przez telefon, mogą otrzymać SMS-a w celu weryfikacji i standardowego obowiązują opłaty.

Następnie przekaż jego numer telefonu do PhoneAuthProvider.verifyPhoneNumber metoda wysyłania żądania Firebase zweryfikować numer telefonu użytkownika. 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 powtarzająca się, jeśli ją wywołasz wiele razy, na przykład w metodzie onStart aktywności, Metoda verifyPhoneNumber nie wyśle drugiego SMS-a, chyba że przekroczono limit czasu pierwotnego żądania.

Możesz ich użyć do wznowienia procesu logowania się na numer telefonu, jeśli aplikacja zamyka się, zanim użytkownik będzie mógł się zalogować (np. gdy użytkownik korzysta z w aplikacji do obsługi SMS-ów). Po wywołaniu funkcji verifyPhoneNumber ustaw flagę, która wskazuje, że trwa weryfikacja. Następnie zapisz flagę w sekcji Aktywność onSaveInstanceState i przywróć flagę w onRestoreInstanceState Na koniec, w sekcji Aktywność onStart, sprawdź, czy weryfikacja jest już w toku. Jeśli tak, zadzwoń ponownie pod numer verifyPhoneNumber. Pamiętaj, żeby usunąć flagę, gdy zakończy się lub nie zakończy weryfikacji (patrz na potrzeby weryfikacji).

Aby łatwo obsługiwać obrót ekranu i inne przypadki ponownego uruchomienia urządzenia, przekazują Twoją aktywność do metody verifyPhoneNumber. Wywołania zwrotne zostanie automatycznie odłączona po zakończeniu aktywności, dzięki czemu możesz swobodnie pisać UI kodu przejścia w metodach wywołań zwrotnych.

SMS wysłany przez Firebase można też zlokalizować, określając język uwierzytelniania za pomocą metody setLanguageCode w Uwierzytelnianiu instancji.

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 dzwonisz pod numer PhoneAuthProvider.verifyPhoneNumber, musisz też podać instancję OnVerificationStateChangedCallbacks, która zawiera implementacje funkcji wywołania zwrotnego, które obsługują wyniki do ich przesłania. 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

Wywołania zwrotne w ramach weryfikacji

W większości aplikacji implementujesz onVerificationCompleted, onVerificationFailed i onCodeSent wywołań zwrotnych. Ty może też zaimplementować onCodeAutoRetrievalTimeOut, w zależności od z wymaganiami aplikacji.

onWeryfikacjaZakończona(PhoneAuthCredential)

Metodę tę wywołuje się w 2 sytuacjach:

  • Natychmiastowa weryfikacja: w niektórych przypadkach numer telefonu można połączyć natychmiast. weryfikacji bez konieczności wysyłania ani wpisywania kodu weryfikacyjnego.
  • Automatyczne pobieranie: na niektórych urządzeniach Usługi Google Play mogą automatycznie wykrywa przychodzącego SMS-a weryfikacyjnego i przeprowadza weryfikacji bez działania ze strony użytkownika. (Ta funkcja może być niedostępna u niektórych operatorów). W tym przypadku używane są funkcje SMS retriever API, zawiera 11-znakowy hasz na końcu wiadomości SMS.
. w obu przypadkach numer telefonu użytkownika został zweryfikowany i możesz użyć obiektu PhoneAuthCredential, który jest przekazywany do wywołanie zwrotne do zalogowania użytkownika.

onWeryfikacja nieudzielona(FirebaseWyjątek)

Ta metoda jest wywoływana w odpowiedzi na nieprawidłowe żądanie weryfikacji, takie jak , które wskazują nieprawidłowy numer telefonu lub kod weryfikacyjny.

onCodeSent(String verificationId, PhoneAuthProvider.ForceConfirmingToken)

Opcjonalnie. Ta metoda jest wywoływana po wysłaniu kodu weryfikacyjnego przez SMS na podany numer telefonu.

Po wywołaniu tej metody większość aplikacji wyświetla interfejs użytkownika, który aby wpisać kod weryfikacyjny z SMS-a. (Jednocześnie automatyczna weryfikacja może być kontynuowana w tle). Następnie, gdy użytkownik wpisz kod weryfikacyjny, możesz użyć zarówno kodu, jak i identyfikator weryfikacyjny przekazany do metody w celu utworzenia PhoneAuthCredential, którego możesz użyć do zalogowania się użytkownika. Niektóre aplikacje mogą jednak poczekać do Funkcja onCodeAutoRetrievalTimeOut jest wywoływana przed wyświetleniem parametru UI kodu weryfikacyjnego (niezalecane).

onCodeAutoRetrievalTimeOut(identyfikator weryfikacji ciągu znaków)

Opcjonalnie. Ta metoda jest wywoływana po upłynięciu czasu oczekiwania określonym jako verifyPhoneNumber jest zaliczony bez Reguła onVerificationCompleted uruchamia się najpierw. Na urządzeniach bez karty SIM karty, ta metoda jest wywoływana natychmiast, ponieważ funkcja automatycznego pobierania SMS-ów jak to tylko możliwe.

Niektóre aplikacje blokują dane wejściowe użytkownika do zakończenia okresu automatycznej weryfikacji, i wyświetla interfejs użytkownika z prośbą o wpisanie kodu weryfikacyjnego. z wiadomości SMS (niezalecane).

Tworzenie obiektu PhoneAuthCredential

Gdy użytkownik wpisze kod weryfikacyjny, który Firebase wysłał na przez telefon, utwórz obiekt PhoneAuthCredential, korzystając z funkcji weryfikacji oraz identyfikator weryfikacyjny, który został przekazany do onCodeSent lub onCodeAutoRetrievalTimeOut oddzwonienie. (Kiedy onVerificationCompleted nazywa się, a Ty otrzymasz PhoneAuthCredential, możesz więc 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

Logowanie użytkownika

Po uzyskaniu obiektu PhoneAuthCredential możesz określić, czy onVerificationCompleted oddzwonienie lub połączenie telefoniczne PhoneAuthProvider.getCredential, dokończ proces logowania do 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

Testowanie za pomocą fikcyjnych numerów telefonów

W konsoli Firebase możesz skonfigurować fikcyjne numery telefonów na potrzeby programowania. Testowanie na fikcyjnym telefonie ma następujące korzyści:

  • Przetestuj uwierzytelnianie za pomocą numeru telefonu bez przekraczania limitu wykorzystania.
  • Przetestuj uwierzytelnianie numeru telefonu bez wysyłania faktycznego SMS-a.
  • Przeprowadzaj kolejne testy z tym samym numerem telefonu bez ograniczania limitu. Ten minimalizuje ryzyko odrzucenia aplikacji podczas procesu sprawdzania w Sklepie z aplikacjami, jeśli weryfikator ten sam numer telefonu do przetestowania.
  • Możesz łatwo przeprowadzać testy w środowiskach programistycznych bez dodatkowych działań, takich jak: możliwość programowania w symulatorze iOS lub w emulatorze Androida bez Usług Google Play.
  • Zapis testów integracji bez blokowania przez testy zabezpieczeń, które normalnie są stosowane przy użyciu prawdziwych numerów telefonów w środowisku produkcyjnym.

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

  1. Upewnij się, że używane numery telefonów są fałszywe i nie istnieją. Uwierzytelnianie Firebase nie umożliwia ustawiania 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 parametrów . Nadal przechodzą one taką samą weryfikację jak numer telefonu rzeczywistego użytkownika.
  3. Możesz dodać maksymalnie 10 numerów telefonów na potrzeby programowania.
  4. Używaj testowych numerów telefonów lub kodów, które są trudne do odgadnięcia i zmiany. i to często.

Tworzenie fikcyjnych numerów telefonów i kodów weryfikacyjnych

  1. W konsoli Firebase otwórz Uwierzytelnianie.
  2. Na karcie Metoda logowania włącz dostawcę telefonu, jeśli nie jest jeszcze włączony.
  3. Otwórz menu nawigacyjne Numery telefonów do testowania.
  4. Podaj numer telefonu, który chcesz przetestować, np. +1 650-555-3434.
  5. Podaj 6-cyfrowy kod weryfikacyjny tego numeru, np. 654321.
  6. Dodaj numer. W razie potrzeby możesz usunąć numer telefonu swojego kodu, najeżdżając kursorem na odpowiedni wiersz i klikając ikonę kosza.

Testy ręczne

Możesz od razu zacząć używać fikcyjnego numeru telefonu we wniosku. Dzięki temu możesz: przeprowadzaj testy ręczne na etapach programowania, aby uniknąć problemów z limitami i ich ograniczania. Możesz też przeprowadzać testy bezpośrednio w symulatorze iOS lub w emulatorze Androida bez Usług Google Play. Zainstalowano.

Po podaniu fikcyjnego numeru telefonu i wysłaniu kodu weryfikacyjnego SMS nie zostanie wysłany wysłano. Zamiast tego, aby dokończyć podpisywanie, musisz podać wcześniej skonfigurowany kod weryfikacyjny cal

Gdy się zalogujesz, zostanie utworzony użytkownik Firebase z tym numerem telefonu. działa i ma takie samo zachowanie jak prawdziwy użytkownik numeru telefonu oraz ma dostęp do Baza danych czasu rzeczywistego/Cloud Firestore i inne usługi w ten sam sposób. Token tożsamości wygenerowany podczas ten proces ma taki sam podpis jak prawdziwy użytkownik numeru telefonu.

Inną możliwością jest ustawienie roli testowej za pomocą niestandardowej dotyczące tych użytkowników, aby odróżnić ich jako fałszywych użytkowników, jeśli chcesz dostęp.

Aby ręcznie aktywować proces reCAPTCHA na potrzeby testowania, użyj Metoda forceRecaptchaFlowForTesting(). 

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

Testowanie integracji

Oprócz testowania ręcznego Uwierzytelnianie Firebase udostępnia interfejsy API, które ułatwiają pisanie testów integracji do testowania uwierzytelniania przez telefon. Te interfejsy API wyłączają weryfikację aplikacji przez wyłączenie reCAPTCHA są wymagane w przypadku aplikacji internetowych i ciche powiadomienia push w iOS. Umożliwia to testowanie automatyzacji i łatwiejsze ich wdrożenie. Zapewniają też możliwość testowania aplikacji błyskawicznych proces weryfikacji na Androidzie.

Na urządzeniu z Androidem zadzwoń pod numer setAppVerificationDisabledForTesting() przed signInWithPhoneNumber połączenie. Spowoduje to automatyczne wyłączenie weryfikacji aplikacji, dzięki czemu możesz podać numer telefonu bez ręcznego wpisywania go. Mimo że Funkcje Play Integrity i reCAPTCHA są wyłączone, dlatego nadal nie można używać prawdziwego numeru telefonu Dokończ logowanie. Za pomocą tego interfejsu API można używać tylko fikcyjnych numerów telefonów. 

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

Połączenie z numerem verifyPhoneNumber z fikcyjnym numerem aktywuje onCodeSent – musisz w tym celu podać odpowiedni numer weryfikacyjny w kodzie. Umożliwia to testowanie w emulatorach Androida.

Java

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

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

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

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

            @Override
            public void onVerificationFailed(@NonNull FirebaseException e) {
                // ...
            }
        })
        .build();
PhoneAuthProvider.verifyPhoneNumber(options);
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

Możesz też przetestować procesy automatycznego pobierania na Androidzie, ustawiając fikcyjną liczbę i odpowiadający mu kod weryfikacyjny do automatycznego pobierania przez wywołanie setAutoRetrievedSmsCodeForPhoneNumber

Gdy verifyPhoneNumber to wywołuje funkcję onVerificationCompleted z PhoneAuthCredential bezpośrednio. Ta funkcja działa tylko w przypadku fikcyjnych numerów telefonów.

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

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

Dalsze kroki

Gdy użytkownik zaloguje się po raz pierwszy, tworzone jest nowe konto użytkownika. powiązane z danymi logowania, czyli z nazwą użytkownika, hasłem i numerem telefonu, numer telefonu lub informacje o dostawcy uwierzytelniania – użytkownik zalogowany. Ten nowy jest przechowywane w ramach projektu Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w projekcie, niezależnie od tego, jak się loguje.

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

  • W Bazie danych czasu rzeczywistego Firebase i Cloud Storage reguł zabezpieczeń, możesz pobierz ze zmiennej auth unikalny identyfikator zalogowanego użytkownika, i używać ich do kontrolowania, do jakich danych użytkownik ma dostęp.

Możesz zezwolić użytkownikom na logowanie się w aplikacji przy użyciu wielokrotnego uwierzytelniania. dostawców, łącząc dane logowania dostawcy uwierzytelniania z istniejącego konta użytkownika.

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

Kotlin+KTX

Firebase.auth.signOut()
MainActivity.kt

Java

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