Authentifizieren Sie sich bei Firebase auf Android mithilfe 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 Einmalcode an, der in der SMS-Nachricht enthalten ist.

Der einfachste Weg, die Telefonnummernanmeldung zu Ihrer App hinzuzufügen, ist die Verwendung von FirebaseUI , das ein Drop-in-Anmelde-Widget enthält, das Anmeldeabläufe für die Telefonnummernanmeldung sowie passwortbasierte und föderierte Anmeldungen implementiert -In. In diesem Dokument wird beschrieben, wie Sie mit dem Firebase SDK einen Anmeldevorgang für Telefonnummern implementieren.

Bevor Sie beginnen

  1. Falls noch nicht geschehen, fügen Sie Firebase zu Ihrem Android-Projekt hinzu .
  2. Fügen Sie in Ihrer Modul-Gradle-Datei (auf App-Ebene) (normalerweise <project>/<app-module>/build.gradle.kts oder <project>/<app-module>/build.gradle ) die Abhängigkeit für die Firebase-Authentifizierung hinzu Bibliothek für Android. Wir empfehlen die Verwendung der Firebase Android BoM zur Steuerung der Bibliotheksversionierung.
    dependencies {
        // Import the BoM for the Firebase platform
        implementation(platform("com.google.firebase:firebase-bom:32.7.3"))
    
        // 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")
    }
    

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

    (Alternative) Fügen Sie Firebase-Bibliotheksabhängigkeiten hinzu , 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: Wenn Sie mehrere Firebase-Bibliotheken in Ihrer App verwenden, empfehlen wir dringend, die BoM zum Verwalten der Bibliotheksversionen zu verwenden, um sicherzustellen, dass alle Versionen kompatibel sind.

    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:22.3.1")
    }
    
    Suchen Sie nach einem Kotlin-spezifischen Bibliotheksmodul? Ab Oktober 2023 (Firebase BoM 32.5.0) können sich sowohl Kotlin- als auch Java-Entwickler auf das Hauptbibliotheksmodul verlassen (Einzelheiten finden Sie in den FAQ zu dieser Initiative ).
  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 bequem, aber weniger sicher als die anderen verfügbaren Methoden, da der Besitz einer Telefonnummer leicht zwischen Benutzern übertragen werden kann. Außerdem kann sich auf Geräten mit mehreren Benutzerprofilen jeder Benutzer, der SMS-Nachrichten empfangen kann, mit der Telefonnummer des Geräts bei einem Konto anmelden.

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

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

Um Benutzer per SMS anzumelden, müssen Sie zunächst die Anmeldemethode „Telefonnummer“ für Ihr Firebase-Projekt aktivieren:

  1. Öffnen Sie in der Firebase-Konsole den Abschnitt Authentifizierung .
  2. Aktivieren Sie auf der Seite „Anmeldemethode“ die Anmeldemethode „Telefonnummer“ .

Das Kontingent von Firebase-Anmeldeanfragen für Telefonnummern ist hoch genug, dass 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 Preisseite .

Aktivieren Sie die App-Verifizierung

