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

Sie können Firebase Authentication verwenden, um einen Nutzer anzumelden, indem Sie eine SMS an das Smartphone des Nutzers senden. Der Nutzer meldet sich mit einem Einmalcode an, der in der SMS enthalten ist.

Am einfachsten lässt sich die Anmeldung per Telefonnummer in Ihre App einbinden, wenn Sie FirebaseUI verwenden. FirebaseUI enthält ein Drop-in-Anmelde-Widget, das Anmeldeabläufe für die Anmeldung per Telefonnummer sowie für die passwortbasierte und föderierte Anmeldung implementiert. In diesem Dokument wird beschrieben, wie Sie einen Anmeldevorgang mit einer Telefonnummer mithilfe des 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 des Moduls (auf App-Ebene) (normalerweise <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 Bibliotheksversionierung zu steuern. 
    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:35.1.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 Verwendung der BoM hinzufügen

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

    Wenn Sie mehrere Firebase-Bibliotheken in Ihrer App verwenden, empfehlen wir dringend, die BoM zum Verwalten der Bibliotheksversionen zu verwenden. So wird sichergestellt, 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:25.0.0")
}
  3. Wenn Sie Ihre App noch nicht mit Ihrem Firebase-Projekt verbunden haben, können Sie das in der Firebase-Konsole tun.
  4. Falls Sie den SHA-1-Hash Ihrer App noch nicht in der Firebase Console festgelegt haben, tun Sie dies jetzt. Informationen zum Ermitteln des SHA-1-Hashs 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 die Inhaberschaft einer Telefonnummer leicht zwischen Nutzern übertragen werden kann. Auf Geräten mit mehreren Nutzerprofilen kann sich jeder Nutzer, der SMS empfangen kann, mit der Telefonnummer des Geräts in einem Konto anmelden.

Wenn Sie in Ihrer App die Anmeldung per Telefonnummer 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 Sie Nutzer per SMS anmelden möchten, müssen Sie zuerst die Anmeldemethode „Telefonnummer“ für Ihr Firebase-Projekt aktivieren:

  1. Rufen Sie in der Firebase-Konsole Sicherheit > Authentifizierung auf.
  2. Aktivieren Sie auf dem Tab Anmeldemethode den Anbieter für die Anmeldung über Telefon.
  3. Legen Sie eine Richtlinie für die Regionen fest, in die SMS gesendet werden dürfen oder nicht. Durch das Festlegen einer SMS-Regionsrichtlinie können Sie Ihre Apps besser vor SMS-Missbrauch schützen. Bei neuen Projekten sind in der Standardrichtlinie keine Regionen zulässig.
    1. Rufen Sie in der Firebase-Konsole den Tab Sicherheit > Authentifizierung > Einstellungen auf.
    2. Richten Sie im Bereich Richtlinie für SMS-Regionen die Richtlinie für SMS-Regionen ein.

App-Überprüfung aktivieren

Damit die Authentifizierung per Telefonnummer verwendet werden kann, muss Firebase bestätigen können, dass die Anmeldeanfragen per Telefonnummer von Ihrer App stammen. Dafür gibt es drei Möglichkeiten Firebase Authentication:

  • Play Integrity API: Wenn ein Nutzer ein Gerät mit installiertem Google Play services hat und Firebase Authentication das Gerät mit der Play Integrity API als legitim bestätigen kann, kann die Anmeldung mit der Telefonnummer fortgesetzt werden. Die Play Integrity API ist in einem Google-eigenen Projekt von Firebase Authentication aktiviert, nicht in Ihrem Projekt. Dies wird nicht auf die Play Integrity API-Kontingente für Ihr Projekt angerechnet. Die Play Integrity-Unterstützung ist ab Authentication SDK-Version 21.2.0 (Firebase BoM-Version 31.4.0 oder höher) verfügbar.

    Wenn Sie Play Integrity 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-Konsole die Seite Einstellungen > Tab Allgemein auf.
    2. Scrollen Sie nach unten zur Karte Meine Apps, wählen Sie Ihre Android-App aus und fügen Sie Ihren SHA-256-Fingerabdruck im Feld SHA-Zertifikat-Fingerabdrücke hinzu.

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

  • reCAPTCHA-Überprüfung: Wenn Play Integrity nicht verwendet werden kann, z. B. wenn ein Nutzer ein Gerät ohne Google Play services hat, verwendet Firebase Authentication eine reCAPTCHA-Überprüfung, um die Anmeldung per Telefon abzuschließen. Die reCAPTCHA-Aufgabe kann oft abgeschlossen werden, ohne dass der Nutzer etwas lösen muss. Für diesen Ablauf muss Ihrer Anwendung ein SHA-1-Wert zugeordnet sein. Für diesen Ablauf muss Ihr API-Schlüssel uneingeschränkt oder für PROJECT_ID.firebaseapp.com auf der Zulassungsliste sein.

    Hier einige Szenarien, in denen reCAPTCHA ausgelöst wird:

    • Wenn Google Play services nicht auf dem Gerät des Endnutzers installiert ist.
    • Wenn die App nicht über Google Play Store vertrieben wird (auf Authentication SDK v21.2.0+).
    • Wenn das erhaltene SafetyNet-Token nicht gültig war (bei Authentication SDK-Versionen < v21.2.0).

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

