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

Możesz użyć Firebase Authentication, aby zalogować użytkownika, wysyłając SMS-a na jego telefon. Użytkownik loguje się za pomocą jednorazowego kodu zawartego w SMS-ie.

Najłatwiejszym sposobem dodania do aplikacji logowania za pomocą numeru telefonu jest użycie FirebaseUI, który zawiera gotowy widżet logowania implementujący przepływy logowania za pomocą numeru telefonu, a także logowania za pomocą hasła i logowania sfederowanego. W tym dokumencie opisano, jak wdrożyć proces logowania się za pomocą numeru telefonu przy użyciu pakietu SDK Firebase.

Zanim zaczniesz

  1. Dodaj Firebase do projektu aplikacji na Androida, jeśli nie korzystasz w nim jeszcze z tej usługi.
  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 biblioteki Firebase Authentication na Androida. Zalecamy używanie Firebase Android BoM do kontrolowania obsługi wersji biblioteki. 
    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:35.1.0"))

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

    Gdy korzystasz z Firebase Android BoM, aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.

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

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

    Pamiętaj, że jeśli w aplikacji używasz kilku 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:25.0.0")
}
  3. Jeśli aplikacja nie jest jeszcze połączona z projektem w Firebase, zrób to w konsoli Firebase.
  4. Jeśli nie masz jeszcze ustawionego skrótu SHA-1 aplikacji w konsoli Firebase, zrób to. Informacje o tym, jak znaleźć skrót SHA-1 aplikacji, znajdziesz w artykule Uwierzytelnianie klienta.

Potencjalne problemy z bezpieczeństwem

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

Jeśli w aplikacji używasz logowania za pomocą numeru telefonu, udostępnij tę opcję obok bezpieczniejszych metod logowania i poinformuj użytkowników o kompromisach związanych z bezpieczeństwem, które wiążą się z używaniem numeru telefonu do logowania.

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

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

  1. W konsoli Firebase otwórz Zabezpieczenia > Uwierzytelnianie.
  2. Na karcie Metoda logowania włącz dostawcę logowania przez telefon.
  3. Skonfiguruj zasadę dotyczącą regionów, do których chcesz zezwolić na wysyłanie SMS-ów lub zabronić ich wysyłania. Ustawienie zasad dotyczących regionów SMS-ów może pomóc chronić aplikacje przed nadużyciami związanymi z SMS-ami. W przypadku nowych projektów domyślna zasada nie zezwala na żadne regiony.
    1. W konsoli Firebase otwórz kartę Zabezpieczenia > Uwierzytelnianie > Ustawienia.
    2. W sekcji Zasady dotyczące regionów SMS skonfiguruj zasady dotyczące regionów SMS.

Włączanie weryfikacji aplikacji

Aby można było używać uwierzytelniania za pomocą numeru telefonu, Firebase musi mieć możliwość sprawdzenia, czy żądania logowania za pomocą numeru telefonu pochodzą z Twojej aplikacji. Firebase Authentication robi to na 3 sposoby:

  • Interfejs Play Integrity API: jeśli użytkownik ma urządzenie z zainstalowaną aplikacją Google Play services, a Firebase Authentication może zweryfikować urządzenie jako autentyczne za pomocą interfejsu Play Integrity API, można kontynuować logowanie za pomocą numeru telefonu. Interfejs Play Integrity API jest włączony w projekcie Google przez Firebase Authentication, a nie w Twoim projekcie. Nie wpływa to na limity interfejsu Play Integrity API w projekcie. Pomoc dotycząca Play Integrity jest dostępna w pakiecie SDK Authentication w wersji 21.2.0 lub nowszej (Firebase BoM w wersji 31.4.0 lub nowszej).

    Aby korzystać z Play Integrity, podaj odcisk cyfrowy SHA-256 aplikacji, jeśli jeszcze nie został podany.

    1. W konsoli Firebase otwórz kartę Ustawienia > Ogólne.
    2. Przewiń w dół do karty Twoje aplikacje, wybierz aplikację na Androida i dodaj odcisk cyfrowy SHA-256 w polu Odciski cyfrowe certyfikatu SHA.

    Szczegółowe informacje o tym, jak uzyskać odcisk cyfrowy SHA aplikacji, znajdziesz w artykule na temat uwierzytelniania klienta.

  • Weryfikacja reCAPTCHA: jeśli nie można użyć Play Integrity, na przykład gdy użytkownik ma urządzenie bez zainstalowanej aplikacji Google Play services, Firebase Authentication używa weryfikacji reCAPTCHA, aby dokończyć proces logowania się za pomocą telefonu. Zadanie reCAPTCHA często można wykonać bez konieczności rozwiązywania czegokolwiek przez użytkownika. Pamiętaj, że ten proces wymaga powiązania SHA-1 z aplikacją. Ten proces wymaga również, aby klucz interfejsu API nie miał ograniczeń lub był na liście dozwolonych w przypadku PROJECT_ID.firebaseapp.com.

    Oto kilka sytuacji, w których uruchamiana jest reCAPTCHA:

    • Jeśli na urządzeniu użytkownika nie jest zainstalowana aplikacja Google Play services.
    • Jeśli aplikacja nie jest rozpowszechniana przez Google Play Store (w Authentication SDK w wersji 21.2.0 lub nowszej).
    • Jeśli uzyskany token SafetyNet był nieprawidłowy (w wersjach pakietu SDK Authentication starszych niż 21.2.0).

    Gdy do weryfikacji aplikacji używana jest usługa SafetyNet lub Play Integrity, pole %APP_NAME% w szablonie SMS-a jest wypełniane nazwą aplikacji określoną na podstawie Google Play Store. W scenariuszach, w których uruchamiana jest usługa reCAPTCHA, parametr %APP_NAME% jest wypełniany jako PROJECT_ID.firebaseapp.com.

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