Um die Telefonnummernauthentifizierung verwenden zu können, muss Firebase überprüfen können, ob Anmeldeanfragen für Telefonnummern von Ihrer App kommen. Dies kann mit der Firebase-Authentifizierung auf drei Arten erreicht werden:

  • Play Integrity API : Wenn ein Benutzer ein Gerät mit installierten Google Play-Diensten hat und die Firebase-Authentifizierung das Gerät mit der Play Integrity API als legitim verifizieren kann, kann die Anmeldung über die Telefonnummer fortgesetzt werden. Die Play Integrity API wird durch die Firebase-Authentifizierung für ein Google-eigenes Projekt aktiviert, nicht für Ihr Projekt. Dies trägt nicht zu den Play Integrity API-Kontingenten Ihres Projekts bei. Play Integrity Support ist mit dem Authentication SDK v21.2.0+ (Firebase BoM v31.4.0+) verfügbar.

    Wenn Sie Play Integrity verwenden möchten, müssen Sie den SHA-256-Fingerabdruck Ihrer App noch nicht angegeben haben. Dies können Sie in den Projekteinstellungen der Firebase-Konsole tun. Weitere Informationen zum Abrufen des SHA-256-Fingerabdrucks Ihrer App finden Sie unter „Authentifizierung Ihres Clients“ .

  • reCAPTCHA-Überprüfung : Für den Fall, dass Play Integrity nicht verwendet werden kann, beispielsweise wenn ein Benutzer ein Gerät ohne installierte Google Play-Dienste hat, verwendet die Firebase-Authentifizierung eine reCAPTCHA-Überprüfung, um den telefonischen Anmeldevorgang abzuschließen. Die reCAPTCHA-Challenge kann häufig abgeschlossen werden, ohne dass der Benutzer etwas lösen muss. Beachten Sie, dass dieser Ablauf erfordert, dass Ihrer Anwendung ein SHA-1 zugeordnet ist. Dieser Ablauf erfordert außerdem, dass Ihr API-Schlüssel uneingeschränkt oder auf der Zulassungsliste für PROJECT_ID .firebaseapp.com steht.

    Einige Szenarien, in denen reCAPTCHA ausgelöst wird:

    • Wenn auf dem Gerät des Endbenutzers keine Google Play-Dienste installiert sind.
    • Wenn die App nicht über den Google Play Store vertrieben wird (auf Authentication SDK v21.2.0+ ).
    • Wenn das erhaltene SafetyNet-Token ungültig war (bei Authentication SDK-Versionen < v21.2.0).

    Wenn SafetyNet oder Play Integrity für die App-Verifizierung verwendet wird, wird das Feld %APP_NAME% in der SMS-Vorlage mit dem aus dem Google Play Store ermittelten App-Namen gefüllt. In den Szenarien, in denen reCAPTCHA ausgelöst wird, wird %APP_NAME% als PROJECT_ID .firebaseapp.com ausgefüllt.

Sie können den reCAPTCHA-Verifizierungsablauf mit forceRecaptchaFlowForTesting erzwingen. Sie können die App-Verifizierung (bei Verwendung fiktiver Telefonnummern) mit setAppVerificationDisabledForTesting deaktivieren.

Fehlerbehebung

  • Fehler „Anfangsstatus fehlt“ bei Verwendung von reCAPTCHA zur App-Verifizierung

    Dies kann auftreten, wenn der reCAPTCHA-Ablauf erfolgreich abgeschlossen wird, der Benutzer jedoch nicht zurück zur nativen Anwendung umgeleitet wird. In diesem Fall wird der Benutzer zur Fallback-URL PROJECT_ID .firebaseapp.com/__/auth/handler umgeleitet. In Firefox-Browsern ist das Öffnen nativer App-Links standardmäßig deaktiviert. Wenn Sie den oben genannten Fehler in Firefox sehen, befolgen Sie die Schritte unter „Firefox für Android so einstellen, dass Links in nativen Apps geöffnet werden“, um das Öffnen von App-Links zu ermöglichen.

Senden Sie einen Bestätigungscode an das Telefon des Benutzers

Um die Anmeldung per Telefonnummer zu initiieren, präsentieren Sie dem Benutzer eine Schnittstelle, die ihn zur Eingabe seiner Telefonnummer auffordert. Die gesetzlichen Anforderungen variieren. Als Best Practice und um die Erwartungen an Ihre Benutzer zu wecken, sollten Sie sie jedoch darüber informieren, dass sie bei Verwendung der telefonischen Anmeldung möglicherweise eine SMS-Nachricht zur Überprüfung erhalten und Standardtarife gelten.

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

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)

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

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

