Authentifizieren Sie sich mit Firebase unter Android unter Verwendung einer Telefonnummer

Sie können die Firebase-Authentifizierung verwenden, um einen Benutzer anzumelden, indem Sie eine SMS-Nachricht an das Telefon des Benutzers senden. Der Benutzer meldet sich mit einem in der SMS-Nachricht enthaltenen Einmalcode an.

Der einfachste Weg, Ihrer App eine Telefonnummernanmeldung hinzuzufügen, ist die Verwendung von FirebaseUI , das ein Drop-In-Anmelde-Widget enthält, das Anmeldeflüsse für die Telefonnummernanmeldung sowie kennwortbasierte und Verbundanmeldungen implementiert -im. In diesem Dokument wird beschrieben, wie Sie einen Anmeldefluss für Telefonnummern mithilfe des Firebase SDK implementieren.

Bevor Sie beginnen

1. Wenn Sie dies noch nicht getan haben, fügen Sie Firebase zu Ihrem Android-Projekt hinzu .
2. Deklarieren Sie mithilfe der Firebase Android BoM die Abhängigkeit für die Firebase Authentication Android-Bibliothek in der Gradle-Datei Ihres Moduls (App-Ebene) (normalerweise app/build.gradle ).

   Java

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

   Bei Verwendung der Firebase Android BoM verwendet Ihre App immer kompatible Versionen der Firebase Android-Bibliotheken.

   (Alternative) Deklarieren Sie Firebase-Bibliotheksabhängigkeiten ohne Verwendung der Stückliste

   Wenn Sie die Firebase-Stückliste nicht verwenden möchten, müssen Sie jede Firebase-Bibliotheksversion in ihrer Abhängigkeitszeile angeben.

   Beachten Sie, dass wir bei Verwendung mehrerer Firebase-Bibliotheken in Ihrer App die Verwendung der Stückliste zum Verwalten von Bibliotheksversionen dringend empfehlen, um sicherzustellen, dass alle Versionen kompatibel sind.

   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:20.0.1'
   }
   

   Kotlin + KTX

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

   Bei Verwendung der Firebase Android BoM verwendet Ihre App immer kompatible Versionen der Firebase Android-Bibliotheken.

   (Alternative) Deklarieren Sie Firebase-Bibliotheksabhängigkeiten, ohne die Stückliste zu verwenden

   Wenn Sie die Firebase-Stückliste nicht verwenden möchten, müssen Sie jede Firebase-Bibliotheksversion in ihrer Abhängigkeitszeile angeben.

   Beachten Sie, dass wir bei Verwendung mehrerer Firebase-Bibliotheken in Ihrer App die Verwendung der Stückliste zum Verwalten von Bibliotheksversionen dringend empfehlen, um sicherzustellen, dass alle Versionen kompatibel sind.

   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:20.0.1'
   }
   

3. Wenn Sie Ihre App noch nicht mit Ihrem Firebase-Projekt verbunden haben, tun Sie dies über die Firebase-Konsole .
4. Wenn Sie den SHA-1-Hash Ihrer App noch nicht in der Firebase-Konsole festgelegt haben , tun Sie dies. Informationen zum Ermitteln des SHA-1-Hashs Ihrer App finden Sie unter Authentifizieren Ihres Clients .

Sicherheitsbedenken

Die Authentifizierung nur mit einer Telefonnummer ist zwar praktisch, aber weniger sicher als die anderen verfügbaren Methoden, da der Besitz einer Telefonnummer leicht zwischen Benutzern übertragen werden kann. Auf Geräten mit mehreren Benutzerprofilen kann sich jeder Benutzer, der SMS-Nachrichten empfangen kann, unter Verwendung der Telefonnummer des Geräts bei einem Konto anmelden.

Wenn Sie in Ihrer App eine auf Telefonnummern basierende Anmeldung verwenden, sollten Sie diese zusammen mit sichereren Anmeldemethoden anbieten und die Benutzer über die Sicherheitsmängel bei der Verwendung der Telefonnummernanmeldung informieren.

Aktivieren Sie die Anmeldung zur Telefonnummer für Ihr Firebase-Projekt

Um Benutzer per SMS anzumelden, müssen Sie zuerst die Anmeldemethode für die Telefonnummer für Ihr Firebase-Projekt aktivieren:

1. Öffnen Sie in der Firebase-Konsole den Abschnitt Authentifizierung .
2. Auf der Sign-in - Methode Seite, aktivieren Sie die Telefonnummer Anmelde-Verfahren.

