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

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

Najłatwiejszym sposobem na dodanie do aplikacji logowania za pomocą numeru telefonu jest użycie FirebaseUI, które zawiera gotowy widżet logowania implementujący procesy logowania za pomocą numeru telefonu, a także logowania opartego na haśle i logowania federacyjnego. W tym dokumencie opisujemy, jak wdrożyć proces logowania za pomocą numeru telefonu przy użyciu pakietu SDK Firebase.

Zanim zaczniesz

  1. Jeśli nie korzystasz jeszcze z tej usługi, dodaj Firebase do projektu aplikacji na Androida.
  2. W pliku Gradle modułu (na poziomie aplikacji) (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle) dodaj zależność z biblioteką 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.0.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 korzystamy z Firebase Android BoM, aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.

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

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

    Pamiętaj, że jeśli w aplikacji używasz kilku bibliotek Firebase, zdecydowanie zalecamy używanie 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 nie masz jeszcze połączonej aplikacji z projektem w Firebase, zrób to w Firebase konsoli.
  4. Jeśli nie masz jeszcze ustawionego w Firebase konsoli skrótu SHA-1 aplikacji, zrób to. Informacje o znajdowaniu skrótu 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 przekazać innemu użytkownikowi. 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 za pomocą numeru telefonu urządzenia.

Jeśli w aplikacji używasz logowania na podstawie numeru telefonu, powinieneś oferować je wraz z bezpieczniejszymi metodami logowania i informować użytkowników o kompromisach w zakresie bezpieczeństwa związanych z logowaniem za pomocą numeru telefonu.

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

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

  1. W konsoli Firebase otwórz Bezpieczeństwo Uwierzytelnianie.
  2. Na karcie Metoda logowania włącz dostawcę logowania Telefon.
  3. Ustaw zasady dotyczące regionów, do których chcesz zezwolić na wysyłanie SMS-ów lub im tego zabronić. Ustawienie zasad dotyczących regionu SMS-ów może pomóc w ochronie aplikacji przed nadużyciami związanymi z SMS-ami. W przypadku nowych projektów domyślne zasady nie zezwalają na żadne regiony.
    1. W konsoli Firebase otwórz Zabezpieczenia > Uwierzytelnianie > karta Ustawienia.
    2. W sekcji Zasady dotyczące regionów SMS skonfiguruj zasady dotyczące regionów SMS.

Włączanie weryfikacji aplikacji

