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.

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

Hinweis

  1. Fügen Sie Ihrem Android-Projekt Firebase hinzu, falls noch nicht geschehen.
  2. Fügen Sie in der Gradle-Datei des 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 Versionierung der Bibliothek zu steuern. 
    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.7.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 Firebase BoM nicht verwenden, müssen Sie jede Firebase-Bibliotheksversion in der entsprechenden Abhängigkeitszeile angeben.

    Wenn Sie in Ihrer App mehrere Firebase-Bibliotheken verwenden, empfehlen wir Ihnen dringend, die Bibliotheksversionen mithilfe der BoM zu verwalten. 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:23.1.0")
}
         Sie suchen nach einem Kotlin-spezifischen Bibliotheksmodul? Ab Oktober 2023 (Firebase BoM 32.5.0) können sowohl Kotlin- als auch Java-Entwickler das Hauptbibliotheksmodul verwenden. Weitere Informationen finden Sie in den häufig gestellten Fragen zu dieser Initiative.
  3. Wenn Sie Ihre App noch nicht mit Ihrem Firebase-Projekt verknüpft haben, tun Sie dies in der Firebase Console.
  4. Wenn Sie den SHA-1-Hash Ihrer App noch nicht in der Firebase Console festgelegt haben, tun Sie dies jetzt. Informationen zum Abrufen des SHA-1-Hashes Ihrer App finden Sie unter Client authentifizieren.

Sicherheitsbedenken

Die Authentifizierung mit nur 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 standortbasierte Anmeldung per Telefonnummer anbieten, sollten Sie sie zusammen mit sichereren Anmeldemethoden anbieten und die Nutzer über die Sicherheitsrisiken der Anmeldung per Telefonnummer informieren.

Anmeldung per Telefonnummer für Ihr Firebase-Projekt aktivieren

Damit Nutzer per SMS angemeldet werden können, müssen Sie zuerst die Anmeldemethode „Telefonnummer“ für Ihr Firebase-Projekt aktivieren:

  1. Öffnen Sie in der Firebase Console den Bereich Authentifizierung.
  2. Aktivieren Sie auf der Seite Anmeldemethode die Anmeldemethode Telefonnummer.

App-Überprüfung aktivieren

Damit die Telefonnummernauthentifizierung verwendet werden kann, muss Firebase prüfen können, ob Anmeldeanfragen über Telefonnummern von Ihrer App stammen. Firebase Authentication bietet dazu drei Möglichkeiten:

  • Play Integrity API: Wenn ein Nutzer ein Gerät mit installierter 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 ist von Firebase Authentication in einem Google-eigenen Projekt aktiviert, nicht in Ihrem Projekt. Dies trägt nicht zu den Play Integrity API-Kontingenten Ihres Projekts bei. Play Integrity-Unterstützung ist mit dem Authentication SDK 21.2.0 oder höher (Firebase BoM 31.4.0 oder höher) verfügbar.

    Wenn Sie die Play Integrity API verwenden möchten und den SHA-256-Fingerabdruck Ihrer App noch nicht angegeben haben, können Sie dies in den Projekteinstellungen der Firebase-Konsole tun. Weitere Informationen zum Abrufen des SHA-256-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 hat, auf dem Google Play services nicht installiert ist, verwendet Firebase Authentication eine reCAPTCHA-Überprüfung, um die Anmeldung auf dem Smartphone abzuschließen. Die reCAPTCHA-Herausforderung kann oft abgeschlossen werden, ohne dass der Nutzer etwas lösen muss. Für diesen Ablauf muss Ihrer Anwendung eine SHA-1-Signatur zugewiesen sein. Außerdem muss Ihr API-Schlüssel uneingeschränkt oder für PROJECT_ID.firebaseapp.com auf die Zulassungsliste gesetzt sein.

    Beispiele für Szenarien, in denen reCAPTCHA ausgelöst wird:

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

    Wenn SafetyNet oder Play Integrity für die App-Bestätigung verwendet wird, wird das Feld %APP_NAME% in der SMS-Vorlage mit dem App-Namen ausgefüllt, der anhand von 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-Bestätigungsvorgang mit forceRecaptchaFlowForTesting erzwingen. Sie können die App-Überprüfung (bei Verwendung fiktiver Telefonnummern) mit setAppVerificationDisabledForTesting deaktivieren.

