Mit einer Telefonnummer bei Firebase auf Android-Geräten authentifizieren

Mit Firebase Authentication können Sie einen Nutzer anmelden, indem Sie eine SMS-Nachricht an sein Smartphone senden. Der Nutzer meldet sich mit einem Einmalcode an, der in der SMS enthalten ist.

Die einfachste Möglichkeit, die Anmeldung per Telefonnummer in Ihre App einzubinden, ist die Verwendung von FirebaseUI, das ein Drop-in-Anmeldewidget enthält, das Anmeldevorgänge für die Anmeldung per Telefon nummer sowie für die passwortbasierte und föderierte Anmeldung implementiert. In diesem Dokument wird beschrieben, wie Sie einen Anmeldevorgang per Telefonnummer mit dem Firebase SDK implementieren.

Hinweis

  1. Falls noch nicht geschehen, fügen Sie Ihrem Android-Projekt Firebase hinzu.
  2. Fügen Sie in der Gradle-Datei Ihres Moduls (auf Anwendungsebene) (in der Regel <project>/<app-module>/build.gradle.kts oder <project>/<app-module>/build.gradle) die Abhängigkeit für die Firebase Authentication Bibliothek für Android hinzu. Wir empfehlen, die Firebase Android BoM zu verwenden, um die Versionsverwaltung der Bibliothek zu steuern. 
    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:34.13.0"))

    // Add the dependency for the Firebase Authentication library
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-auth")
}

    Mit der Firebase Android BoM, haben Sie immer eine kompatible Version der Firebase Android-Bibliotheken in Ihrer App.

    (Alternative)   Firebase-Bibliotheksabhängigkeiten ohne BoM hinzufügen

    Wenn Sie die Firebase BoM nicht verwenden möchten, müssen Sie die Version jeder Firebase-Bibliothek in der entsprechenden Abhängigkeitszeile angeben.

    Hinweis: Wenn Sie in Ihrer App mehrere Firebase-Bibliotheken verwenden, empfehlen wir dringend, die BoM zur Verwaltung 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:24.1.0")
}
  3. Wenn Sie Ihre App noch nicht mit Ihrem Firebase-Projekt verknüpft haben, tun Sie dies in der Firebase Konsole.
  4. Wenn Sie den SHA‑1-Hash Ihrer App noch nicht in der Firebase Konsole festgelegt haben, tun Sie dies jetzt. Informationen zum Ermitteln des SHA‑1-Hash Ihrer App finden Sie unter Client authentifizieren.

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 Nutzern übertragen werden kann. Außerdem kann sich auf Geräten mit mehreren Benutzerprofilen jeder Nutzer, der SMS-Nachrichten empfangen kann, mit der Telefonnummer des Geräts in einem Konto anmelden.

Wenn Sie die Anmeldung per Telefonnummer in Ihrer App verwenden, sollten Sie sie zusammen mit sichereren Anmeldemethoden anbieten und Nutzer über die Sicherheitsrisiken der Anmeldung per Telefonnummer informieren.

Anmeldung per Telefonnummer für Ihr Firebase-Projekt aktivieren

Wenn sich Nutzer per SMS anmelden sollen, müssen Sie zuerst die Anmeldemethode per Telefonnummer für Ihr Firebase-Projekt aktivieren:

  1. Rufen Sie in der Firebase Console Security > Authentication auf.
  2. Aktivieren Sie auf dem Tab Anmeldemethode den Anmeldeanbieter Telefon.
  3. Legen Sie eine Richtlinie für die Regionen fest, in denen SMS-Nachrichten gesendet werden dürfen oder nicht. Durch das Festlegen einer Richtlinie für SMS-Regionen können Sie Ihre Apps vor SMS-Missbrauch schützen. Für neue Projekte lässt die Standardrichtlinie keine Regionen zu.
    1. Rufen Sie in der Firebase Console den Tab Sicherheit > Authentifizierung > Einstellungen auf.
    2. Richten Sie im Abschnitt Richtlinie für SMS-Regionen Ihre Richtlinie für SMS-Regionen ein.

App-Überprüfung aktivieren

