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

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

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

Hinweis

  1. Fügen Sie Ihrem Android-Projekt Firebase hinzu, falls noch nicht geschehen.
  2. Fügen Sie in der Gradle-Datei Ihres Moduls (auf App-Ebene) (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.0.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 von 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 von 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.0.0")
}
  3. Wenn Sie Ihre App noch nicht mit Ihrem Firebase-Projekt verknüpft haben, holen Sie das in der Firebase Console nach.
  4. Wenn Sie den SHA-1-Hash Ihrer App noch nicht in der Firebase-Konsole festgelegt haben, holen Sie das nach. Informationen zum Ermitteln des SHA-1-Hashs Ihrer App finden Sie unter Client authentifizieren.

Sicherheitsbedenken

Die Authentifizierung nur über eine Telefonnummer ist zwar praktisch, aber weniger sicher als die anderen verfügbaren Methoden, da der Besitz einer Telefonnummer leicht auf andere Nutzer übertragen werden kann. Außerdem kann sich auf Geräten mit mehreren Nutzerprofilen jeder Nutzer, der SMS empfangen kann, mit der Telefonnummer des Geräts in einem Konto anmelden.

Wenn Sie die Anmeldung per Telefonnummer in Ihrer App anbieten, 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. Öffnen Sie in der Firebase-Konsole den Abschnitt Authentifizierung.
  2. Aktivieren Sie auf der Seite Sign-in Method (Anmeldemethode) die Anmeldemethode Phone Number (Telefonnummer).

App-Überprüfung aktivieren

Damit die Telefonnummernauthentifizierung verwendet werden kann, muss Firebase bestätigen können, dass Anfragen zur Anmeldung mit einer Telefonnummer von Ihrer App stammen. Firebase Authentication bietet hierfür drei Möglichkeiten:

  • Play Integrity API: Wenn ein Nutzer ein Gerät mit Google Play services installiert 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 wird in einem Google-eigenen Projekt von Firebase Authentication aktiviert, nicht in Ihrem Projekt. Dies wird nicht auf das Play Integrity API-Kontingent Ihres Projekts angerechnet. Die Play Integrity API wird mit dem Authentication SDK 21.2.0 oder höher (Firebase BoM 31.4.0 oder höher) unterstützt.

    Wenn Sie die Play Integrity API verwenden möchten und den SHA‑256-Fingerabdruck Ihrer App noch nicht angegeben haben, tun Sie dies in der Firebase-Konsole unter Projekteinstellungen. Weitere Informationen zum Abrufen des SHA-256-Fingerabdrucks Ihrer App finden Sie unter Client authentifizieren.

  • reCAPTCHA-Bestätigung: Falls Play Integrity nicht verwendet werden kann, z. B. wenn ein Nutzer ein Gerät ohne installierte Google Play services hat, verwendet Firebase Authentication eine reCAPTCHA-Bestätigung, um den Anmeldevorgang abzuschließen. Die reCAPTCHA-Aufgabe kann oft abgeschlossen werden, ohne dass der Nutzer etwas lösen muss. Für diesen Ablauf muss ein SHA‑1-Fingerabdruck mit Ihrer Anwendung verknüpft sein. Für diesen Ablauf muss Ihr API-Schlüssel uneingeschränkt sein oder auf der Zulassungsliste für PROJECT_ID.firebaseapp.com stehen.

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

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

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

Sie können den reCAPTCHA-Bestätigungsablauf mit forceRecaptchaFlowForTesting erzwingen. Sie können die App-Bestätigung (bei Verwendung fiktiver Telefonnummern) mit setAppVerificationDisabledForTesting deaktivieren.

Fehlerbehebung

  • Fehler „Missing initial state“ bei der Verwendung von reCAPTCHA zur App-Bestätigung

    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 nativen Apps standardmäßig deaktiviert. Wenn Sie den oben genannten Fehler in Firefox sehen, folgen Sie der Anleitung unter Firefox für Android so einrichten, dass Links in nativen Apps geöffnet werden, um das Öffnen von App-Links zu aktivieren.

Bestätigungscode an das Mobiltelefon des Nutzers senden

Um die Anmeldung mit der Telefonnummer zu starten, präsentieren Sie dem Nutzer eine Schnittstelle, in der er aufgefordert wird, seine Telefonnummer einzugeben. 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 mit dem Smartphone 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 zu veranlassen, dass Firebase die Telefonnummer des Nutzers überprüft. 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)
PhoneAuthActivity.kt

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

Die Methode verifyPhoneNumber ist reentrant: Wenn Sie sie mehrmals aufrufen, z. B. in der Methode onStart einer Aktivität, wird mit der Methode verifyPhoneNumber keine zweite SMS gesendet, es sei denn, für die ursprüngliche Anfrage ist ein Zeitlimit überschritten.

Sie können dieses Verhalten nutzen, 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 onSaveInstanceState-Methode 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. Rufen Sie in diesem Fall verifyPhoneNumber noch einmal auf. Entfernen Sie das Flag, wenn die Bestätigung abgeschlossen oder fehlgeschlagen ist (siehe Bestätigungs-Callbacks).

Um die Bildschirmdrehung 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 problemlos Code für UI-Übergänge in die Callback-Methoden schreiben.

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

Kotlin

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

Java

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