Sie können dieses Verhalten verwenden, um den Anmeldevorgang mit der Telefonnummer fortzusetzen, wenn Ihre App geschlossen wird, bevor sich der Benutzer anmelden kann (z. B. während der Benutzer seine SMS-App verwendet). Nachdem Sie verifyPhoneNumber aufgerufen haben, legen Sie ein Flag fest, das angibt, dass die Überprüfung läuft. Speichern Sie dann das Flag in der onSaveInstanceState Methode Ihrer Aktivität und stellen Sie das Flag in onRestoreInstanceState wieder her. Überprüfen Sie abschließend in onStart Methode Ihrer Aktivität, ob die Verifizierung bereits läuft, und rufen Sie in diesem Fall noch einmal verifyPhoneNumber auf. Stellen Sie sicher, dass Sie das Flag löschen, wenn die Überprüfung abgeschlossen ist oder fehlschlägt (siehe Rückrufe bei der Überprüfung ).

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

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

Kotlin+KTX

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

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

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

Rückrufe zur Überprüfung

In den meisten Apps implementieren Sie die Rückrufe 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 Verifizierung: In manchen Fällen kann die Telefonnummer sofort verifiziert werden, ohne dass ein Verifizierungscode 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 Benutzereingriff durchführen. (Diese Funktion ist bei einigen Netzbetreibern möglicherweise nicht verfügbar.) Dabei wird die SMS Retriever-API verwendet, die am Ende der SMS-Nachricht einen 11-stelligen Hash enthält.
In beiden Fällen wurde die Telefonnummer des Benutzers erfolgreich überprüft und Sie können das PhoneAuthCredential Objekt verwenden, das an den Rückruf übergeben wird, um den Benutzer anzumelden .

onVerificationFailed(FirebaseException)

Diese Methode wird als Reaktion auf eine ungültige Verifizierungsanforderung aufgerufen, beispielsweise eine Anforderung, die eine ungültige Telefonnummer oder einen ungültigen Verifizierungscode angibt.

onCodeSent(String-Verifizierungs-ID, PhoneAuthProvider.ForceResendingToken)

Optional. Diese Methode wird aufgerufen, nachdem der Verifizierungscode 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 läuft möglicherweise die automatische Überprüfung im Hintergrund ab.) Nachdem der Benutzer dann 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, das Sie können es wiederum verwenden, um den Benutzer anzumelden. Einige Apps warten jedoch möglicherweise, bis onCodeAutoRetrievalTimeOut aufgerufen wird, bevor sie die Benutzeroberfläche für den Bestätigungscode anzeigen (nicht empfohlen).

onCodeAutoRetrievalTimeOut(String-Überprüfungs-ID)

Optional. Diese Methode wird aufgerufen, nachdem die für verifyPhoneNumber angegebene Zeitüberschreitungsdauer abgelaufen ist, ohne dass zuvor onVerificationCompleted ausgelöst wurde. Auf Geräten ohne SIM-Karte wird diese Methode sofort aufgerufen, da kein automatischer SMS-Abruf möglich ist.

Einige Apps blockieren Benutzereingaben, bis der Zeitraum der automatischen Ü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 eingegeben hat, 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 onCodeSent oder onCodeAutoRetrievalTimeOut -Rückruf übergeben wurden. (Wenn onVerificationCompleted aufgerufen wird, erhalten Sie direkt ein PhoneAuthCredential Objekt, sodass Sie diesen Schritt überspringen können.)

Um das PhoneAuthCredential Objekt zu erstellen, rufen Sie PhoneAuthProvider.getCredential auf:

Kotlin+KTX

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

Java

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

Melden Sie den Benutzer an

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

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

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

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 Ihrer Telefonnummer, 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 dass es zu einer Drosselung kommt. Dies minimiert das Risiko einer Ablehnung während des Überprüfungsprozesses im App Store, wenn der Prüfer zufällig dieselbe Telefonnummer zum Testen verwendet.
  • Testen Sie problemlos in Entwicklungsumgebungen ohne zusätzlichen Aufwand, z. B. die Möglichkeit, in einem iOS-Simulator oder einem Android-Emulator ohne Google Play Services zu entwickeln.
  • Schreiben Sie Integrationstests, ohne durch Sicherheitsüberprüfungen blockiert zu werden, die normalerweise auf echte Telefonnummern in einer Produktionsumgebung angewendet werden.