Für die Authentifizierung per Telefonnummer muss Firebase bestätigen können, dass Anfragen zur Anmeldung per Telefonnummer von Ihrer App stammen. Dazu gibt es drei Möglichkeiten, Firebase Authentication dies zu erreichen:

  • Play Integrity API: Wenn ein Nutzer ein Gerät mit installierten Google Play services hat und Firebase Authentication das Gerät mit der Play Integrity API als legitim bestätigen kann, kann die Anmeldung per Telefonnummer fortgesetzt werden. Die Play Integrity API wird von Firebase Authentication in einem Google-eigenen Projekt aktiviert, nicht in Ihrem Projekt. Dies trägt nicht zu den Play Integrity API Kontingenten für Ihr Projekt bei. Der Play Integrity-Support ist mit dem Authentication SDK ab Version 21.2.0+ (Firebase BoM ab Version 31.4.0) verfügbar.

    Wenn Sie die Play Integrity API verwenden möchten, geben Sie den SHA‑256-Fingerabdruck Ihrer App an, falls Sie dies noch nicht getan haben.

    1. Rufen Sie in der Firebase Console die Einstellungen > Allgemein auf.
    2. Scrollen Sie nach unten zur Karte Ihre Apps, wählen Sie Ihre Android-App aus und fügen Sie Ihren SHA‑256-Fingerabdruck in das Feld SHA-Zertifikat-Fingerabdrücke ein.

    Weitere Informationen zum Abrufen des SHA-Fingerabdrucks Ihrer App finden Sie unter Client authentifizieren.

  • reCAPTCHA-Überprüfung: Wenn die Play Integrity API nicht verwendet werden kann, z. B. wenn ein Nutzer ein Gerät ohne Google Play services installiert hat, Firebase Authentication verwendet Firebase Authentication eine reCAPTCHA-Überprüfung, um den Anmeldevorgang per Telefonnummer abzuschließen. Die reCAPTCHA-Aufgabe kann oft abgeschlossen werden, ohne dass der Nutzer etwas tun muss. Für diesen Vorgang muss ein SHA‑1 mit Ihrer Anwendung verknüpft sein. Außerdem muss Ihr API-Schlüssel uneingeschränkt sein oder für PROJECT_ID.firebaseapp.com auf der Zulassungsliste stehen.

    Einige Szenarien, in denen reCAPTCHA ausgelöst wird:

    • Auf dem Gerät des Endnutzers ist Google Play services nicht installiert.
    • Die App wird nicht über Google Play Store vertrieben (mit Authentication SDK ab Version 21.2.0+).
    • Das abgerufene SafetyNet-Token war ungültig (mit Authentication SDK-Versionen < Version 21.2.0).

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

Sie können den reCAPTCHA-Überprüfungsvorgang mit forceRecaptchaFlowForTesting Die App-Überprüfung kann mit setAppVerificationDisabledForTesting deaktiviert werden (bei Verwendung fiktiver Telefonnummern).

Fehlerbehebung

  • Fehler „Missing initial state“ (Fehlender Anfangszustand) bei Verwendung von reCAPTCHA für die App-Überprüfung

    Dieser Fehler kann auftreten, wenn der reCAPTCHA-Vorgang erfolgreich abgeschlossen wird, der Nutzer aber nicht zur nativen Anwendung zurückgeleitet wird. In diesem Fall wird der Nutzer zur Fallback-URL PROJECT_ID.firebaseapp.com/__/auth/handler weitergeleitet. In Firefox-Browsern ist das Öffnen von Links zu systemeigenen Apps standardmäßig deaktiviert. Wenn der oben genannte Fehler in Firefox auftritt, folgen Sie der Anleitung unter Firefox für Android so einstellen, dass Links in nativen Apps geöffnet werden, um das Öffnen von App-Links zu aktivieren.

Bestätigungscode an das Smartphone des Nutzers senden

Um die Anmeldung per Telefonnummer zu starten, präsentieren Sie dem Nutzer eine Oberfläche, auf der er seine Telefonnummer eingeben kann. Die rechtlichen Anforderungen variieren. Als Best Practice und um die Erwartungen Ihrer Nutzer zu erfüllen, sollten Sie sie jedoch darüber informieren, dass sie bei der Anmeldung per Telefonnummer möglicherweise eine SMS zur Bestätigung erhalten und dass die üblichen Gebühren anfallen.

Übergeben Sie dann die Telefonnummer an die Methode PhoneAuthProvider.verifyPhoneNumber, um Firebase aufzufordern, die Telefonnummer des Nutzers zu bestätigen. Beispiel:

Kotlin

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

Java

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

Die Methode verifyPhoneNumber ist wiederholbar. Wenn Sie sie mehrmals aufrufen, z. B. in der Methode onStart einer Aktivität, sendet die Methode verifyPhoneNumber erst dann eine zweite SMS, wenn für die ursprüngliche Anfrage ein Zeitlimit überschritten wurde.