Das Anmeldeanforderungskontingent für die Telefonnummer von Firebase ist hoch genug, damit die meisten Apps nicht betroffen sind. Wenn Sie jedoch eine sehr große Anzahl von Benutzern mit Telefonauthentifizierung anmelden müssen, müssen Sie möglicherweise Ihren Preisplan aktualisieren. Siehe die Preisseite .

Aktivieren Sie die App-Überprüfung

Um die Authentifizierung von Telefonnummern verwenden zu können, muss Firebase in der Lage sein, zu überprüfen, ob Anmeldeanforderungen für Telefonnummern von Ihrer App kommen. Es gibt zwei Möglichkeiten, wie die Firebase-Authentifizierung dies erreicht:

• SafetyNet : Wenn auf einem Benutzer ein Gerät mit Google Play Services installiert ist und die Firebase-Authentifizierung das Gerät mit Android SafetyNet als legitim überprüfen kann, kann die Anmeldung zur Telefonnummer fortgesetzt werden .

So aktivieren Sie SafetyNet für die Verwendung mit der Firebase-Authentifizierung:

1. Aktivieren Sie in der Google Cloud Console die Android DeviceCheck-API für Ihr Projekt. Der Standard-Firebase-API-Schlüssel wird verwendet und muss Zugriff auf die DeviceCheck-API haben.
2. Wenn Sie den SHA-256-Fingerabdruck Ihrer App noch nicht angegeben haben, tun Sie dies auf der Einstellungsseite der Firebase-Konsole. Weitere Informationen zum Abrufen des SHA-256-Fingerabdrucks Ihrer App finden Sie unter Authentifizieren Ihres Kunden .
• reCAPTCHA-Überprüfung : Falls SafetyNet nicht verwendet werden kann, z. B. wenn der Benutzer keine Unterstützung für Google Play Services hat oder wenn Sie Ihre App auf einem Emulator testen, verwendet die Firebase-Authentifizierung eine reCAPTCHA-Überprüfung, um den Anmeldefluss des Telefons abzuschließen. Die reCAPTCHA-Herausforderung kann häufig abgeschlossen werden, ohne dass der Benutzer etwas lösen muss. Bitte beachten Sie, dass für diesen Ablauf ein SHA-1 erforderlich ist, der Ihrer Anwendung zugeordnet ist.

Senden Sie einen Bestätigungscode an das Telefon des Benutzers

Um die Anmeldung der Telefonnummer zu initiieren, präsentieren Sie dem Benutzer eine Benutzeroberfläche, in der er aufgefordert wird, seine Telefonnummer einzugeben. Die gesetzlichen Anforderungen variieren, aber als bewährte Methode und um die Erwartungen Ihrer Benutzer festzulegen, sollten Sie sie darüber informieren, dass sie bei Verwendung der Telefonanmeldung möglicherweise eine SMS-Nachricht zur Überprüfung erhalten und Standardtarife gelten.

PhoneAuthProvider.verifyPhoneNumber dann ihre Telefonnummer an die PhoneAuthProvider.verifyPhoneNumber Methode, um Firebase PhoneAuthProvider.verifyPhoneNumber , die Telefonnummer des Benutzers zu überprüfen. Zum Beispiel:

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);     
PhoneAuthActivity.java

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

Die verifyPhoneNumber Methode ist wiedereintrittsfähig: Wenn Sie sie mehrmals aufrufen, z. B. in der onStart Methode einer Aktivität, onStart die verifyPhoneNumber Methode keine zweite SMS, es sei denn, die ursprüngliche Anforderung ist abgelaufen.

Sie können dieses Verhalten verwenden, um den Anmeldevorgang für die Telefonnummer fortzusetzen, wenn Ihre App geschlossen wird, bevor sich der Benutzer anmelden kann (z. B. während der Benutzer seine SMS-App verwendet). verifyPhoneNumber Sie nach dem Aufruf von verifyPhoneNumber ein Flag, das angibt, dass die Überprüfung ausgeführt wird. Speichern Sie dann das Flag in der onSaveInstanceState Methode Ihrer Aktivität und stellen Sie das Flag in onRestoreInstanceState . Überprüfen Sie onStart in der onStart Methode Ihrer Aktivität, ob die Überprüfung bereits ausgeführt wird, und rufen Sie in diesem verifyPhoneNumber erneut verifyPhoneNumber auf. Stellen Sie sicher, dass das Flag gelöscht ist, wenn die Überprüfung abgeschlossen ist oder fehlschlägt (siehe Überprüfungsrückrufe ).

