Join us for Firebase Summit on November 10, 2021. Tune in to learn how Firebase can help you accelerate app development, release with confidence, and scale with ease. Register

Uwierzytelnij się w Firebase na Androidzie za pomocą numeru telefonu

Za pomocą Uwierzytelniania Firebase możesz zalogować się użytkownika, wysyłając wiadomość SMS na jego telefon. Użytkownik loguje się za pomocą kodu jednorazowego zawartego w wiadomości SMS.

Najprostszym sposobem, aby dodać numer telefonu logowania się do aplikacji jest użycie FirebaseUI , który obejmuje drop-in logowania widżet, który implementuje logowania przepływów dla numeru telefonu logowania, jak i opartych na hasłach i stowarzyszonego znak -w. W tym dokumencie opisano, jak zaimplementować proces logowania za pomocą numeru telefonu przy użyciu pakietu Firebase SDK.

Zanim zaczniesz

  1. Jeśli tego nie zrobiłeś, dodaj Firebase do projektu Android .
  2. Korzystanie z Firebase Android Bom , deklarują zależność dla biblioteki Firebase Authentication Android w module (app szczebla) Gradle plik (zazwyczaj app/build.gradle ).

    Jawa

    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:28.4.2')
    
        // Declare the dependency for the Firebase Authentication library
        // When using the BoM, you don't specify versions in Firebase library dependencies
        implementation 'com.google.firebase:firebase-auth'
    }
    

    Korzystając z Firebase Bom Android , aplikacja będzie zawsze używać kompatybilne wersje bibliotek Firebase Android.

    (Alternatywna) Stwierdzenie Firebase zależności biblioteki bez użycia BOM

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

    Należy pamiętać, że w przypadku korzystania z wielu bibliotek Firebase w swojej aplikacji, zalecamy korzystania z BOM do zarządzania wersjami biblioteki, co gwarantuje, że wszystkie wersje są kompatybilne.

    dependencies {
        // Declare 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:21.0.1'
    }
    

    Kotlin+KTX

    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:28.4.2')
    
        // Declare 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-ktx'
    }
    

    Korzystając z Firebase Bom Android , aplikacja będzie zawsze używać kompatybilne wersje bibliotek Firebase Android.

    (Alternatywna) Stwierdzenie Firebase zależności biblioteki bez użycia BOM

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

    Należy pamiętać, że w przypadku korzystania z wielu bibliotek Firebase w swojej aplikacji, zalecamy korzystania z BOM do zarządzania wersjami biblioteki, co gwarantuje, że wszystkie wersje są kompatybilne.

    dependencies {
        // Declare 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-ktx:21.0.1'
    }
    
  3. Jeśli nie zostały jeszcze podłączone swoją aplikację do projektu Firebase, zrobić z konsoli Firebase .
  4. Jeśli nie masz już ustawione swojej aplikacji skrótu SHA-1 w konsoli Firebase , należy to zrobić. Zobacz Uwierzytelnianie Twój klient do informacji o znalezieniu swojej aplikacji skrótu SHA-1.

Obawy dotyczące bezpieczeństwa

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

Jeśli korzystasz z logowania na podstawie numeru telefonu w swojej aplikacji, powinieneś oferować go wraz z bezpieczniejszymi metodami logowania i informować użytkowników o kompromisach związanych z bezpieczeństwem korzystania z logowania za pomocą numeru telefonu.

Włącz logowanie za pomocą numeru telefonu w projekcie Firebase

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

  1. W konsoli Firebase otwórz sekcję uwierzytelniania.
  2. Na stronie logowania w metodzie, należy włączyć logowania metodą numer telefonu.

Limit żądań logowania za pomocą numeru telefonu Firebase jest na tyle wysoki, że nie ma to wpływu na większość aplikacji. Jeśli jednak musisz zalogować bardzo dużą liczbę użytkowników za pomocą uwierzytelniania telefonicznego, może być konieczne uaktualnienie planu cenowego. Zobacz cenową stronę.

Włącz weryfikację aplikacji