Sie können dieses Verhalten nutzen, um den Anmeldevorgang per Telefonnummer fortzusetzen, wenn Ihre App geschlossen wird, bevor sich der Nutzer anmelden kann (z. B. während der Nutzer seine SMS-App verwendet). Legen Sie nach dem Aufrufen von verifyPhoneNumber ein Flag fest, das angibt, dass die Bestätigung läuft. Speichern Sie das Flag dann in der Methode onSaveInstanceState Ihrer Aktivität und stellen Sie es in onRestoreInstanceState wieder her. Prüfen Sie schließlich in der Methode onStart Ihrer Aktivität, ob die Bestätigung bereits läuft, und rufen Sie in diesem Fall verifyPhoneNumber noch einmal auf. Achten Sie darauf, das Flag zu löschen, wenn die Bestätigung abgeschlossen ist oder fehlschlägt (siehe Bestätigungs-Callbacks).

Um die Bildschirmrotation und andere Fälle von Aktivitätsneustarts einfach zu verarbeiten, übergeben Sie Ihre Aktivität an die Methode verifyPhoneNumber. Die Callbacks werden automatisch getrennt, wenn die Aktivität beendet wird. Sie können also UI-Übergangscode frei in die Callback-Methoden schreiben.

Die von Firebase gesendete SMS-Nachricht kann auch lokalisiert werden. Geben Sie dazu die Authentifizierungssprache über die Methode setLanguageCode in Ihrer Auth-Instanz an.

Kotlin

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

Java

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

Wenn Sie PhoneAuthProvider.verifyPhoneNumber aufrufen, müssen Sie auch eine Instanz von OnVerificationStateChangedCallbacks angeben, die Implementierungen der Callback-Funktionen enthält, die die Ergebnisse der Anfrage verarbeiten. Beispiel:

Kotlin

callbacks = object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

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

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

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

        // Show a message and update the UI
    }

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

        // Save verification ID and resending token so we can use them later
        storedVerificationId = verificationId
        resendToken = token
    }
}

Java

mCallbacks = new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

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

        signInWithPhoneAuthCredential(credential);
    }

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

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

        // Show a message and update the UI
    }

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

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

Bestätigungs-Callbacks

In den meisten Apps implementieren Sie die Callbacks onVerificationCompleted, onVerificationFailed und onCodeSent. Je nach den Anforderungen Ihrer App können Sie auch onCodeAutoRetrievalTimeOut implementieren.

onVerificationCompleted(PhoneAuthCredential)

Diese Methode wird in zwei Situationen aufgerufen:

  • Sofortige Bestätigung: In einigen Fällen kann die Telefonnummer sofort bestätigt werden, ohne dass ein Bestätigungscode gesendet oder eingegeben werden muss.
  • Automatisches Abrufen: Auf einigen Geräten können die Google Play-Dienste die eingehende Bestätigungs-SMS automatisch erkennen und die Bestätigung ohne Nutzeraktion durchführen. (Diese Funktion ist möglicherweise nicht bei allen Mobilfunkanbietern verfügbar.) Dabei wird die SMS Retriever API verwendet, die am Ende der SMS einen 11-stelligen Hash enthält.
In beiden Fällen wurde die Telefonnummer des Nutzers erfolgreich bestätigt und Sie können das PhoneAuthCredential Objekt, das an den Callback übergeben wird, verwenden, um den Nutzer anzumelden.

onVerificationFailed(FirebaseException)

Diese Methode wird als Antwort auf eine ungültige Bestätigungsanfrage aufgerufen, z. B. eine Anfrage, die eine ungültige Telefonnummer oder einen ungültigen Bestätigungscode enthält.

onCodeSent(String verificationId, PhoneAuthProvider.ForceResendingToken)

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

Wenn diese Methode aufgerufen wird, zeigen die meisten Apps eine UI an, in der der Nutzer aufgefordert wird, den Bestätigungscode aus der SMS einzugeben. (Gleichzeitig kann die automatische Bestätigung im Hintergrund laufen.) Nachdem der Nutzer den Bestätigungscode eingegeben hat, können Sie mit dem Bestätigungscode und der Bestätigungs-ID, die an die Methode übergeben wurde, ein PhoneAuthCredential Objekt erstellen, mit dem Sie den Nutzer anmelden können. Einige Apps warten jedoch möglicherweise, bis onCodeAutoRetrievalTimeOut aufgerufen wird, bevor sie die UI für den Bestätigungscode anzeigen (nicht empfohlen).