Aby korzystać z uwierzytelniania za pomocą numeru telefonu, Firebase musi mieć możliwość sprawdzenia, czy prośby o zalogowanie się za pomocą numeru telefonu pochodzą z Twojej aplikacji. Można to zrobić na 3 sposoby:Firebase Authentication

  • Interfejs Play Integrity API: jeśli użytkownik ma urządzenie z zainstalowanym Google Play services, a Firebase Authentication może zweryfikować urządzenie jako autentyczne za pomocą interfejsu Play Integrity API, logowanie za pomocą numeru telefonu może zostać przeprowadzone. Interfejs Play Integrity API jest włączony w projekcie należącym do Google przez Firebase Authentication, a nie w Twoim projekcie. Nie ma to wpływu na limity interfejsu Play Integrity API w Twoim projekcie. Obsługa interfejsu Play Integrity API jest dostępna w Authenticationpakiecie SDK w wersji 21.2.0 lub nowszej (Firebase BoM w wersji 31.4.0 lub nowszej).

    Aby korzystać z interfejsu Play Integrity API, podaj odcisk cyfrowy SHA-256 aplikacji, jeśli nie zostało to jeszcze zrobione.

    1. W konsoli Firebase otwórz Ustawienia > kartę 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.

    Więcej informacji o tym, jak uzyskać odcisk cyfrowy SHA aplikacji, znajdziesz w sekcji Uwierzytelnianie klienta.

  • Weryfikacja reCAPTCHA: jeśli nie można użyć usługi Play Integrity, np. gdy użytkownik ma urządzenie bez Google Play services zainstalowanej usługi Firebase Authentication, do ukończenia procesu logowania na telefonie używana jest weryfikacja reCAPTCHA. Test reCAPTCHA można często przejść bez rozwiązywania żadnego zadania. Pamiętaj, że ten proces wymaga, aby z aplikacją był powiązany SHA-1. Ten proces wymaga też, aby Twój klucz interfejsu API nie miał ograniczeń lub był na liście dozwolonych dla PROJECT_ID.firebaseapp.com.

    Przykłady sytuacji, w których wywoływana jest reCAPTCHA:

    • Jeśli na urządzeniu użytkownika nie jest zainstalowana aplikacja Google Play services.
    • Jeśli aplikacja nie jest rozpowszechniana w Google Play Store (w Authentication pakiecie SDK w wersji 21.2.0 lub nowszej).
    • Jeśli uzyskany token SafetyNet był nieprawidłowy (w przypadku Authentication wersji pakietu SDK < 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 wartości Google Play Store. W scenariuszach, w których wywoływana jest reCAPTCHA, pole %APP_NAME% jest wypełniane jako PROJECT_ID.firebaseapp.com.

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

Rozwiązywanie problemów

  • Błąd „Missing initial state” 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 zostanie przekierowany na adres URL kreacji zastępczej PROJECT_ID.firebaseapp.com/__/auth/handler. W przeglądarkach Firefox otwieranie linków do aplikacji natywnych jest domyślnie wyłączone. Jeśli w Firefoxie widzisz powyższy błąd, wykonaj czynności opisane w artykule Ustawianie Firefoxa na Androida do otwierania linków w aplikacjach natywnych, aby włączyć otwieranie linków do aplikacji.

Wysyłanie kodu weryfikacyjnego na telefon użytkownika

Aby rozpocząć logowanie za pomocą numeru telefonu, wyświetl użytkownikowi interfejs z prośbą o wpisanie numeru telefonu. Wymagania prawne są różne, ale zgodnie ze sprawdzonymi metodami i aby spełnić oczekiwania użytkowników, należy poinformować ich, że jeśli używają logowania przez telefon, mogą otrzymać SMS-a z prośbą o weryfikację, a w takim przypadku obowiązują standardowe stawki.

Następnie przekaż jego numer telefonu do metody PhoneAuthProvider.verifyPhoneNumber, aby poprosić Firebase o zweryfikowanie numeru telefonu użytkownika. 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 wielokrotnego wejścia: jeśli wywołasz ją kilka razy, np. w metodzie onStart aktywności, metoda verifyPhoneNumber nie wyśle drugiego SMS-a, chyba że pierwotne żądanie przekroczy limit czasu.

Możesz użyć tego działania, aby wznowić proces logowania za pomocą numeru telefonu, jeśli aplikacja zostanie zamknięta, zanim użytkownik zdąży się zalogować (np. gdy użytkownik korzysta z aplikacji do SMS-ów). Po zadzwonieniu pod numer verifyPhoneNumber ustaw flagę, która wskazuje, że weryfikacja jest w toku. Następnie zapisz flagę w metodzie onSaveInstanceState aktywności i przywróć ją w metodzie onRestoreInstanceState. Na koniec w metodzie ActivityonStart sprawdź, czy weryfikacja jest już w toku, a jeśli tak, ponownie wywołaj verifyPhoneNumber. Pamiętaj, aby wyczyścić flagę po zakończeniu lub niepowodzeniu weryfikacji (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, więc w metodach wywołań zwrotnych możesz swobodnie pisać kod przejścia interfejsu.

Wiadomość SMS wysyłana przez Firebase może być też zlokalizowana. Wystarczy, że w instancji Auth określisz język uwierzytelniania za pomocą metody setLanguageCode.

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 funkcji PhoneAuthProvider.verifyPhoneNumber musisz też podać instancję funkcji OnVerificationStateChangedCallbacks, która zawiera implementacje funkcji wywołania zwrotnego obsługujących wyniki żądania. 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 weryfikacji

W większości aplikacji implementujesz 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ć od razu 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 interwencji użytkownika. (Ta funkcja może być niedostępna u niektórych operatorów). W tym celu używany jest 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, a do zalogowania użytkownika możesz użyć obiektu PhoneAuthCredential przekazanego do wywołania zwrotnego.

onVerificationFailed(FirebaseException)

Ta metoda jest wywoływana w odpowiedzi na nieprawidłową prośbę o weryfikację, np. prośbę, która 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. (W tym samym czasie w tle może trwać automatyczna weryfikacja). Następnie, 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ć z wyświetleniem interfejsu kodu weryfikacyjnego do momentu wywołania funkcji onCodeAutoRetrievalTimeOut (niezalecane).

onCodeAutoRetrievalTimeOut(String verificationId)

Opcjonalnie. Ta metoda jest wywoływana po upływie czasu oczekiwania określonego w parametrze verifyPhoneNumber, jeśli wcześniej nie nastąpiło wywołanie parametru 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ą dane wejściowe użytkownika do czasu upłynięcia okresu automatycznej weryfikacji, a dopiero potem wyświetlają interfejs, w którym użytkownik może wpisać kod weryfikacyjny 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 funkcja 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 otrzymaniu obiektu PhoneAuthCredential, niezależnie od tego, czy nastąpiło to w wywołaniu zwrotnym onVerificationCompleted, czy w wyniku wywołania 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ą Firebase konsoli. Testowanie z użyciem fikcyjnych numerów telefonów zapewnia te korzyści:

  • Testuj uwierzytelnianie numeru telefonu bez wykorzystywania limitu użycia.
  • Testowanie uwierzytelniania numeru telefonu bez wysyłania SMS-a.
  • Przeprowadzaj kolejne testy z tym samym numerem telefonu bez ograniczeń. Minimalizuje to ryzyko odrzucenia podczas procesu sprawdzania w sklepie z aplikacjami, jeśli osoba sprawdzająca użyje tego samego numeru telefonu do testowania.
  • Łatwe testowanie w środowiskach deweloperskich bez dodatkowego wysiłku, np. możliwość tworzenia aplikacji w symulatorze iOS lub emulatorze Androida bez Usług Google Play.
  • pisać testy integracyjne bez blokowania przez kontrole bezpieczeństwa, które są zwykle stosowane w przypadku prawdziwych numerów telefonów w środowisku produkcyjnym;

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

  1. Używaj numerów telefonów, które są fikcyjne i nie istnieją. Firebase Authentication nie pozwala ustawiać jako numerów testowych istniejących numerów telefonów używanych przez prawdziwych użytkowników. Jedną z opcji jest użycie numerów z prefiksem 555 jako amerykańskich numerów testowych, np.:+1 650-555-3434
  2. Numery telefonów muszą być poprawnie sformatowane pod względem długości i innych ograniczeń. Będą one podlegać tej samej weryfikacji co numery telefonów prawdziwych użytkowników.
  3. Możesz dodać maksymalnie 10 numerów telefonów do celów deweloperskich.
  4. Używaj numerów telefonów i kodów testowych, 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 Bezpieczeństwo > Uwierzytelnianie.
  2. Na karcie Metoda logowania włącz dostawcę logowania Telefon, jeśli nie jest jeszcze włączony.
  3. Rozwiń sekcję Numery telefonów do testowania.
  4. Podaj numer telefonu, który chcesz przetestować, np. +1 650-555-3434.
  5. Podaj 6-cyfrowy kod weryfikacyjny dla tego numeru, np. 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ć w aplikacji fikcyjnego numeru telefonu. Umożliwia to przeprowadzanie testów ręcznych na etapach rozwoju bez problemów z limitami lub ograniczaniem przepustowości. Możesz też testować bezpośrednio w symulatorze iOS lub emulatorze Androida bez zainstalowanych Usług Google Play.

Gdy podasz fikcyjny numer telefonu i wyślesz kod weryfikacyjny, nie zostanie wysłana żadna wiadomość 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 zachowanie i właściwości jak użytkownik z prawdziwym numerem telefonu i może uzyskiwać dostęp do Realtime Database/Cloud Firestore i innych usług w ten sam sposób. Token identyfikatora wygenerowany w tym procesie ma taki sam podpis jak w przypadku użytkownika z prawdziwym numerem telefonu.

Inną opcją jest ustawienie roli testowej za pomocą niestandardowych roszczeń w przypadku tych użytkowników, aby odróżnić ich od prawdziwych użytkowników, jeśli chcesz dodatkowo ograniczyć dostęp.

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

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

Testy integracji

Oprócz testów ręcznych Firebase Authentication udostępnia interfejsy API, które pomagają pisać testy integracyjne na potrzeby testowania uwierzytelniania telefonicznego. Te interfejsy API wyłączają weryfikację aplikacji, wyłączając wymaganie reCAPTCHA w przypadku powiadomień push w internecie i cichych powiadomień push na iOS. Umożliwia to testowanie automatyzacji w tych procesach i ułatwia jego wdrożenie. Umożliwiają też testowanie procesów natychmiastowej weryfikacji na urządzeniach z Androidem.

Na urządzeniu z Androidem zadzwoń pod numer setAppVerificationDisabledForTesting() przed połączeniem signInWithPhoneNumber. Spowoduje to automatyczne wyłączenie weryfikacji aplikacji, dzięki czemu możesz przejść weryfikację numeru telefonu bez ręcznego rozwiązywania zadania. Nawet jeśli Play Integrity i reCAPTCHA są wyłączone, użycie prawdziwego numeru telefonu nadal nie umożliwi zalogowania 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();

Zadzwonienie pod numer verifyPhoneNumber z fikcyjnego numeru spowoduje wywołanie funkcji zwrotnej onCodeSent, w której 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)

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

Gdy wywoływana jest funkcja verifyPhoneNumber, bezpośrednio wywołuje ona funkcję onVerificationCompleted z parametrem PhoneAuthCredential. Działa to tylko w przypadku fikcyjnych numerów telefonów.

Podczas publikowania aplikacji w Sklepie Google Play upewnij się, że ta funkcja jest wyłączona i w aplikacji nie ma na stałe zakodowanych fikcyjnych numerów telefonów.

Java

// The test phone number and code should be whitelisted in the console.
String phoneNumber = "+16505554567";
String smsCode = "123456";

FirebaseAuth firebaseAuth = FirebaseAuth.getInstance();
FirebaseAuthSettings firebaseAuthSettings = firebaseAuth.getFirebaseAuthSettings();

// Configure faking the auto-retrieval with the whitelisted numbers.
firebaseAuthSettings.setAutoRetrievedSmsCodeForPhoneNumber(phoneNumber, smsCode);

PhoneAuthOptions options = PhoneAuthOptions.newBuilder(firebaseAuth)
        .setPhoneNumber(phoneNumber)
        .setTimeout(60L, TimeUnit.SECONDS)
        .setActivity(this)
        .setCallbacks(new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
            @Override
            public void onVerificationCompleted(@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

Po pierwszym zalogowaniu się użytkownika tworzone jest nowe konto użytkownika, które jest powiązane z danymi logowania, czyli nazwą użytkownika i hasłem, numerem telefonu lub informacjami o dostawcy uwierzytelniania, za pomocą których użytkownik się zalogował. To nowe konto jest przechowywane w ramach projektu w Firebase i może służyć do identyfikowania użytkownika we wszystkich aplikacjach w projekcie, niezależnie od sposobu logowania.

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

  • W Firebase Realtime Database i Cloud Storage regułach bezpieczeństwa możesz pobrać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i użyć go do kontrolowania, do jakich danych użytkownik może mieć dostęp.

Możesz zezwolić użytkownikom na logowanie się w aplikacji za pomocą wielu dostawców uwierzytelniania, łącząc dane logowania dostawcy uwierzytelniania z istniejącym kontem użytkownika.

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

Kotlin

Firebase.auth.signOut()

Java

FirebaseAuth.getInstance().signOut();