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łatwiej dodać logowanie za pomocą numeru telefonu do aplikacji, używając FirebaseUI, które zawiera gotowy widget logowania, który implementuje przepływy logowania za pomocą numeru telefonu, a także logowania na podstawie hasła i logowania sfederowanego. W tym dokumencie opisano, jak za pomocą pakietu SDK Firebase wdrożyć proces logowania za pomocą numeru telefonu.

Zanim zaczniesz

  1. Jeśli jeszcze tego nie zrobiono, dodaj Firebase do projektu 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 wersji biblioteki. 
    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.7.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.

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

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

    Jeśli w aplikacji używasz kilku bibliotek Firebase, zdecydowanie zalecamy korzystanie z BoM do zarządzania wersjami bibliotek. Dzięki temu wszystkie wersje będą ze sobą zgodne. 

    dependencies {
    // Add the dependency for the Firebase Authentication library
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-auth:23.1.0")
}
         Szukasz modułu biblioteki dla Kotlina? Od października 2023 r. (Firebase BoM 32.5.0) deweloperzy Kotlina i Java mogą korzystać z głównego modułu biblioteki (szczegółowe informacje znajdziesz w często zadawanych pytaniach dotyczących tej inicjatywy).
  3. Jeśli nie połączysz jeszcze aplikacji z projektem Firebase, możesz to zrobić w konsoli Firebase.
  4. Jeśli nie masz jeszcze ustawionego hasha SHA-1 aplikacji w konsoli Firebase, zrób to. Informacje o znajdowaniu hasha SHA-1 aplikacji znajdziesz w artykule Uwierzytelnianie klienta.

Potencjalne problemy z bezpieczeństwem

Uwierzytelnianie za pomocą tylko numeru telefonu jest wygodne, ale mniej bezpieczne niż inne dostępne metody, ponieważ numer telefonu można łatwo przekazać innemu użytkownikowi. 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 na podstawie numeru telefonu, powinnaś je oferować razem z bardziej bezpiecznymi metodami logowania i informować użytkowników o konsekwencjach zabezpieczeń związanych z logowaniem na podstawie numeru telefonu.

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

Aby umożliwić użytkownikom logowanie się za pomocą SMS-a, musisz najpierw włączyć metodę logowania za pomocą numeru telefonu w projekcie Firebase:

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

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 się za pomocą numeru telefonu pochodzą z Twojej aplikacji. Firebase Authentication może to zrobić na 3 sposoby:

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

Rozwiązywanie problemów

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

    Może się to zdarzyć, gdy proces reCAPTCHA zostanie zakończony, ale użytkownik nie zostanie przekierowany z powrotem do natywnej aplikacji. W takim przypadku użytkownik jest przekierowywany do adresu URL zapasowego 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 pojawi się powyższy błąd, wykonaj czynności opisane w artykule Konfigurowanie Firefoksa na Androida w celu otwierania linków w własnych aplikacjach, aby umożliwić otwieranie linków 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 podanie numeru telefonu. Wymagania prawne różnią się w zależności od kraju, ale zgodnie ze sprawdzoną metodą i aby określić oczekiwania użytkowników, należy ich poinformować, że jeśli korzystają z logowania przez telefon, mogą otrzymać SMS-a z weryfikacją i że obowiązują standardowe stawki.

Następnie prześlij numer telefonu do metody PhoneAuthProvider.verifyPhoneNumber, aby poprosić Firebase o sprawdzenie 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)
PhoneAuthActivity.kt

Java

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

Metoda verifyPhoneNumber jest rekurencyjna: 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 zachowania, aby wznowić proces logowania za pomocą numeru telefonu, jeśli aplikacja zamknie się, zanim użytkownik uda się zalogować (np. gdy użytkownik używa aplikacji do obsługi SMS-ów). Po wykonaniu połączenia z numerem verifyPhoneNumber ustaw flagę wskazującą, że weryfikacja jest w toku. Następnie zapisz flagę w metodie aktywności onSaveInstanceState i przywróć ją w metodie onRestoreInstanceState. Na koniec sprawdź w sekcji Aktywności metodę onStart, czy weryfikacja jest już w toku. Jeśli tak, ponownie zadzwoń pod numer verifyPhoneNumber. Pamiętaj, aby usunąć flagę po zakończeniu lub niepowodzeniu weryfikacji (patrz funkcje zwrotne weryfikacji).

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

SMS-y wysyłane przez Firebase można też zlokalizować, określając język uwierzytelniania za pomocą metody setLanguageCode w Twoim wystąpieniu Auth.

Kotlin

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

Java

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

Podczas wywołania funkcji 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
    }
}
PhoneAuthActivity.kt

Java