verifyPhoneNumber Ihre Aktivität an die verifyPhoneNumber Methode, um die Bildschirmrotation und andere Instanzen von Aktivitätsneustarts einfach zu handhaben. Die Rückrufe werden automatisch getrennt, wenn die Aktivität beendet wird, sodass Sie in den Rückrufmethoden frei UI-Übergangscode schreiben können.

Die von Firebase gesendete SMS-Nachricht kann auch lokalisiert werden, indem die setLanguageCode über die setLanguageCode Methode in Ihrer Auth-Instanz angegeben wird.

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

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

Wenn Sie PhoneAuthProvider.verifyPhoneNumber , müssen Sie auch eine Instanz von OnVerificationStateChangedCallbacks , die Implementierungen der Rückruffunktionen enthält, die die Ergebnisse der Anforderung verarbeiten. Zum Beispiel:

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;

        // ...
    }
};
PhoneAuthActivity.java

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

        // ...
    }
}
PhoneAuthActivity.kt

Rückrufe zur Überprüfung

In den meisten Apps implementieren Sie die onVerificationCompleted , onVerificationFailed und onCodeSent . Abhängig von den Anforderungen Ihrer App können Sie auch onCodeAutoRetrievalTimeOut implementieren.

onVerificationCompleted (PhoneAuthCredential)

Diese Methode wird in zwei Situationen aufgerufen:

• Sofortige Überprüfung: In einigen Fällen kann die Telefonnummer sofort überprüft werden, ohne dass ein Bestätigungscode gesendet oder eingegeben werden muss.
• Automatischer Abruf: Auf einigen Geräten können Google Play-Dienste die eingehende Bestätigungs-SMS automatisch erkennen und die Überprüfung ohne Benutzeraktion durchführen. (Diese Funktion ist bei einigen Anbietern möglicherweise nicht verfügbar.)

onVerificationFailed (FirebaseException)

Diese Methode wird als Antwort auf eine ungültige Überprüfungsanforderung aufgerufen, z. B. eine Anforderung, die eine ungültige Telefonnummer oder einen ungültigen Bestätigungscode angibt.

onCodeSent (String verificationId, PhoneAuthProvider.ForceResendingToken)

Optional. Diese Methode wird aufgerufen, nachdem der Bestätigungscode per SMS an die angegebene Telefonnummer gesendet wurde.

Wenn diese Methode aufgerufen wird, zeigen die meisten Apps eine Benutzeroberfläche an, die den Benutzer auffordert, den Bestätigungscode aus der SMS-Nachricht einzugeben. (Gleichzeitig wird die automatische Überprüfung möglicherweise im Hintergrund ausgeführt.) Nachdem der Benutzer den Bestätigungscode eingegeben hat, können Sie den Bestätigungscode und die Bestätigungs-ID, die an die Methode übergeben wurden, verwenden, um ein PhoneAuthCredential Objekt zu erstellen Sie können wiederum verwenden, um den Benutzer anzumelden. Einige Apps warten jedoch möglicherweise, bis onCodeAutoRetrievalTimeOut aufgerufen wird, bevor sie die Benutzeroberfläche des Bestätigungscodes anzeigen (nicht empfohlen).

onCodeAutoRetrievalTimeOut (String verificationId)

Optional. Diese Methode wird aufgerufen, nachdem die angegebene Zeitüberschreitungsdauer für verifyPhoneNumber verstrichen ist, ohne dass zuvor onVerificationCompleted ausgelöst wurde. Auf Geräten ohne SIM-Karte wird diese Methode sofort aufgerufen, da das automatische Abrufen von SMS nicht möglich ist.

Einige Apps blockieren Benutzereingaben, bis der Zeitraum für die automatische Überprüfung abgelaufen ist, und zeigen erst dann eine Benutzeroberfläche an, die den Benutzer auffordert, den Bestätigungscode aus der SMS-Nachricht einzugeben (nicht empfohlen).

Erstellen Sie ein PhoneAuthCredential-Objekt

Nachdem der Benutzer den Bestätigungscode PhoneAuthCredential , den Firebase an das Telefon des Benutzers gesendet hat, erstellen Sie ein PhoneAuthCredential Objekt unter Verwendung des Bestätigungscodes und der Bestätigungs-ID, die an den Rückruf onCodeSent oder onCodeAutoRetrievalTimeOut . (Wenn onVerificationCompleted aufgerufen wird, erhalten Sie direkt ein PhoneAuthCredential Objekt, sodass Sie diesen Schritt überspringen können.)