Sie können den reCAPTCHA-Überprüfungsablauf mit forceRecaptchaFlowForTesting erzwingen. Sie können die App-Überprüfung (bei Verwendung fiktiver Telefonnummern) mit setAppVerificationDisabledForTesting deaktivieren.

Fehlerbehebung

  • Fehler „Anfangszustand fehlt“ bei Verwendung von reCAPTCHA für die App-Überprüfung

    Dies kann passieren, wenn der reCAPTCHA-Ablauf 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 Sie den oben genannten Fehler in Firefox sehen, folgen Sie der Anleitung unter Firefox für Android so einstellen, dass Links in systemeigenen Apps geöffnet werden, um das Öffnen von App-Links zu aktivieren.

Bestätigungscode an das Smartphone des Nutzers senden

Wenn Sie die Anmeldung per Telefonnummer initiieren möchten, müssen Sie dem Nutzer eine Oberfläche präsentieren, 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 darüber informieren, dass sie bei der Anmeldung per Telefon möglicherweise eine SMS zur Bestätigung erhalten und dass Standardgebü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 wiedereintrittsfähig: Wenn Sie sie mehrmals aufrufen, z. B. in der Methode onStart einer Aktivität, wird von der Methode verifyPhoneNumber keine zweite SMS gesendet, es sei denn, die ursprüngliche Anfrage ist abgelaufen.

Sie können dieses Verhalten verwenden, um den Anmeldevorgang mit der Telefonnummer fortzusetzen, wenn Ihre App geschlossen wird, bevor sich der Nutzer anmelden kann (z. B. während der Nutzer seine SMS-App verwendet). Nachdem Sie verifyPhoneNumber aufgerufen haben, legen Sie 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 abschließend in der Methode onStart Ihrer Aktivität, ob die Bestätigung bereits läuft. Wenn ja, rufen Sie verifyPhoneNumber noch einmal auf. Lösche das Flag, wenn die Bestätigung abgeschlossen ist oder fehlschlägt (siehe Bestätigungs-Callbacks).

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

Die von Firebase gesendete SMS kann auch lokalisiert werden. Dazu geben Sie 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 werden die Callbacks onVerificationCompleted, onVerificationFailed und onCodeSent implementiert. 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.
  • Automatischer Abruf: 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 bei einigen Mobilfunkanbietern möglicherweise nicht 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 du kannst 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 per SMS an die angegebene Telefonnummer gesendet wurde.

Wenn diese Methode aufgerufen wird, zeigen die meisten Apps eine Benutzeroberfläche an, auf der der Nutzer aufgefordert wird, den Bestätigungscode aus der SMS einzugeben. (Gleichzeitig wird möglicherweise im Hintergrund die automatische Bestätigung durchgeführt.) Nachdem der Nutzer den Bestätigungscode eingegeben hat, können Sie den Bestätigungscode und die Bestätigungs-ID, die an die Methode übergeben wurde, verwenden, um ein PhoneAuthCredential-Objekt zu erstellen. Mit diesem Objekt können Sie den Nutzer dann anmelden. 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 verificationId)

Optional. Diese Methode wird aufgerufen, nachdem die in verifyPhoneNumber angegebene Zeitüberschreitung abgelaufen ist, ohne dass onVerificationCompleted zuerst ausgelöst wurde. Auf Geräten ohne SIM-Karte wird diese Methode sofort aufgerufen, da der automatische SMS-Abruf nicht möglich ist.