Fiktive Telefonnummern müssen diese 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 vorhandene Telefonnummern, die von echten Benutzern verwendet werden, nicht als Testnummern festlegen. Eine Möglichkeit besteht darin, 555-Vorwahlnummern als US-Testtelefonnummern zu verwenden, zum Beispiel: +1 650-555-3434
  2. Telefonnummern müssen im Hinblick auf Länge und andere Einschränkungen korrekt formatiert sein. Sie durchlaufen weiterhin die gleiche 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. Aktivieren Sie auf der Registerkarte „Anmeldemethode“ den Telefonanbieter, falls Sie dies noch nicht getan haben.
  3. Öffnen Sie das Menü Telefonnummern zum Testen des Akkordeons.
  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 an, zum Beispiel: 654321 .
  6. Fügen Sie die Nummer hinzu. Bei Bedarf können Sie die Telefonnummer und ihren Code löschen, indem Sie mit der Maus über die entsprechende Zeile fahren und auf das Papierkorbsymbol klicken.

Manuelles Testen

Sie können direkt damit beginnen, eine fiktive Telefonnummer in Ihrer Bewerbung zu verwenden. Dadurch können Sie während der Entwicklungsphase manuelle Tests durchführen, ohne dass es zu Kontingentproblemen oder Drosselungen kommt. Sie können den Test auch direkt von einem iOS-Simulator oder Android-Emulator aus durchführen, 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 das gleiche Verhalten und die gleichen Eigenschaften wie ein echter Telefonnummernbenutzer und kann auf die gleiche Weise auf Realtime Database/Cloud Firestore und andere Dienste zugreifen. Der während dieses Vorgangs geprägte ID-Token hat die gleiche Signatur wie ein echter Telefonnummernbenutzer.

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

Um den reCAPTCHA-Fluss zum Testen manuell auszulösen, verwenden Sie die Methode forceRecaptchaFlowForTesting() .

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

Integrationstests

Zusätzlich zu manuellen Tests bietet Firebase Authentication APIs, die beim Schreiben von Integrationstests für Telefonauthentifizierungstests helfen. Diese APIs deaktivieren die App-Verifizierung, indem sie die reCAPTCHA-Anforderung im Web und stille Push-Benachrichtigungen in iOS deaktivieren. Dies macht Automatisierungstests in diesen Abläufen möglich und einfacher zu implementieren. Darüber hinaus bieten sie die Möglichkeit, sofortige Verifizierungsabläufe auf Android zu testen.

Rufen Sie unter Android setAppVerificationDisabledForTesting() vor dem signInWithPhoneNumber -Aufruf auf. Dadurch wird die App-Überprüfung automatisch deaktiviert, sodass Sie die Telefonnummer weitergeben können, ohne sie manuell lösen zu müssen. Auch wenn Play Integrity und reCAPTCHA deaktiviert sind, kann die Anmeldung mit einer echten Telefonnummer dennoch nicht abgeschlossen werden. Mit dieser API können nur fiktive Telefonnummern verwendet werden.

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

Wenn Sie verifyPhoneNumber mit einer fiktiven Nummer aufrufen, wird der onCodeSent Rückruf ausgelöst, bei dem Sie den entsprechenden Bestätigungscode angeben müssen. Dies ermöglicht das Testen in Android-Emulatoren.

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+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)

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

Wenn verifyPhoneNumber aufgerufen wird, wird onVerificationCompleted direkt mit PhoneAuthCredential ausgelöst. 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.

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+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)

Nächste Schritte

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

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

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

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

Um einen Benutzer abzumelden, rufen Sie signOut auf:

Kotlin+KTX

Firebase.auth.signOut()

Java

FirebaseAuth.getInstance().signOut();