Rozwiązywanie problemów

  • Błąd „Brak stanu początkowego” podczas korzystania z reCAPTCHA do weryfikacji aplikacji

    Może się tak zdarzyć, gdy proces reCAPTCHA zakończy się pomyślnie, ale nie przekieruje użytkownika z powrotem do aplikacji natywnej. W takim przypadku użytkownik jest przekierowywany 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 w Firefoksie widzisz powyższy błąd, wykonaj czynności opisane w artykule Ustawianie Firefoksa na Androida, aby otwierał linki w aplikacjach natywnych, aby włączyć otwieranie linków do aplikacji.

wysłać kod weryfikacyjny na telefon użytkownika,

Aby zainicjować logowanie za pomocą numeru telefonu, wyświetl użytkownikowi interfejs, który prosi o wpisanie numeru telefonu. Wymagania prawne różnią się, ale zgodnie ze sprawdzonymi metodami i aby określić oczekiwania użytkowników, poinformuj ich, że jeśli korzystają z logowania przez telefon, mogą otrzymać SMS-a z prośbą o weryfikację i że obowiązują standardowe opłaty.

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

Kotlin

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

Java

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

Metoda verifyPhoneNumber jest wielobieżna: jeśli wywołasz ją wielokrotnie, np. w metodzie onStart aktywności, metoda verifyPhoneNumber nie wyśle drugiego SMS-a, chyba że upłynie 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ć (np. gdy użytkownik korzysta z aplikacji do SMS-ów). Po wywołaniu metody verifyPhoneNumber ustaw flagę wskazującą, że weryfikacja jest w toku. Następnie zapisz flagę w metodzie onSaveInstanceState aktywności i przywróć ją w onRestoreInstanceState. Na koniec w metodzie onStart aktywności sprawdź, czy weryfikacja jest już w toku, a jeśli tak, ponownie wywołaj verifyPhoneNumber. Pamiętaj, aby usunąć flagę po zakończeniu weryfikacji lub w przypadku jej niepowodzenia (patrz Wywołania zwrotne weryfikacji).

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

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

Kotlin

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

Java

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

Podczas wywoływania metody PhoneAuthProvider.verifyPhoneNumber musisz też podać instancję OnVerificationStateChangedCallbacks, która zawiera implementacje funkcji wywołania zwrotnego obsługujących wyniki żądania. Na przykład:

Kotlin

callbacks = object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

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

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

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

        // Show a message and update the UI
    }

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

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

Java

mCallbacks = new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

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

        signInWithPhoneAuthCredential(credential);
    }

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

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

        // Show a message and update the UI
    }

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

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

Wywołania zwrotne dotyczące weryfikacji

W większości aplikacji implementuje się wywołania zwrotne onVerificationCompleted, onVerificationFailed i onCodeSent. W zależności od wymagań aplikacji możesz też wdrożyć onCodeAutoRetrievalTimeOut.

