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

Do logowania użytkownika możesz użyć usługi 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 widżet logowania typu drop-in. Implementuje on procesy logowania za pomocą numeru telefonu, a także logowania opartego na haśle i logowania federacyjnego. W tym dokumencie opisujemy, jak zaimplementować proces logowania 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 na poziomie modułu (aplikacji) (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle), dodaj zależność od biblioteki Firebase Authentication na Androida. Do kontrolowania obsługi wersji biblioteki zalecamy używanie Firebase Android BoM. 
    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:34.15.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 od bibliotek Firebase bez użycia BoM

    Jeśli nie chcesz używać 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 ich zgodność. 

    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:24.1.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 konsoli Firebase hasha SHA-1 aplikacji, zrób to. Informacje o tym, jak znaleźć hash SHA-1 aplikacji, znajdziesz w artykule Uwierzytelnianie klienta.Firebase

Potencjalne problemy z bezpieczeństwem

Uwierzytelnianie tylko za pomocą numeru telefonu, choć wygodne, jest mniej bezpieczne niż inne dostępne metody, ponieważ posiadanie numeru telefonu można łatwo przenieść na innego użytkownika. 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 za pomocą numeru telefonu urządzenia.

Jeśli w aplikacji używasz logowania za pomocą numeru telefonu, powinna ona oferować też bezpieczniejsze metody logowania. Należy też informować użytkowników o kompromisach w zakresie bezpieczeństwa związanych z używaniem logowania 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ć metodę logowania za pomocą numeru telefonu w projekcie w Firebase:

  1. W konsoli Firebase otwórz Bezpieczeństwo > Uwierzytelnianie.
  2. Na karcie Metoda logowania włącz dostawcę logowania Telefon.
  3. Ustaw zasadę dotyczącą regionów, do których chcesz zezwolić na wysyłanie SMS-ów lub zabronić ich wysyłania. Ustawienie zasady dotyczącej regionów SMS-ów może pomóc w ochronie aplikacji 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ę Bezpieczeństwo > Uwierzytelnianie > Ustawienia.
    2. W sekcji Zasady dotyczące regionów SMS-ów skonfiguruj zasady dotyczące regionów SMS-ów.

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: Firebase Authentication

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

    Aby używać interfejsu Play Integrity API, określ odcisk cyfrowy SHA-256 aplikacji, jeśli nie masz go jeszcze.

    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 Uwierzytelnianie klienta.

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

    Niektóre sytuacje, w których jest wywoływana reCAPTCHA:

    • Jeśli urządzenie użytkownika nie ma zainstalowanych Google Play services.
    • Jeśli aplikacja nie jest rozpowszechniana w Google Play Store (w Authentication SDK w wersji 21.2.0 lub nowszej).
    • Jeśli uzyskany token SafetyNet był nieprawidłowy (w pakiecie Authentication SDK w wersji wcześniejszej niż 21.2.0).

    Gdy do weryfikacji aplikacji używany jest SafetyNet lub interfejs Play Integrity API, pole %APP_NAME% w szablonie SMS-a jest wypełniane nazwą aplikacji określoną w Google Play Store. W sytuacjach, w których jest wywoływana reCAPTCHA, pole %APP_NAME% jest wypełniane wartością PROJECT_ID.firebaseapp.com.

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

Rozwiązywanie problemów

  • Błąd „Missing initial state” (Brak stanu początkowego) podczas używania reCAPTCHA do weryfikacji aplikacji

    Może to wystąpić, 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 adres URL rezerwowy 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, aby otwierał linki 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, który prosi go o wpisanie numeru telefonu. Wymagania prawne różnią się w zależności od kraju, ale jako sprawdzona metoda i aby spełnić oczekiwania użytkowników, należy ich poinformować, że jeśli użyją logowania za pomocą telefonu, mogą otrzymać SMS-a z kodem weryfikacyjnym i że obowiązują standardowe stawki.

Następnie przekaż numer telefonu użytkownika 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 reentrantna. Jeśli wywołasz ją kilka razy, 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 zdąży się zalogować (np. gdy użytkownik korzysta z aplikacji do obsługi SMS-ów). Po wywołaniu verifyPhoneNumber ustaw flagę wskazującą, że weryfikacja jest w toku. Następnie zapisz flagę w metodzie onSaveInstanceState aktywności i przywróć ją w onRestoreInstanceState. Na koniec w metodzie onStart aktywności sprawdź, czy weryfikacja jest już w toku, a jeśli tak, wywołaj ponownie 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, dzięki czemu możesz swobodnie pisać kod przejścia interfejsu w metodach wywołania zwrotnego.

SMS-a wysyłanego 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();

Gdy wywołujesz PhoneAuthProvider.verifyPhoneNumber, musisz też podać instancję 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ż zaimplementować onCodeAutoRetrievalTimeOut.

onVerificationCompleted(PhoneAuthCredential)

Ta metoda jest wywoływana w 2 sytuacjach:

  • Natychmiastowa weryfikacja: w niektórych przypadkach numer telefonu można natychmiast zweryfikować bez konieczności wysyłania lub wpisywania kodu weryfikacyjnego.
  • Automatyczne pobieranie: na niektórych urządzeniach Usługi Google Play mogą automatycznie wykryć przychodzącego SMS-a z kodem weryfikacyjnym i przeprowadzić weryfikację bez interwencji użytkownika. (Ta funkcja może być niedostępna u niektórych operatorów). Używa ona interfejsu SMS Retriever API, który zawiera 11-znakowy hash na końcu SMS-a.