Rufen Sie PhoneAuthProvider.getCredential auf, um das PhoneAuthCredential Objekt zu PhoneAuthProvider.getCredential :

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

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

Melden Sie sich beim Benutzer an

Nachdem Sie ein PhoneAuthCredential Objekt erhalten haben, sei es im Rückruf onVerificationCompleted oder durch Aufrufen von PhoneAuthProvider.getCredential , schließen Sie den PhoneAuthProvider.getCredential , indem Sie das PhoneAuthCredential Objekt an FirebaseAuth.signInWithCredential :

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();
                        // ...
                    } 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

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
                    }
                }
            }
}
PhoneAuthActivity.kt

Testen Sie mit fiktiven Telefonnummern

Über die Firebase-Konsole können Sie fiktive Telefonnummern für die Entwicklung einrichten. Das Testen mit fiktiven Telefonnummern bietet folgende Vorteile:

• Testen Sie die Authentifizierung von Telefonnummern, ohne Ihr Nutzungskontingent zu verbrauchen.
• Testen Sie die Authentifizierung der Telefonnummer, ohne eine tatsächliche SMS-Nachricht zu senden.
• Führen Sie aufeinanderfolgende Tests mit derselben Telefonnummer durch, ohne gedrosselt zu werden. Dies minimiert das Risiko einer Ablehnung während des App Store-Überprüfungsprozesses, wenn der Prüfer zufällig dieselbe Telefonnummer zum Testen verwendet.
• Testen Sie problemlos in Entwicklungsumgebungen ohne zusätzlichen Aufwand, z. B. in einem iOS-Simulator oder einem Android-Emulator ohne Google Play Services.
• Schreiben Sie Integrationstests, ohne durch Sicherheitsüberprüfungen blockiert zu werden, die normalerweise auf reale Telefonnummern in einer Produktionsumgebung angewendet werden.

Fiktive Telefonnummern müssen folgende Anforderungen erfüllen:

1. Stellen Sie sicher, dass Sie Telefonnummern verwenden, die tatsächlich fiktiv sind und noch nicht existieren. Mit der Firebase-Authentifizierung können Sie keine vorhandenen Telefonnummern festlegen, die von echten Benutzern als Testnummern verwendet werden. Eine Möglichkeit besteht darin, 555 Präfixnummern als US- Testtelefonnummern zu verwenden , zum Beispiel: +1 650-555-3434
2. Telefonnummern müssen hinsichtlich Länge und anderer Einschränkungen korrekt formatiert sein. Sie durchlaufen weiterhin dieselbe Validierung wie die Telefonnummer eines echten Benutzers.
3. Sie können bis zu 10 Telefonnummern für die Entwicklung hinzufügen.
4. Verwenden Sie Testtelefonnummern / -codes, die schwer zu erraten sind, und ändern Sie diese häufig.

Erstellen Sie fiktive Telefonnummern und Bestätigungscodes

1. Öffnen Sie in der Firebase-Konsole den Abschnitt Authentifizierung .
2. Im Zeichen in Verfahren Registerkarte, aktivieren Sie die Telefonanbieter , wenn Sie nicht bereits haben.
3. Öffnen Sie die Telefonnummern zum Testen des Akkordeonmenüs.
4. Geben Sie die Telefonnummer an, die Sie testen möchten, zum Beispiel: +1 650-555-3434 .
5. Geben Sie den 6-stelligen Bestätigungscode für diese bestimmte Nummer ein, zum Beispiel: 654321 .
6. Fügen Sie die Nummer hinzu. Bei Bedarf können Sie die Telefonnummer und ihren Code löschen, indem Sie den Mauszeiger über die entsprechende Zeile bewegen und auf das Papierkorbsymbol klicken.

Manuelle Prüfung

Sie können direkt mit der Verwendung einer fiktiven Telefonnummer in Ihrer Anwendung beginnen. Auf diese Weise können Sie während der Entwicklungsphase manuelle Tests durchführen, ohne auf Kontingentprobleme oder Drosselung zu stoßen. Sie können auch direkt von einem iOS-Simulator oder Android-Emulator aus testen, ohne dass Google Play Services installiert ist.

Wenn Sie die fiktive Telefonnummer angeben und den Bestätigungscode senden, wird keine tatsächliche SMS gesendet. Stattdessen müssen Sie den zuvor konfigurierten Bestätigungscode angeben, um die Anmeldung abzuschließen.