onVerificationCompleted(PhoneAuthCredential)

Ta metoda jest wywoływana w 2 sytuacjach:

  • Natychmiastowa weryfikacja: w niektórych przypadkach numer telefonu można zweryfikować natychmiast, bez konieczności wysyłania lub wpisywania kodu weryfikacyjnego.
  • Automatyczne pobieranie: na niektórych urządzeniach Usługi Google Play mogą automatycznie wykrywać przychodzące SMS-y weryfikacyjne i przeprowadzać weryfikację bez udziału użytkownika. (Ta funkcja może być niedostępna u niektórych operatorów). Wykorzystuje on interfejs SMS Retriever API, który zawiera 11-znakowy skrót na końcu SMS-a.
W obu przypadkach numer telefonu użytkownika został zweryfikowany i możesz 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, np. żądanie, które zawiera nieprawidłowy numer telefonu lub kod weryfikacyjny.

onCodeSent(String verificationId, PhoneAuthProvider.ForceResendingToken)

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

Gdy ta metoda jest wywoływana, większość aplikacji wyświetla interfejs, który prosi użytkownika o wpisanie kodu weryfikacyjnego z SMS-a. (Jednocześnie w tle może odbywać się automatyczna weryfikacja). Gdy użytkownik wpisze kod weryfikacyjny, możesz użyć tego kodu i identyfikatora weryfikacji przekazanego do metody, aby utworzyć obiekt PhoneAuthCredential, którego możesz użyć do zalogowania użytkownika. Niektóre aplikacje mogą jednak czekać na wywołanie metody onCodeAutoRetrievalTimeOut, zanim wyświetlą interfejs kodu weryfikacyjnego (niezalecane).

onCodeAutoRetrievalTimeOut(String verificationId)

Opcjonalnie. Ta metoda jest wywoływana po upływie czasu oczekiwania określonego w verifyPhoneNumber, jeśli wcześniej nie nastąpiło wywołanie 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ą możliwość wprowadzania danych przez użytkownika do momentu upływu czasu automatycznej weryfikacji i dopiero wtedy wyświetlają interfejs, który prosi użytkownika o wpisanie kodu weryfikacyjnego z SMS-a (niezalecane).

Tworzenie obiektu PhoneAuthCredential

Gdy użytkownik wpisze kod weryfikacyjny wysłany przez Firebase na jego telefon, utwórz obiekt PhoneAuthCredential, używając kodu weryfikacyjnego i identyfikatora weryfikacji przekazanego do wywołania zwrotnego onCodeSent lub onCodeAutoRetrievalTimeOut. (Gdy wywoływana jest metoda onVerificationCompleted, otrzymujesz bezpośrednio obiekt PhoneAuthCredential, więc możesz pominąć ten krok).

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

Kotlin

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

Java

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

Logowanie użytkownika

Po uzyskaniu obiektu PhoneAuthCredential w wywołaniu zwrotnym onVerificationCompleted lub przez wywołanie PhoneAuthProvider.getCredential dokończ proces logowania, przekazując obiekt PhoneAuthCredential do FirebaseAuth.signInWithCredential:

Kotlin

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

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

Java

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

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

Testowanie za pomocą fikcyjnych numerów telefonów