Einige Apps blockieren Nutzereingaben, bis der Zeitraum für die automatische Bestätigung abgelaufen ist, und zeigen erst dann eine Benutzeroberfläche an, auf 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, sodass Sie diesen Schritt überspringen können.

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 onVerificationCompleted-Callback 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

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

  • Testen Sie die Telefonnummer-Authentifizierung, ohne Ihr Nutzungskontingent zu verbrauchen.
  • Testen Sie die Telefonnummer-Authentifizierung, ohne eine tatsächliche SMS zu senden.
  • Sie können aufeinanderfolgende Tests mit derselben Telefonnummer ausführen, ohne dass die Geschwindigkeit gedrosselt wird. Dadurch wird das Risiko einer Ablehnung während der App Store-Überprüfung minimiert, falls der Prüfer dieselbe Telefonnummer zum Testen verwendet.
  • Sie können die App ohne zusätzlichen Aufwand in Entwicklungsumgebungen testen, z. B. in einem iOS-Simulator oder einem Android-Emulator ohne Google Play-Dienste.
  • Schreiben Sie Integrationstests, ohne durch Sicherheitsprüfungen blockiert zu werden, die normalerweise für echte Telefonnummern in einer Produktionsumgebung gelten.

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

  1. Verwenden Sie fiktive Telefonnummern, die noch nicht existieren. In Firebase Authentication können Sie keine vorhandenen Telefonnummern, die von echten Nutzern verwendet werden, als Testnummern festlegen. Eine Möglichkeit besteht darin, Nummern mit der Vorwahl 555 als US-amerikanische Testtelefonnummern zu verwenden, z. B. +1 650-555-3434.
  2. Telefonnummern müssen im Hinblick auf die Länge und andere Einschränkungen korrekt formatiert sein. Sie werden genauso validiert wie die Telefonnummer eines echten Nutzers.
  3. Sie können bis zu 10 Telefonnummern für die Entwicklung hinzufügen.
  4. Verwende Testtelefonnummern und ‑codes, die schwer zu erraten sind, und ändere sie regelmäßig.

Fiktive Telefonnummern und Bestätigungscodes erstellen

  1. Rufen Sie in der Firebase-Konsole Sicherheit > Authentifizierung auf.
  2. Aktivieren Sie auf dem Tab Anmeldemethode den Anmeldeanbieter Telefon, falls noch nicht geschehen.
  3. Maximieren Sie den Bereich Telefonnummern für Tests.
  4. Geben Sie die Telefonnummer an, die Sie testen möchten, z. B. +1 650-555-3434.
  5. Geben Sie den sechsstelligen Bestätigungscode für diese Nummer an, 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, indem Sie den Mauszeiger auf die entsprechende Zeile bewegen und auf das Papierkorbsymbol klicken.

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 dass Kontingentprobleme oder Drosselungen auftreten. Sie können auch direkt über einen iOS-Simulator oder Android-Emulator testen, ohne dass die 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 dieselben Verhaltensweisen und Eigenschaften wie ein Nutzer mit einer echten 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 ein echter Nutzer mit Telefonnummer.

Eine weitere Möglichkeit besteht darin, für diese Nutzer eine Testrolle über benutzerdefinierte Anforderungen festzulegen, um sie als Fake-Nutzer zu kennzeichnen, wenn Sie den Zugriff weiter einschränken möchten.

Verwenden Sie die Methode forceRecaptchaFlowForTesting(), um den reCAPTCHA-Ablauf zu Testzwecken manuell 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. Diese APIs deaktivieren die App-Überprüfung, indem sie die reCAPTCHA-Anforderung im Web und die stillen Push-Benachrichtigungen in iOS deaktivieren. Dadurch werden Automatisierungstests in diesen Abläufen möglich und einfacher zu implementieren. Außerdem können damit Abläufe für die sofortige Bestätigung auf Android-Geräten getestet werden.

Rufen Sie unter Android setAppVerificationDisabledForTesting() vor dem Aufruf von signInWithPhoneNumber auf. Dadurch wird die App-Überprüfung automatisch deaktiviert, sodass Sie die Telefonnummer übergeben können, ohne sie manuell lösen zu müssen. Auch wenn Play Integrity 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 anrufen, wird der Callback onCodeSent ausgelöst, in dem Sie den entsprechenden Bestätigungscode angeben müssen. Dies ermöglicht Tests 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

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 kannst du Abläufe für den automatischen Abruf in Android testen, indem du die fiktive Nummer und den entsprechenden Bestätigungscode für den automatischen Abruf festlegst. Rufe dazu setAutoRetrievedSmsCodeForPhoneNumber auf.

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

Achte darauf, dass diese Option deaktiviert ist und keine fiktiven Telefonnummern in deiner App hartcodiert sind, wenn du deine App im Google Play Store veröffentlichst.

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

Nachdem sich ein Nutzer zum ersten Mal angemeldet hat, wird ein neues Nutzerkonto erstellt und mit den Anmeldedaten verknüpft, mit denen sich der Nutzer angemeldet hat, also mit dem Nutzernamen und dem Passwort, der Telefonnummer oder den Informationen des Authentifizierungsanbieters. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um einen Nutzer in jeder App in Ihrem Projekt zu identifizieren, unabhängig davon, wie sich der Nutzer anmeldet.

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

  • In Ihren Sicherheitsregeln für Firebase Realtime Database und Cloud Storage 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.

Wenn Sie einen Nutzer abmelden möchten, rufen Sie signOut auf:

Kotlin

Firebase.auth.signOut()

Java

FirebaseAuth.getInstance().signOut();