Fehlerbehebung

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

    Das kann passieren, 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 nativen Apps standardmäßig deaktiviert. Wenn Sie in Firefox die oben genannte Fehlermeldung sehen, 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.

Senden Sie einen Bestätigungscode an das Mobiltelefon des Nutzers.

Wenn Sie die Anmeldung per Telefonnummer starten möchten, zeigen Sie dem Nutzer eine Benutzeroberfläche an, in der er aufgefordert wird, seine Telefonnummer einzugeben. Die rechtlichen Anforderungen variieren. Als Best Practice und um die Erwartungen Ihrer Nutzer zu steuern, sollten Sie sie darüber informieren, dass sie bei der Anmeldung per Smartphone möglicherweise eine SMS zur Bestätigung erhalten und dass dabei die üblichen Gebühren anfallen.

Übergeben Sie dann die Telefonnummer an die Methode PhoneAuthProvider.verifyPhoneNumber, um Firebase zu bitten, 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)
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 onStart-Methode einer Aktivität, sendet die Methode verifyPhoneNumber nur dann eine zweite SMS, wenn die ursprüngliche Anfrage abgelaufen ist.

Sie können dieses Verhalten verwenden, um die Anmeldung per Telefonnummer fortzusetzen, wenn Ihre App geschlossen wird, bevor sich der Nutzer anmelden kann (z. B. wenn er seine SMS-App verwendet). Nachdem du verifyPhoneNumber aufgerufen hast, setze ein Flag, 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 abschließend in der Methode onStart Ihrer Aktivität, ob die Bestätigung bereits läuft. Falls ja, rufen Sie verifyPhoneNumber noch einmal auf. Heben Sie die Markierung auf, wenn die Bestätigung abgeschlossen oder fehlgeschlagen ist (siehe Callbacks für die Bestätigung).

Wenn Sie die Bildschirmdrehung und andere Neustarts der Aktivität problemlos verarbeiten möchten, passen Sie Ihre Aktivität an die Methode verifyPhoneNumber an. Die Rückrufe werden automatisch getrennt, wenn die Aktivität beendet wird. Sie können also in den Rückrufmethoden Code für UI-Übergänge 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 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
    }
}
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 onVerificationCompleted-, onVerificationFailed- und onCodeSent-Callbacks. 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 Google Play-Dienste 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. Dazu wird die SMS Retriever API verwendet, die am Ende der SMS-Nachricht einen 11-stelligen Hash enthält.
In beiden Fällen wurde die Telefonnummer des Nutzers erfolgreich bestätigt. Du kannst 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, wird in den meisten Apps eine Benutzeroberfläche angezeigt, auf der der Nutzer aufgefordert wird, den Bestätigungscode aus der SMS einzugeben. Gleichzeitig läuft möglicherweise die automatische Bestätigung im Hintergrund ab. 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 die Benutzeroberfläche für den Bestätigungscode angezeigt wird (nicht empfohlen).

onCodeAutoRetrievalTimeOut(String verificationId)