Możesz skonfigurować fikcyjne numery telefonów do celów programistycznych za pomocą konsoli Firebase. Testowanie z użyciem fikcyjnych numerów telefonów zapewnia te korzyści:

  • Przetestuj uwierzytelnianie numeru telefonu bez wykorzystywania limitu wykorzystania.
  • Przetestuj uwierzytelnianie numeru telefonu bez wysyłania SMS-a.
  • przeprowadzać kolejne testy z tym samym numerem telefonu bez ograniczania przepustowości. Zminimalizuje to ryzyko odrzucenia aplikacji podczas procesu sprawdzania w sklepie z aplikacjami, jeśli weryfikator użyje tego samego numeru telefonu do testów.
  • łatwe testowanie w środowiskach programistycznych bez dodatkowego wysiłku, np. możliwość programowania w symulatorze iOS lub Android Emulatorze bez usług Google Play;
  • pisać testy integracyjne bez blokowania przez kontrole bezpieczeństwa, które zwykle są stosowane do 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 nie istnieją. Firebase Authentication nie pozwala na ustawianie 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 amerykańskich testowych numerów telefonów, na przykład: +1 650-555-3434
  2. Numery telefonów muszą być prawidłowo sformatowane pod względem długości i innych ograniczeń. Będą one przechodzić tę samą weryfikację co numer telefonu prawdziwego użytkownika.
  3. Możesz dodać maksymalnie 10 numerów telefonów do celów programistycznych.
  4. Używaj testowych numerów telefonów i kodów, które są trudne do odgadnięcia, i często je zmieniaj.

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

  1. W konsoli Firebase otwórz Zabezpieczenia > Uwierzytelnianie.
  2. Na karcie Metoda logowania włącz dostawcę logowania Telefon, jeśli nie został jeszcze włączony.
  3. Rozwiń sekcję Numery telefonów do testowania.
  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. Kliknij Dodaj przy każdym numerze. W razie potrzeby możesz usunąć numer telefonu i jego kod, 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 w aplikacji. Dzięki temu możesz przeprowadzać testy ręczne na etapach programowania bez problemów z limitami i ograniczeniami. Możesz też przeprowadzić test bezpośrednio w symulatorze iOS lub Android Emulatorze bez zainstalowanych usług Google Play.

Gdy podasz fikcyjny numer telefonu i wyślesz kod weryfikacyjny, nie zostanie wysłany żaden SMS. 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 zachowania i właściwości jak użytkownik z prawdziwym numerem telefonu i może uzyskać dostęp do Realtime Database/Cloud Firestore i innych usług w ten sam sposób. Token identyfikacji wygenerowany podczas tego procesu ma taki sam podpis jak token prawdziwego użytkownika numeru telefonu.

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

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

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

Testy integracji

Oprócz testowania ręcznego Firebase Authentication udostępnia interfejsy API, które pomagają pisać testy integracyjne na potrzeby testowania uwierzytelniania przez telefon. Te interfejsy API wyłączają weryfikację aplikacji przez wyłączenie wymogu reCAPTCHA w przypadku powiadomień push w internecie i cichych powiadomień push w iOS. Umożliwia to testowanie automatyzacji w tych procesach i ułatwia ich wdrażanie. Dodatkowo pomagają testować procesy natychmiastowej weryfikacji na Androidzie.

Na Androidzie wywołaj setAppVerificationDisabledForTesting() przed wywołaniem signInWithPhoneNumber. Spowoduje to automatyczne wyłączenie weryfikacji aplikacji, co pozwoli Ci podać numer telefonu bez konieczności ręcznego rozwiązywania problemu. Nawet jeśli Play Integrity i reCAPTCHA są wyłączone, użycie prawdziwego numeru telefonu nie pozwoli na ukończenie logowania. Z tym interfejsem API można używać tylko fikcyjnych numerów telefonów. 

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

Zadzwonienie pod numer verifyPhoneNumber z fikcyjnego numeru wywołuje wywołanie zwrotne onCodeSent, w którym musisz podać odpowiedni kod weryfikacyjny. Umożliwia to testowanie w emulatorach Androida.

Java

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

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

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

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

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

Kotlin

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)

Możesz też przetestować procesy automatycznego pobierania na Androidzie, ustawiając fikcyjny numer i odpowiadający mu kod weryfikacyjny do automatycznego pobierania, wywołując setAutoRetrievedSmsCodeForPhoneNumber.

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

Upewnij się, że ta opcja jest wyłączona i że w aplikacji nie ma zakodowanych na stałe fikcyjnych numerów telefonów, gdy publikujesz ją 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);

Kotlin

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

Dalsze kroki

Gdy użytkownik zaloguje się po raz pierwszy, zostanie utworzone nowe konto użytkownika i połączone z danymi logowania, czyli nazwą użytkownika i hasłem, numerem telefonu lub informacjami o dostawcy uwierzytelniania, których użytkownik użył do zalogowania się. To nowe konto jest przechowywane w projekcie w Firebase i może służyć do identyfikowania użytkownika we wszystkich aplikacjach w projekcie, niezależnie od tego, jak się loguje.

  • W 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 regułach zabezpieczeń możesz pobrać 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ę w aplikacji przy użyciu wielu dostawców uwierzytelniania, łącząc dane logowania dostawcy uwierzytelniania z istniejącym kontem użytkownika.

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

Kotlin

Firebase.auth.signOut()

Java

FirebaseAuth.getInstance().signOut();