Nach Abschluss der Anmeldung wird ein Firebase-Benutzer mit dieser Telefonnummer erstellt. Der Benutzer hat dasselbe Verhalten und dieselben Eigenschaften wie ein Benutzer mit einer echten Telefonnummer und kann auf dieselbe Weise auf die Echtzeitdatenbank / den Cloud-Firestore und andere Dienste zugreifen. Das während dieses Vorgangs geprägte ID-Token hat dieselbe Signatur wie ein Benutzer mit einer echten Telefonnummer.

Eine andere Möglichkeit besteht darin , eine Testrolle über benutzerdefinierte Ansprüche für diese Benutzer festzulegen, um sie als gefälschte Benutzer zu unterscheiden, wenn Sie den Zugriff weiter einschränken möchten.

Verwenden Sie die forceRecaptchaFlowForTesting() -Methode, um den reCAPTCHA-Flow zum Testen manuell auszulösen.

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

Integrationstests

Zusätzlich zum manuellen Testen bietet die Firebase-Authentifizierung APIs, mit denen Integrationstests für Telefonauthentifizierungstests geschrieben werden können. Diese APIs deaktivieren die App-Überprüfung, indem sie die reCAPTCHA-Anforderung im Web und stille Push-Benachrichtigungen in iOS deaktivieren. Dies ermöglicht Automatisierungstests in diesen Flows und ist einfacher zu implementieren. Darüber hinaus bieten sie die Möglichkeit, sofortige Überprüfungsabläufe unter Android zu testen.

Rufen Sie unter Android setAppVerificationDisabledForTesting() vor dem Aufruf von signInWithPhoneNumber . Dadurch wird die App-Überprüfung automatisch deaktiviert, sodass Sie die Telefonnummer übergeben können, ohne sie manuell zu lösen. Beachten Sie, dass die Verwendung einer echten Telefonnummer trotz der Deaktivierung von reCAPTCHA und / oder SafetyNet immer noch nicht vollständig abgeschlossen werden kann. Mit dieser API können nur fiktive Telefonnummern verwendet werden.

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

Das Aufrufen von verifyPhoneNumber mit einer fiktiven Nummer löst den onCodeSent Rückruf aus, in dem Sie den entsprechenden Bestätigungscode onCodeSent müssen. Dies ermöglicht das Testen in Android-Emulatoren.

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);
MainActivity.java

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

Darüber hinaus können Sie den automatischen Abruf in Android testen, indem Sie die fiktive Nummer und den entsprechenden Bestätigungscode für den automatischen Abruf setAutoRetrievedSmsCodeForPhoneNumber indem Sie setAutoRetrievedSmsCodeForPhoneNumber aufrufen.

Wenn verifyPhoneNumber genannt wird, löst es onVerificationCompleted mit dem PhoneAuthCredential direkt. Dies funktioniert nur mit fiktiven Telefonnummern.

Stellen Sie sicher, dass dies deaktiviert ist und keine fiktiven Telefonnummern in Ihrer App fest codiert sind, wenn Sie Ihre Anwendung im Google Play Store veröffentlichen.

// 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);
MainActivity.java

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

Nächste Schritte

Nachdem sich ein Benutzer zum ersten Mal angemeldet hat, wird ein neues Benutzerkonto erstellt und mit den Anmeldeinformationen verknüpft, dh dem Benutzernamen und dem Kennwort, der Telefonnummer oder den Informationen zum Authentifizierungsanbieter, mit denen sich der Benutzer angemeldet hat. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um einen Benutzer in jeder App in Ihrem Projekt zu identifizieren, unabhängig davon, wie sich der Benutzer anmeldet.

• In Ihren Apps können Sie die grundlegenden Profilinformationen des Benutzers aus dem FirebaseUser Objekt FirebaseUser . Siehe Benutzer verwalten .

• In Ihren Firebase- Sicherheitsregeln für Echtzeitdatenbanken und Cloud-Speicher können Sie die eindeutige Benutzer-ID des angemeldeten Benutzers aus der auth und damit steuern, auf welche Daten ein Benutzer zugreifen kann.

Sie können Benutzern erlauben, sich mit mehreren Authentifizierungsanbietern bei Ihrer App anzumelden, indem Sie die Anmeldeinformationen des Authentifizierungsanbieters mit einem vorhandenen Benutzerkonto verknüpfen.

Um einen Benutzer signOut , rufen Sie signOut :

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

Firebase.auth.signOut()
MainActivity.kt