Aby korzystać z uwierzytelniania za pomocą numeru telefonu, Firebase musi mieć możliwość sprawdzenia, czy żądania logowania za pomocą numeru telefonu pochodzą z Twojej aplikacji. Uwierzytelnianie Firebase realizuje to na dwa sposoby:

  • SafetyNet: Jeśli użytkownik posiada urządzenie z usługi Google Play zainstalowaną i uwierzytelniania Firebase może zweryfikować urządzenie jako uzasadnione z Android SafetyNet , numer telefonu logowania może być kontynuowana.
  • Aby włączyć SafetyNet do użytku z Uwierzytelnianiem Firebase:

    1. W konsoli Google Cloud, umożliwiają API Android DeviceCheck dla danego projektu. Zostanie użyty domyślny klucz Firebase API, który musi mieć dostęp do interfejsu DeviceCheck API.
    2. Jeśli nie zostały jeszcze określone swojej aplikacji odcisk palca SHA-256, zrób to od ustawień strony konsoli Firebase. Patrz Uwierzytelnianie Twojego klienta o sposobach na zdobycie aplikacji odcisk palca SHA-256.
  • weryfikacja Odśwież: W przypadku SafetyNet nie może być używany, na przykład, gdy użytkownik nie posiada zabaw Usługi Google wspierać, lub podczas testowania aplikacji na emulatorze, uwierzytelnianie Firebase używa weryfikacji reCAPTCHA aby zakończyć logowania przepływu telefonu. Wyzwanie reCAPTCHA często można ukończyć bez konieczności rozwiązywania jakichkolwiek problemów przez użytkownika. Pamiętaj, że ten przepływ wymaga, aby z Twoją aplikacją był powiązany SHA-1.

Wyślij kod weryfikacyjny na telefon użytkownika

Aby zainicjować logowanie za pomocą numeru telefonu, zaprezentuj użytkownikowi interfejs z monitem o wpisanie numeru telefonu. Wymagania prawne są różne, ale najlepszym rozwiązaniem i określeniem oczekiwań wobec użytkowników jest poinformowanie ich, że jeśli korzystają z logowania przez telefon, mogą otrzymać wiadomość SMS w celu weryfikacji i obowiązują standardowe stawki.

Następnie przechodzą swój numer telefonu do PhoneAuthProvider.verifyPhoneNumber metody do wniosku, że Firebase weryfikacji numeru telefonu użytkownika. Na przykład:

Jawa

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

Kotlin+KTX

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

verifyPhoneNumber metoda jest reentrant: jeśli nazwać to wiele razy, tak jak w działalności za onStart metodzie verifyPhoneNumber metoda nie wyśle SMS drugiego, chyba że oryginalna prośba wygasła.

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ć (na przykład, gdy użytkownik korzysta z aplikacji do obsługi SMS-ów). Po wywołaniu verifyPhoneNumber , ustawić flagę wskazującą, weryfikacja jest w toku. Następnie zapisz flagę w Twojej aktywności za onSaveInstanceState metody i przywrócić flagę w onRestoreInstanceState . Wreszcie w swoją aktywność w onStart metody, sprawdź czy weryfikacja jest już w toku, a jeśli tak, zadzwoń verifyPhoneNumber ponownie. Pamiętaj, aby usunąć flagę podczas weryfikacji finalizuje lub nie (patrz callbacków weryfikacji ).

Aby łatwo obsługiwać obracania ekranu i innych wystąpień uruchomieniu działalności, przekazać swoją działalność do verifyPhoneNumber metody. Wywołania zwrotne zostaną automatycznie odłączone po zatrzymaniu działania, dzięki czemu możesz swobodnie pisać kod przejścia interfejsu użytkownika w metodach wywołania zwrotnego.

Wiadomość SMS wysłana przez Firebase mogą być także lokalizowane poprzez określenie języka auth poprzez setLanguageCode metody na instancji Auth.

Jawa

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

Kotlin+KTX

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

Podczas rozmowy telefonicznej PhoneAuthProvider.verifyPhoneNumber , należy również zapewnić wystąpienie OnVerificationStateChangedCallbacks , która zawiera implementacje funkcji zwrotnych, które zajmują wyniki życzenie. Na przykład:

Jawa

mCallbacks = new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

    @Override
    public void onVerificationCompleted(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(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
        }

        // 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;
    }
};

Kotlin+KTX

callbacks = object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

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

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

        if (e is FirebaseAuthInvalidCredentialsException) {
            // Invalid request
        } else if (e is FirebaseTooManyRequestsException) {
            // The SMS quota for the project has been exceeded
        }

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

Weryfikacja połączeń zwrotnych

W większości aplikacji, należy wdrożyć onVerificationCompleted , onVerificationFailed i onCodeSent zwrotnych. Można również wdrożyć onCodeAutoRetrievalTimeOut , w zależności od wymogów swojej aplikacji.

Ukończono weryfikację po weryfikacji (poświadczenia PhoneAuth)

Ta metoda jest wywoływana w dwóch sytuacjach:

  • Natychmiastowa weryfikacja: w niektórych przypadkach numer telefonu można natychmiast zweryfikować bez konieczności wysyłania lub wprowadzania kodu weryfikacyjnego.
  • Automatyczne pobieranie: na niektórych urządzeniach usługi Google Play mogą automatycznie wykrywać przychodzące weryfikacyjne wiadomości SMS i przeprowadzać weryfikację bez działania użytkownika. (Możliwość ta może być dostępna z kilkoma nośnikami.) Używa API SMS Retriever , który zawiera mieszania 11 znaków na końcu wiadomości SMS.
W obu przypadkach, numer telefonu autora został zweryfikowany pomyślnie, można użyć PhoneAuthCredential obiekt, który jest przekazywany do wywołania zwrotnego, aby zalogować się użytkownik .

onVerificationFailed(FirebaseException)

Ta metoda jest wywoływana w odpowiedzi na nieprawidłowe żądanie weryfikacji, takie jak żądanie określające nieprawidłowy numer telefonu lub kod weryfikacyjny.

onCodeSent (Id weryfikacji ciągu, PhoneAuthProvider.ForceResendingToken)

Opcjonalny. 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 użytkownika, który prosi użytkownika o wpisanie kodu weryfikacyjnego z wiadomości SMS. (W tym samym czasie, auto może być prowadzona weryfikacja przebiega w tle). Następnie, po użytkownik wpisze kod weryfikacyjny, można użyć kodu weryfikacyjnego oraz identyfikator weryfikacyjny, który został przekazany do metody stworzyć PhoneAuthCredential przedmiot, który możesz z kolei użyć do zalogowania użytkownika. Jednak niektóre aplikacje mogą czekać aż onCodeAutoRetrievalTimeOut nazywa się przed wyświetleniem UI kod weryfikacyjny (nie zalecane).

onCodeAutoRetrievalTimeOut(Id weryfikacji ciągu)

Opcjonalny. Metoda ta nazywana jest po czas określony limit czasu na verifyPhoneNumber przeszedł bez onVerificationCompleted wyzwalanie pierwszy. 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ą wprowadzanie danych przez użytkownika do czasu upływu czasu automatycznej weryfikacji, a dopiero potem wyświetlają interfejs użytkownika, który prosi użytkownika o wpisanie kodu weryfikacyjnego z wiadomości SMS (niezalecane).

Utwórz obiekt PhoneAuthCredential

Gdy użytkownik wprowadza kod weryfikacyjny, który Firebase wysłana do użytkownika telefonu, należy utworzyć PhoneAuthCredential obiektu, przy użyciu kodu weryfikacyjnego oraz identyfikator weryfikacyjny, który został przekazany do onCodeSent lub onCodeAutoRetrievalTimeOut zwrotnego. (Gdy onVerificationCompleted nazywa, masz PhoneAuthCredential obiektu bezpośrednio, więc można pominąć ten krok).

Aby utworzyć PhoneAuthCredential obiekt, zadzwoń PhoneAuthProvider.getCredential :

Jawa

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

Kotlin+KTX

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

Zaloguj się użytkownika