onCodeAutoRetrievalTimeOut(String verificationId)

Optional. Diese Methode wird aufgerufen, nachdem die für verifyPhoneNumber angegebene Zeitüberschreitungsdauer abgelaufen ist, ohne dass onVerificationCompleted zuerst 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 die Nutzereingabe, bis das Zeitlimit für die automatische Bestätigung abgelaufen ist, und zeigen erst dann eine UI an, in der der Nutzer aufgefordert wird, den Bestätigungscode aus der SMS einzugeben (nicht empfohlen).

PhoneAuthCredential-Objekt erstellen

Nachdem der Nutzer den Bestätigungscode eingegeben hat, den Firebase an das Smartphone des Nutzers gesendet hat, erstellen Sie ein PhoneAuthCredential-Objekt mit dem Bestätigungscode und der Bestätigungs-ID, die an den Callback onCodeSent oder onCodeAutoRetrievalTimeOut übergeben wurde. (Wenn onVerificationCompleted aufgerufen wird, erhalten Sie direkt ein PhoneAuthCredential-Objekt. Sie können diesen Schritt also überspringen.)

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

Kotlin

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

Java

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

Nutzer anmelden

Nachdem Sie ein PhoneAuthCredential-Objekt erhalten haben, entweder im Callback onVerificationCompleted oder durch Aufrufen von PhoneAuthProvider.getCredential, schließen Sie den Anmeldevorgang ab, indem Sie das PhoneAuthCredential-Objekt an FirebaseAuth.signInWithCredential übergeben:

Kotlin

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

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

Java

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

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

Mit fiktiven Telefonnummern testen

Sie können in der Firebase Console fiktive Telefonnummern für die Entwicklung einrichten. Tests mit fiktiven Telefonnummern bieten folgende Vorteile:

  • Sie können die Authentifizierung per Telefonnummer testen, ohne Ihr Nutzungskontingent zu verbrauchen.
  • Sie können die Authentifizierung per Telefonnummer testen, ohne eine tatsächliche SMS zu senden.
  • Sie können aufeinanderfolgende Tests mit derselben Telefonnummer ausführen, ohne dass es zu Drosselung kommt. Dadurch wird das Risiko einer Ablehnung während der App-Überprüfung im App Store minimiert, wenn der Prüfer zufällig dieselbe Telefonnummer für Tests verwendet.
  • Sie können in Entwicklungsumgebungen ohne zusätzlichen Aufwand testen, z. B. in einem iOS-Simulator oder einem Android-Emulator ohne Google Play-Dienste.
  • Sie können Integrationstests schreiben, ohne von Sicherheitsprüfungen blockiert zu werden, die normalerweise auf echte Telefonnummern in einer Produktionsumgebung angewendet werden.

Fiktive Telefonnummern müssen die folgenden Anforderungen erfüllen:

  1. Verwenden Sie Telefonnummern, die tatsächlich fiktiv sind und noch nicht existieren. Firebase Authentication lässt nicht zu, dass Sie vorhandene Telefonnummern, die von echten Nutzern verwendet werden, als Testnummern festlegen. Eine Möglichkeit besteht darin, Nummern mit der Vorwahl 555 als US-Testtelefonnummern zu verwenden, z. B.: +1 650-555-3434
  2. Telefonnummern müssen hinsichtlich Länge und anderer Einschränkungen korrekt formatiert sein. Sie durchlaufen dieselbe Bestätigung wie die Telefonnummer eines echten Nutzers.
  3. Sie können bis zu zehn Telefonnummern für die Entwicklung hinzufügen.
  4. Verwenden Sie Testtelefonnummern und ‑codes, die nicht einfach zu erraten sind, und ändern Sie sie häufig.

Fiktive Telefonnummern und Bestätigungscodes erstellen

  1. Rufen Sie in der Firebase Console Security > Authentication auf.
  2. Aktivieren Sie auf dem Tab Anmeldemethode den Anmeldeanbieter Telefon, falls noch nicht geschehen.
  3. Maximieren Sie den Abschnitt Telefonnummern für Tests.
  4. Geben Sie die Telefonnummer ein, die Sie testen möchten, z. B.: +1 650-555-3434.
  5. Geben Sie den sechsstelligen Bestätigungscode für diese Nummer ein, z. B.: 654321.
  6. Klicken Sie für jede Nummer auf Hinzufügen. Bei Bedarf können Sie die Telefonnummer und den zugehörigen Code löschen. Bewegen Sie dazu den Mauszeiger auf die entsprechende Zeile und klicken Sie auf das Papierkorbsymbol .