Wenn Sie PhoneAuthProvider.verifyPhoneNumber aufrufen, müssen Sie auch eine Instanz von OnVerificationStateChangedCallbacks bereitstellen, 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
    }
}
PhoneAuthActivity.kt

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

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 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. Dazu wird die SMS Retriever API verwendet, die am Ende der SMS einen 11 Zeichen langen 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 Reaktion auf eine ungültige Bestätigungsanfrage aufgerufen, z. B. eine Anfrage, in der eine ungültige Telefonnummer oder ein ungültiger Bestätigungscode angegeben ist.

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, in der der Nutzer aufgefordert wird, den Bestätigungscode aus der SMS einzugeben. Gleichzeitig läuft möglicherweise im Hintergrund die automatische Bestätigung. 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 dem Sie den Nutzer anmelden können. Bei einigen Apps wird die Benutzeroberfläche für den Bestätigungscode jedoch möglicherweise erst angezeigt, wenn onCodeAutoRetrievalTimeOut aufgerufen wird. Das ist nicht empfehlenswert.

onCodeAutoRetrievalTimeOut(String verificationId)

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

Einige Apps blockieren die Nutzereingabe, bis der Zeitraum für die automatische Bestätigung abgelaufen ist. Erst dann wird eine Benutzeroberfläche angezeigt, 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 Telefon des Nutzers gesendet hat, erstellen Sie ein PhoneAuthCredential-Objekt mit dem Bestätigungscode und der Bestätigungs-ID, die an den onCodeSent- oder onCodeAutoRetrievalTimeOut-Callback ü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)
PhoneAuthActivity.kt

Java

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

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

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

Mit fiktiven Telefonnummern testen

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

  • Authentifizierung der Telefonnummer testen, ohne das Nutzungskontingent zu belasten
  • Testen Sie die Authentifizierung der Telefonnummer, 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, falls der Prüfer dieselbe Telefonnummer für Tests verwendet.
  • Sie können ganz einfach in Entwicklungsumgebungen testen, ohne zusätzlichen Aufwand. So können Sie beispielsweise in einem iOS-Simulator oder einem Android-Emulator ohne Google Play-Dienste entwickeln.
  • 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 nur fiktive Telefonnummern, die noch nicht existieren. Mit Firebase Authentication können Sie keine vorhandenen Telefonnummern, die von echten Nutzern verwendet werden, als Testnummern festlegen. Eine Möglichkeit besteht darin, Telefonnummern 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 Validierung wie die Telefonnummer eines echten Nutzers.
  3. Sie können bis zu zehn Telefonnummern für die Entwicklung hinzufügen.
  4. Verwenden Sie Testtelefonnummern/-codes, die schwer zu erraten sind, und ändern Sie diese häufig.

Fiktive Telefonnummern und Bestätigungscodes erstellen

  1. Öffnen Sie in der Firebase-Konsole den Abschnitt Authentifizierung.
  2. Aktivieren Sie auf dem Tab Anmeldemethode den Telefonanbieter, falls noch nicht geschehen.
  3. Öffnen Sie das Akkordeonmenü 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. Fügen Sie die Nummer hinzu. Bei Bedarf können Sie die Telefonnummer und den zugehörigen Code löschen, indem Sie mit dem Mauszeiger auf die entsprechende Zeile zeigen und auf das Papierkorbsymbol klicken.

Manuelle Tests

Sie können sofort damit beginnen, eine fiktive Telefonnummer in Ihrer Anwendung zu verwenden. So können Sie während der Entwicklungsphasen manuelle Tests durchführen, ohne dass es zu Kontingentproblemen oder Drosselung kommt. Sie können auch direkt über einen iOS-Simulator oder Android-Emulator ohne installierte Google Play-Dienste testen.

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 Realtime Database/Cloud Firestore und andere Dienste auf dieselbe Weise zugreifen. Das in diesem Prozess generierte ID-Token hat dieselbe Signatur wie ein echter Nutzer mit Telefonnummer.

Eine weitere Option ist, diesen Nutzern über benutzerdefinierte Anforderungen eine Testrolle zuzuweisen, um sie als Fakenutzer zu kennzeichnen, wenn Sie den Zugriff weiter einschränken möchten.

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

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

Integrationstests

Zusätzlich zu manuellen Tests bietet Firebase Authentication APIs, die Sie bei der Entwicklung von Integrationstests für die Telefonnummernauthentifizierung unterstützen. Mit diesen APIs wird die App-Überprüfung deaktiviert, indem die reCAPTCHA-Anforderung im Web und die unregelmäßigen Push-Benachrichtigungen unter iOS deaktiviert werden. So sind automatisierte Tests in diesen Abläufen möglich und lassen sich leichter implementieren. Außerdem ermöglichen sie das Testen von Sofortbestätigungsabläufen unter Android.

Rufen Sie unter Android setAppVerificationDisabledForTesting() vor dem Aufruf von signInWithPhoneNumber auf. Dadurch wird die App-Bestätigung automatisch deaktiviert und Sie können die Telefonnummer übergeben, ohne sie manuell zu bestätigen. Auch wenn Play Integrity und reCAPTCHA deaktiviert sind, kann die Anmeldung nicht abgeschlossen werden, wenn Sie eine echte Telefonnummer verwenden. 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 onCodeSent-Callback ausgelöst, in dem Sie den entsprechenden Bestätigungscode angeben müssen. So können Sie Tests in Android-Emulatoren durchführen.

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

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)
MainActivity.kt

Außerdem können Sie Flows für das automatische Abrufen in 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 PhoneAuthCredential ausgelöst. Das funktioniert nur mit fiktiven Telefonnummern.

Achten Sie darauf, dass diese Funktion deaktiviert ist und keine fiktiven Telefonnummern in Ihrer App fest codiert sind, wenn Sie Ihre App 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);
MainActivity.java

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)
MainActivity.kt

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, also mit dem Nutzernamen und 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 allen Apps 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 FirebaseUser-Objekt abrufen. Weitere Informationen finden Sie unter Nutzer verwalten.

  • In Ihren 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()
MainActivity.kt

Java

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