Po dostać PhoneAuthCredential obiektu, czy w onVerificationCompleted zwrotnego lub dzwoniąc PhoneAuthProvider.getCredential , wypełnij logowania przepływu przez przepuszczenie PhoneAuthCredential obiekt do FirebaseAuth.signInWithCredential :

Jawa

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
                        }
                    }
                }
            });
}

Kotlin+KTX

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

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

Testuj z fikcyjnymi numerami telefonów

Za pomocą konsoli Firebase możesz skonfigurować fikcyjne numery telefonów do programowania. Testowanie z fikcyjnymi numerami telefonów zapewnia następujące korzyści:

  • Przetestuj uwierzytelnianie numeru telefonu bez zużywania limitu użycia.
  • Przetestuj uwierzytelnianie numeru telefonu bez wysyłania wiadomości SMS.
  • Przeprowadzaj kolejne testy z tym samym numerem telefonu bez dławienia. Minimalizuje to ryzyko odrzucenia podczas procesu recenzji App Store, jeśli recenzent użyje tego samego numeru telefonu do testów.
  • Łatwe testowanie w środowiskach programistycznych bez dodatkowego wysiłku, na przykład możliwość programowania w symulatorze systemu iOS lub emulatorze systemu Android bez usług Google Play.
  • Twórz testy integracyjne bez blokowania przez kontrole bezpieczeństwa stosowane zwykle w przypadku 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 jeszcze nie istnieją. Uwierzytelnianie Firebase 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 555 prefiksem numery jak numery telefonów Test USA, na przykład: +1 650-555-3434
  2. Numery telefonów muszą być poprawnie sformatowane pod kątem długości i innych ograniczeń. Będą nadal przechodzić tę samą weryfikację, co numer telefonu prawdziwego użytkownika.
  3. Możesz dodać maksymalnie 10 numerów telefonów do rozwoju.
  4. Używaj testowych numerów/kodów telefonów, które są trudne do odgadnięcia i często je zmieniaj.

Twórz fikcyjne numery telefonów i kody weryfikacyjne

  1. W konsoli Firebase otwórz sekcję uwierzytelniania.
  2. W Znaku w zakładce metodzie umożliwienia usługodawcy telefonu, jeśli nie masz.
  3. Otwórz numery telefonów do testowania menu akordeon.
  4. Podać numer telefonu, który ma na celu sprawdzenie, na przykład: +1 650-555-3434.
  5. Zapewnienie 6-cyfrowy kod dla tej określonej ilości, na przykład: 654321.
  6. Dodaj numer. W razie potrzeby możesz usunąć numer telefonu i jego kod, najeżdżając kursorem na odpowiedni wiersz i klikając ikonę kosza.

Testowanie ręczne

Możesz bezpośrednio zacząć używać fikcyjnego numeru telefonu w swojej aplikacji. Pozwala to na wykonywanie testów ręcznych na etapach opracowywania bez problemów z przydziałem lub ograniczaniem przepustowości. Możesz także 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, rzeczywisty SMS nie zostanie wysłany. Zamiast tego musisz podać wcześniej skonfigurowany kod weryfikacyjny, aby zakończyć logowanie.

Po zakończeniu logowania zostanie utworzony użytkownik Firebase z tym numerem telefonu. Użytkownik zachowuje się tak samo i ma takie same właściwości jak użytkownik z prawdziwym numerem telefonu i może w ten sam sposób uzyskiwać dostęp do Bazy danych czasu rzeczywistego/Cloud Firestore i innych usług. Token ID wybity podczas tego procesu ma taki sam podpis jak użytkownik z prawdziwym numerem telefonu.

Innym rozwiązaniem jest ustawienie roli testowego poprzez niestandardowe roszczenia dotyczące tych użytkowników, aby odróżnić je jako użytkowników fałszywych jeśli chcesz dodatkowo ograniczyć dostęp.

Aby ręcznie wyzwolić reCAPTCHA przepływu dla sprawdzenia, użyć forceRecaptchaFlowForTesting() sposobu.

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

Testy integracyjne