W obu przypadkach numer telefonu użytkownika został pomyślnie 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 określa 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 trwać automatyczna weryfikacja). Następnie, gdy użytkownik wpisze kod weryfikacyjny, możesz użyć kodu weryfikacyjnego i identyfikatora weryfikacji przekazanego do metody, aby utworzyć PhoneAuthCredential obiekt, którego możesz użyć do zalogowania użytkownika. Niektóre aplikacje mogą jednak czekać na wywołanie onCodeAutoRetrievalTimeOut, zanim wyświetlą interfejs kodu weryfikacyjnego (niezalecane).

onCodeAutoRetrievalTimeOut(String verificationId)

Opcjonalnie. Ta metoda jest wywoływana po upływie czasu określonego w verifyPhoneNumber bez wcześniejszego wywołania onVerificationCompleted. Na urządzeniach bez karty SIM ta metoda jest wywoływana natychmiast, ponieważ automatyczne pobieranie SMS-ów jest niemożliwe.

Niektóre aplikacje blokują dane wejściowe użytkownika do czasu upłynięcia limitu czasu automatycznej weryfikacji, a dopiero potem 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 za pomocą 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

Gdy uzyskasz obiekt PhoneAuthCredential, czy to w wywołaniu zwrotnym onVerificationCompleted, czy 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

W konsoli Firebase możesz skonfigurować fikcyjne numery telefonów na potrzeby programowania. Testowanie za pomocą fikcyjnych numerów telefonów ma te zalety:

  • Możesz testować uwierzytelnianie za pomocą numeru telefonu bez wykorzystywania limitu użycia.
  • Możesz testować uwierzytelnianie za pomocą numeru telefonu bez wysyłania rzeczywistego SMS-a.
  • Możesz przeprowadzać kolejne testy z tym samym numerem telefonu bez ograniczania. Zmniejsza to ryzyko odrzucenia podczas sprawdzania aplikacji w sklepie, jeśli recenzent użyje tego samego numeru telefonu do testowania.
  • Możesz łatwo testować w środowiskach programistycznych bez dodatkowego wysiłku, np. programować w symulatorze iOS lub emulatorze Androida bez Usług Google Play.
  • Możesz pisać testy integracji bez blokowania przez kontrole bezpieczeństwa zwykle stosowane w przypadku rzeczywistych 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 ustawiać istniejących numerów telefonów używanych przez prawdziwych użytkowników jako numerów testowych. Możesz na przykład użyć numerów z prefiksem 555 jako amerykańskich testowych numerów telefonów, np.: +1 650-555-3434
  2. Numery telefonów muszą mieć prawidłowy format pod względem długości i innych ograniczeń. Będą one nadal podlegać tej samej weryfikacji co numer telefonu prawdziwego użytkownika.
  3. Na potrzeby programowania możesz dodać maksymalnie 10 numerów telefonów.
  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 Bezpieczeństwo > Uwierzytelnianie.
  2. Na karcie Metoda logowania włącz dostawcę logowania Telefon, jeśli nie masz go jeszcze.
  3. Rozwiń sekcję Numery telefonów na potrzeby 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. W przypadku każdego numeru kliknij Dodaj. 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 bezpośrednio zacząć używać fikcyjnego numeru telefonu w swojej aplikacji. Umożliwia to przeprowadzanie testów ręcznych na etapach programowania bez problemów z limitami i ograniczaniem. Możesz też testować bezpośrednio z symulatora iOS lub emulatora Androida bez zainstalowanych Usług Google Play.

Gdy podasz fikcyjny numer telefonu i wyślesz kod weryfikacyjny, 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 samo zachowanie i właściwości jak prawdziwy użytkownik numeru telefonu i może w ten sam sposób uzyskiwać dostęp do Realtime Database/Cloud Firestore i innych usług. Token identyfikatora wygenerowany podczas tego procesu ma ten sam podpis co token identyfikatora 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 dodatkowo ograniczyć dostęp.

Aby ręcznie wywołać 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 integracji na potrzeby testowania uwierzytelniania telefonicznego. Te interfejsy API wyłączają weryfikację aplikacji, wyłączając wymaganie reCAPTCHA w powiadomieniach push w internecie i powiadomieniach push w iOS. Umożliwia to automatyzację testów w tych procesach i ułatwia ich implementację. Dodatkowo pomagają one testować procesy natychmiastowej weryfikacji na Androidzie.

Na Androidzie wywołaj setAppVerificationDisabledForTesting() przed wywołaniem signInWithPhoneNumber. Spowoduje to automatyczne wyłączenie weryfikacji aplikacji, co pozwoli przekazać numer telefonu bez ręcznego rozwiązywania. Nawet jeśli interfejs Play Integrity API i reCAPTCHA są wyłączone, użycie prawdziwego numeru telefonu nadal nie pozwoli na dokończenie logowania. 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();

Wywołanie verifyPhoneNumber z fikcyjnym numerem 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)

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

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

Podczas publikowania aplikacji w Sklepie Google Play upewnij się, że ta opcja jest wyłączona i że w aplikacji nie ma zakodowanych na stałe 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

Gdy użytkownik zaloguje się po raz pierwszy, zostanie utworzone nowe konto użytkownika i połączone z danymi logowania – 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 w każdej aplikacji w projekcie, niezależnie od sposobu logowania.

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

  • W regułach bezpieczeństwa Firebase Realtime Database i Cloud Storage Security Rules, możesz uzyskać unikalny identyfikator zalogowanego użytkownika z 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 przez połączenie danych logowania dostawcy uwierzytelniania z istniejącym kontem użytkownika.

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

Kotlin

Firebase.auth.signOut()

Java

FirebaseAuth.getInstance().signOut();