mCallbacks = new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

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

        signInWithPhoneAuthCredential(credential);
    }

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

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

        // Show a message and update the UI
    }

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

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

Wywołania zwrotne weryfikacji

Większość aplikacji implementuje 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:

  • Szybka 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 z weryfikacją i przeprowadzać weryfikację bez udziału użytkownika. (ta funkcja może być niedostępna w przypadku niektórych operatorów). Do tego celu używamy interfejsu SMS Retriever API, który zawiera 11-znakowy ciąg znaków na końcu wiadomości SMS.
W obu przypadkach numer telefonu użytkownika został zweryfikowany, więc możesz użyć obiektu PhoneAuthCredential przekazanego do funkcji wywołania zwrotnego, aby zalogować użytkownika.

onVerificationFailed(FirebaseException)

Ta metoda jest wywoływana w odpowiedzi na nieprawidłowe żądanie weryfikacji, np. żądanie zawierające 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.

Po wywołaniu tej metody większość aplikacji wyświetla interfejs, który prosi użytkownika o wpisanie kodu weryfikacyjnego z SMS-a. (W tym samym czasie może być przeprowadzana 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 poczekać, aż zostanie wywołana funkcja onCodeAutoRetrievalTimeOut, zanim wyświetlą interfejs kodu weryfikacyjnego (nie zalecane).

onCodeAutoRetrievalTimeOut(String verificationId)

Opcjonalnie. Ta metoda jest wywoływana po upływie czasu oczekiwania określonego w , jeśli nie został on wcześniej uruchomiony przez funkcję onVerificationCompleted.verifyPhoneNumber Na urządzeniach bez kart SIM ta metoda jest wywoływana natychmiast, ponieważ automatyczne pobieranie SMS-ów jest niemożliwe.

Niektóre aplikacje blokują wprowadzanie danych przez użytkownika do czasu, gdy upłynie czas automatycznej weryfikacji. Dopiero wtedy wyświetlają interfejs, który prosi o wpisanie kodu weryfikacyjnego z SMS-a (nie zalecane).

Tworzenie obiektu PhoneAuthCredential

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

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

Kotlin

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

Java

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

Logowanie użytkownika

Po otrzymaniu obiektu PhoneAuthCredential (w wywołaniu zwrotnym onVerificationCompleted lub wywołaniu PhoneAuthProvider.getCredential) przeprowadź 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
            }
        }
}
PhoneAuthActivity.kt

Java

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

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

Testowanie z fikcyjnymi numerami telefonów

Na potrzeby programowania możesz skonfigurować fikcyjne numery telefonów w konsoli Firebase. Testowanie z użyciem fikcyjnych numerów telefonów:

  • Testowanie uwierzytelniania numeru telefonu bez zużywania limitu użycia.
  • Testowanie uwierzytelniania numeru telefonu bez wysyłania SMS-a.
  • Przeprowadzanie kolejnych testów z użyciem tego samego numeru telefonu bez ograniczenia przepustowości. Pozwala to zminimalizować ryzyko odrzucenia aplikacji podczas procesu sprawdzania w App Store, jeśli recenzent użyje tego samego numeru telefonu do testowania.
  • testować w środowiskach programistycznych bez dodatkowych wysiłków, takich jak możliwość tworzenia w symulatorze iOS lub emulatorze Androida bez Usług Google Play;
  • pisać testy integracyjne bez blokowania przez zabezpieczenia stosowane zwykle w rzeczywistych środowiskach produkcyjnych;

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

  1. Upewnij się, że używasz numerów telefonów, które są fikcyjne i nie istnieją. Firebase Authentication nie pozwala na ustawienie 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 telefonów testowych w Stanach Zjednoczonych z prefiksem 555, na przykład: +1 650-555-3434
  2. Numery telefonów muszą być sformatowane zgodnie z długością i innymi ograniczeniami. Nadal będą przechodzić przez tę samą weryfikację co numer telefonu rzeczywistego użytkownika.
  3. Możesz dodać maksymalnie 10 numerów telefonów na potrzeby programowania.
  4. Używaj testowych numerów telefonów i kodów, które są trudne do odgadnięcia i często się zmieniają.

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

  1. W konsoli Firebase otwórz sekcję Uwierzytelnianie.
  2. Na karcie Metoda logowania włącz opcję Dostawca telefonu, jeśli nie została jeszcze włączona.
  3. Otwórz menu Numery telefonu 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. Dodaj numer. W razie potrzeby możesz usunąć numer telefonu i kod, najeżdżając na odpowiedni wiersz i klikając ikonę kosza.

Testowanie ręczne