Oprócz testów ręcznych Uwierzytelnianie Firebase udostępnia interfejsy API ułatwiające pisanie testów integracji na potrzeby testowania uwierzytelniania telefonicznego. Te interfejsy API wyłączają weryfikację aplikacji, wyłączając wymaganie reCAPTCHA w Internecie i ciche powiadomienia push w iOS. Dzięki temu testowanie automatyzacji w tych przepływach jest możliwe i łatwiejsze do wdrożenia. Ponadto zapewniają możliwość testowania przepływów natychmiastowej weryfikacji w systemie Android.

Na Androidzie wezwanie setAppVerificationDisabledForTesting() przed signInWithPhoneNumber rozmowy. Wyłącza to automatycznie weryfikację aplikacji, umożliwiając przekazanie numeru telefonu bez ręcznego rozwiązywania go. Pamiętaj, że nawet jeśli reCAPTCHA i/lub SafetyNet są wyłączone, użycie prawdziwego numeru telefonu nie zakończy się logowaniem. W tym interfejsie 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 numerem fikcyjnej wyzwala onCodeSent zwrotnego, w którym będziesz musiał podać odpowiedni kod weryfikacyjny. Pozwala to na testowanie w emulatorach Androida.

Jawa

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(String verificationId,
                                   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(PhoneAuthCredential phoneAuthCredential) {
                // Sign in with the credential
                // ...
            }

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

Kotlin+KTX

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

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

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

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

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

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

Dodatkowo, można przetestować auto-odzyskiwanie przepływy w Androidzie, ustawiając liczbę fikcyjną i odpowiadający mu kod weryfikacyjny do automatycznego pobierania dzwoniąc setAutoRetrievedSmsCodeForPhoneNumber .

Kiedy verifyPhoneNumber nazywa, to wyzwala onVerificationCompleted z PhoneAuthCredential bezpośrednio. Działa to tylko z fikcyjnymi numerami telefonów.

Upewnij się, że ta opcja jest wyłączona i że podczas publikowania aplikacji w sklepie Google Play w Twojej aplikacji nie są zakodowane żadne fikcyjne numery telefonów.

Jawa

// 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(PhoneAuthCredential credential) {
                // Instant verification is applied and a credential is directly returned.
                // ...
            }

            // ...
        })
        .build();
PhoneAuthProvider.verifyPhoneNumber(options);

Kotlin+KTX

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

val firebaseAuth = Firebase.auth
val firebaseAuthSettings = firebaseAuth.firebaseAuthSettings

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

val options = PhoneAuthOptions.newBuilder(firebaseAuth)
        .setPhoneNumber(phoneNumber)
        .setTimeout(60L, TimeUnit.SECONDS)
        .setActivity(this)
        .setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
            override fun onVerificationCompleted(credential: PhoneAuthCredential) {
                // Instant verification is applied and a credential is directly returned.
                // ...
            }

            // ...
        })
        .build()
PhoneAuthProvider.verifyPhoneNumber(options)

Następne kroki

Gdy użytkownik zaloguje się po raz pierwszy, zostanie utworzone nowe konto użytkownika i połączone z poświadczeniami — czyli nazwą użytkownika i hasłem, numerem telefonu lub informacjami o dostawcy uwierzytelniania — przy użyciu których użytkownik się zalogował. To nowe konto jest przechowywane jako część projektu Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w projekcie, niezależnie od tego, jak się on loguje.

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

  • W bazie danych Firebase Realtime i Cloud Storage zasad bezpieczeństwa , można uzyskać podpisanego w unikalnym identyfikatorem użytkownika użytkownika z auth zmiennej i użyć go do kontroli, jakie dane dostępu może użytkownik.

Można zezwolić użytkownikom na logowanie się do aplikacji przy użyciu wielu dostawców uwierzytelniania przez łączenie auth poświadczenia dostawcy do istniejącego konta użytkownika.

Aby wylogować użytkownika, zadzwoń signOut :

Jawa

FirebaseAuth.getInstance().signOut();

Kotlin+KTX

Firebase.auth.signOut()