Optional. Diese Methode wird aufgerufen, nachdem die für verifyPhoneNumber angegebene Zeitspanne abgelaufen ist, ohne dass onVerificationCompleted zuvor 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 die Zeit für die automatische Bestätigung abgelaufen ist, und zeigen dann erst 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 sein Smartphone 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, wird direkt ein PhoneAuthCredential-Objekt zurückgegeben. 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 du ein PhoneAuthCredential-Objekt erhalten hast, entweder im onVerificationCompleted-Callback oder durch Aufruf von PhoneAuthProvider.getCredential, führe den Anmeldevorgang durch, indem du das PhoneAuthCredential-Objekt an FirebaseAuth.signInWithCredential übergibst:

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-Konsole einrichten. Der Test mit fiktiven Telefonnummern bietet folgende Vorteile:

  • Die Authentifizierung per Telefonnummer testen, ohne das Nutzungskontingent zu verbrauchen
  • Testen Sie die Authentifizierung per Telefonnummer, ohne eine SMS zu senden.
  • Sie können aufeinanderfolgende Tests mit derselben Telefonnummer ausführen, ohne dass es zu Drosselung kommt. So wird das Risiko minimiert, dass die App bei der Überprüfung im App Store abgelehnt wird, wenn der Prüfer dieselbe Telefonnummer für die Tests verwendet.
  • Sie können Ihre Apps ohne zusätzlichen Aufwand in Entwicklungsumgebungen 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 folgende Anforderungen erfüllen:

  1. Verwenden Sie Telefonnummern, die tatsächlich fiktiv sind und noch nicht vergeben wurden. Mit Firebase Authentication können Sie keine Telefonnummern festlegen, die von echten Nutzern verwendet werden. Eine Möglichkeit besteht darin, als US-Testtelefonnummern Nummern mit dem Präfix „555“ zu verwenden, z. B.: +1 650-555-3434
  2. Telefonnummern müssen hinsichtlich Länge und anderer Einschränkungen richtig formatiert sein. Sie werden jedoch genauso wie die Telefonnummer eines echten Nutzers überprüft.
  3. Sie können bis zu zehn Telefonnummern für die Entwicklungszwecke hinzufügen.
  4. Verwenden Sie Testtelefonnummern/-codes, die schwer zu erraten sind, und ändern Sie diese häufig.

Erstellen Sie fiktive Telefonnummern und Bestätigungscodes.

  1. Öffnen Sie in der Firebase Console den Bereich 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. Falls erforderlich, können Sie die Telefonnummer und den Code löschen. Bewegen Sie dazu den Mauszeiger auf die entsprechende Zeile und klicken Sie auf das Papierkorbsymbol.

Manuelle Tests

Sie können direkt mit der Verwendung einer fiktiven Telefonnummer in Ihrer Anwendung beginnen. So können Sie während der Entwicklungsphase manuelle Tests durchführen, ohne auf Kontingentprobleme oder Drosselung zu stoßen. Sie können auch direkt über einen iOS-Simulator oder Android-Emulator testen, ohne dass Google Play-Dienste installiert sind.

Wenn Sie die fiktive Telefonnummer angeben und den Bestätigungscode senden, wird keine 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 bei diesem Vorgang erstellte ID-Token hat dieselbe Signatur wie ein Nutzer mit einer echten Telefonnummer.

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

Wenn Sie den reCAPTCHA-Vorgang zum Testen manuell auslösen möchten, verwenden Sie die Methode forceRecaptchaFlowForTesting(). 

// 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 Telefonauthentifizierung unterstützen. Mit diesen APIs wird die App-Überprüfung deaktiviert, indem die reCAPTCHA-Anforderung im Web und die Funktion für lautlose Push-Benachrichtigungen unter iOS deaktiviert wird. Dadurch sind automatisierte Tests in diesen Abläufen möglich und einfacher zu implementieren. Außerdem können Sie damit Instant-Bestätigungsabläufe auf Android-Geräten testen.

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

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

Wenn Sie verifyPhoneNumber mit einer fiktiven Nummer anrufen, wird der Rückruf von onCodeSent ausgelöst, bei 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);
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 kannst du die Abläufe für die automatische Abholung unter Android testen, indem du die fiktive Nummer und den entsprechenden Bestätigungscode für die automatische Abholung festlegst, indem du setAutoRetrievedSmsCodeForPhoneNumber anrufst.

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

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

Nachdem sich ein Nutzer zum ersten Mal angemeldet hat, wird ein neues Nutzerkonto erstellt und mit den Anmeldedaten verknüpft, d. h. mit dem Nutzernamen und Passwort, der Telefonnummer oder den Informationen zum Authentifizierungsanbieter, mit denen sich der Nutzer angemeldet hat. 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 er sich anmeldet.

  • In Ihren Apps können Sie die grundlegenden Profilinformationen des Nutzers über das 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 über mehrere Authentifizierungsanbieter 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()
MainActivity.kt

Java

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