Możesz od razu zacząć używać fikcyjnego numeru telefonu w aplikacji. Dzięki temu możesz przeprowadzać ręczne testy na etapie programowania bez problemów z limitem lub ograniczeniem szybkości. Możesz też przetestować aplikację bezpośrednio na symulatorze iOS lub emulatorze Androida bez instalowania Usług Google Play.

Gdy podasz fikcyjny numer telefonu i wyślesz kod weryfikacyjny, nie wyślemy SMS-a. Aby się zalogować, musisz podać skonfigurowany wcześniej kod weryfikacyjny.

Po zakończeniu logowania tworzymy użytkownika Firebase z tym numerem telefonu. Użytkownik ma takie same właściwości i takie samo zachowanie jak użytkownik z prawdziwym numerem telefonu. Może też w taki sam sposób korzystać z usługi Realtime Database/Cloud Firestore i innych usług. Podczas tego procesu token identyfikacyjny ma to samo podpisywanie, co użytkownik z prawdziwym numerem telefonu.

Inną opcją jest ustawienie roli testowej za pomocą roszczeń niestandardowych 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 wywołać proces reCAPTCHA na potrzeby testowania, użyj metody forceRecaptchaFlowForTesting(). 

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

Testowanie integracji

Oprócz testów ręcznych Firebase Authentication udostępnia interfejsy API, które ułatwiają tworzenie testów integracyjnych na potrzeby testowania uwierzytelniania przez telefon. Te interfejsy API wyłączają weryfikację aplikacji przez wyłączenie wymagań reCAPTCHA w internecie i cichych powiadomień push na iOS. Dzięki temu testowanie automatyzacji jest możliwe w tych procesach i łatwiej je wdrożyć. Dodatkowo umożliwiają testowanie procesów weryfikacji błyskawicznej na urządzeniach z Androidem.

Na Androidzie przed połączeniem signInWithPhoneNumber zadzwoń setAppVerificationDisabledForTesting(). Spowoduje to automatyczne wyłączenie weryfikacji aplikacji, dzięki czemu nie będziesz musiał podawać numeru telefonu ręcznie. Nawet jeśli integralność Google Play i reCAPTCHA są wyłączone, zalogowanie się za pomocą prawdziwego numeru telefonu nie będzie możliwe. 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 powoduje wywołanie onCodeSent, w którym musisz podać odpowiedni kod weryfikacyjny. Umożliwia to testowanie w emulatorze Androida.

Java

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

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

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

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

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

Kotlin

val phoneNum = "+16505554567"
val testVerificationCode = "123456"

// Whenever verification is triggered with the whitelisted number,
// provided it is not set for auto-retrieval, onCodeSent will be triggered.
val options = PhoneAuthOptions.newBuilder(Firebase.auth)
    .setPhoneNumber(phoneNum)
    .setTimeout(30L, TimeUnit.SECONDS)
    .setActivity(this)
    .setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

        override fun onCodeSent(
            verificationId: String,
            forceResendingToken: PhoneAuthProvider.ForceResendingToken,
        ) {
            // Save the verification id somewhere
            // ...

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

        override fun onVerificationCompleted(phoneAuthCredential: PhoneAuthCredential) {
            // Sign in with the credential
            // ...
        }

        override fun onVerificationFailed(e: FirebaseException) {
            // ...
        }
    })
    .build()
PhoneAuthProvider.verifyPhoneNumber(options)
MainActivity.kt

Dodatkowo możesz przetestować proces automatycznego pobierania na Androidzie, ustawiając fikcyjny numer i odpowiadający mu kod weryfikacyjny do automatycznego pobierania, dzwoniąc na numer setAutoRetrievedSmsCodeForPhoneNumber.

Gdy wywołana zostanie funkcja verifyPhoneNumber, spowoduje ona wywołanie funkcji onVerificationCompleted z użyciem argumentu 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 że w aplikacji nie ma 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);
MainActivity.java

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)
MainActivity.kt

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 dostawcy uwierzytelniania, za pomocą których użytkownik się zalogował. To nowe konto jest przechowywane w projekcie Firebase i może służyć do identyfikowania użytkownika we wszystkich aplikacjach w projekcie, niezależnie od tego, jak użytkownik się loguje.

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

  • W regułach Firebase Realtime Database i Cloud Storage Regułach bezpieczeństwa możesz pobrać z zmiennej auth unikalny identyfikator zalogowanego użytkownika i używać go do kontrolowania dostępu użytkownika do danych.

Możesz zezwolić użytkownikom na logowanie się w aplikacji za pomocą danych uwierzytelniających od różnych dostawców, łącząc je z dotychczasowym kontem użytkownika.

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

Kotlin

Firebase.auth.signOut()
MainActivity.kt

Java

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