Manuelle Tests

Sie können direkt eine fiktive Telefonnummer in Ihrer Anwendung verwenden. So können Sie während der Entwicklungsphasen 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-Dienste installiert sind.

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-Nutzer mit dieser Telefonnummer erstellt. Der Nutzer hat dasselbe Verhalten und dieselben Eigenschaften wie ein echter Nutzer mit Telefonnummer und kann auf dieselbe Weise auf Realtime Database/Cloud Firestore und andere Dienste zugreifen. Das während dieses Vorgangs erstellte ID-Token hat dieselbe Signatur wie das eines echten Nutzers mit Telefonnummer.

Alternativ können Sie diesen Nutzern über benutzerdefinierte Ansprüche eine Testrolle zuweisen, um sie als gefälschte Nutzer zu kennzeichnen, wenn Sie den Zugriff weiter einschränken möchten.

Verwenden Sie die forceRecaptchaFlowForTesting() Methode, um den reCAPTCHA-Vorgang manuell für Tests auszulösen. 

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

Integrationstests

Zusätzlich zu manuellen Tests bietet Firebase Authentication APIs, mit denen Sie Integrationstests für die Authentifizierung per Telefonnummer schreiben können. Mit diesen APIs wird die App-Überprüfung deaktiviert, indem die reCAPTCHA-Anforderung in Web- und Push-Benachrichtigungen im Hintergrund unter iOS deaktiviert wird. Dadurch sind automatisierte Tests in diesen Abläufen möglich und einfacher zu implementieren. Außerdem können Sie damit Abläufe für die sofortige Bestätigung unter Android testen.

Rufen Sie unter Android setAppVerificationDisabledForTesting() vor dem signInWithPhoneNumber Aufruf auf. Dadurch wird die App-Überprüfung automatisch deaktiviert und Sie können die Telefonnummer übergeben, ohne sie manuell zu bestätigen. Auch wenn die Play Integrity API und reCAPTCHA deaktiviert sind, schlägt die Anmeldung mit einer echten Telefonnummer fehl. 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 Callback onCodeSent ausgelöst, in dem Sie den entsprechenden Bestätigungscode angeben müssen. So können Sie in Android-Emulatoren testen.

Java

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

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

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

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

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

Kotlin

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

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

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

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

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

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

Außerdem können Sie Abläufe für das automatische Abrufen unter Android testen, indem Sie die fiktive Nummer und den entsprechenden Bestätigungscode für das automatische Abrufen festlegen. Rufen Sie dazu setAutoRetrievedSmsCodeForPhoneNumber auf.

Wenn verifyPhoneNumber aufgerufen wird, wird onVerificationCompleted direkt mit dem PhoneAuthCredential ausgelöst. Dies funktioniert nur mit fiktiven Telefonnummern.

Achten Sie darauf, dass diese Funktion deaktiviert ist und in Ihrer App keine fiktiven Telefonnummern 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

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

Wenn sich ein Nutzer zum ersten Mal anmeldet, wird ein neues Nutzerkonto erstellt und mit den Anmeldedaten verknüpft, mit denen sich der Nutzer angemeldet hat, d. h. mit dem Nutzernamen und Passwort, der Telefonnummer oder den Informationen zum Authentifizierungsanbieter. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um einen Nutzer in allen Apps Ihres Projekts zu identifizieren, unabhängig davon, wie sich der Nutzer anmeldet.

  • In Ihren Apps können Sie die grundlegenden Profilinformationen des Nutzers aus dem FirebaseUser Objekt abrufen. Weitere Informationen finden Sie unter Nutzer verwalten.

  • In den Firebase Realtime Database und Cloud Storage Sicherheitsregeln können Sie die eindeutige Nutzer-ID des angemeldeten Nutzers aus der Variablen auth abrufen und damit steuern, auf welche Daten ein Nutzer zugreifen kann.

Sie können Nutzern erlauben, sich mit mehreren Authentifizierungsanbietern in Ihrer App anzumelden, indem Sie Anmeldedaten des Authentifizierungsanbieters mit einem vorhandenen Nutzerkonto verknüpfen.

Rufen Sie signOut auf, um einen Nutzer abzumelden:

Kotlin

Firebase.auth.signOut()

Java

FirebaseAuth.getInstance().signOut();