Authentifizieren Sie sich bei Firebase auf Android mithilfe einer Telefonnummer

Sie können die Firebase-Authentifizierung verwenden, um einen Benutzer anzumelden, indem Sie eine SMS-Nachricht an das Telefon des Benutzers senden. Der Benutzer meldet sich mit einem Einmalcode an, der in der SMS-Nachricht enthalten ist.

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

Bevor Sie beginnen

1. Fügen Sie Ihrem Android-Projekt Firebase hinzu , falls Sie dies noch nicht getan haben .
2. Fügen Sie in Ihrer Modul-Gradle-Datei (auf App-Ebene) (normalerweise <project>/<app-module>/build.gradle ) die Abhängigkeit für die Firebase Authentication Android-Bibliothek hinzu. Wir empfehlen die Verwendung der Firebase Android BoM zur Steuerung der Bibliotheksversionierung.

   Kotlin+KTX

   dependencies {
       // Import the BoM for the Firebase platform
       implementation platform('com.google.firebase:firebase-bom:32.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-ktx'
   }
   

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

   (Alternative) Fügen Sie Firebase-Bibliotheksabhängigkeiten hinzu , ohne die Stückliste zu verwenden

   Wenn Sie die Firebase-Stückliste nicht verwenden möchten, müssen Sie jede Firebase-Bibliotheksversion in ihrer Abhängigkeitszeile angeben.

   Beachten Sie, dass wir bei Verwendung mehrerer Firebase-Bibliotheken in Ihrer App dringend empfehlen, die BoM zum Verwalten von Bibliotheksversionen zu verwenden, wodurch sichergestellt wird, 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-ktx:22.0.0'
   }
   

   Java

   dependencies {
       // Import the BoM for the Firebase platform
       implementation platform('com.google.firebase:firebase-bom:32.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'
   }
   

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

   (Alternative) Fügen Sie Firebase-Bibliotheksabhängigkeiten hinzu , ohne die Stückliste zu verwenden

   Wenn Sie die Firebase-Stückliste nicht verwenden möchten, müssen Sie jede Firebase-Bibliotheksversion in ihrer Abhängigkeitszeile angeben.

   Beachten Sie, dass wir bei Verwendung mehrerer Firebase-Bibliotheken in Ihrer App dringend empfehlen, die BoM zum Verwalten von Bibliotheksversionen zu verwenden, wodurch sichergestellt wird, dass alle Versionen kompatibel sind.

   dependencies {
       // Add the dependency for the Firebase Authentication library
       // When NOT using the BoM, you must specify versions in Firebase library dependencies
       implementation 'com.google.firebase:firebase-auth:22.0.0'
   }
   

3. Wenn Sie Ihre App noch nicht mit Ihrem Firebase-Projekt verbunden haben, tun Sie dies über die Firebase-Konsole .
4. Wenn Sie den SHA-1-Hash Ihrer App noch nicht in der Firebase-Konsole festgelegt haben, tun Sie dies jetzt. Informationen zum Auffinden des SHA-1-Hashs Ihrer App finden Sie unter Authentifizieren Ihres Clients .

Sicherheitsbedenken

Die Authentifizierung mit nur einer Telefonnummer ist zwar bequem, aber weniger sicher als die anderen verfügbaren Methoden, da der Besitz einer Telefonnummer leicht zwischen Benutzern übertragen werden kann. Außerdem kann sich auf Geräten mit mehreren Benutzerprofilen jeder Benutzer, der SMS-Nachrichten empfangen kann, mit der Telefonnummer des Geräts bei einem Konto anmelden.

Wenn Sie die telefonnummernbasierte Anmeldung in Ihrer App verwenden, sollten Sie sie zusammen mit sichereren Anmeldemethoden anbieten und die Benutzer über die Sicherheitskompromisse bei der Verwendung der Telefonnummernanmeldung informieren.

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

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

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

Das Kontingent für Anmeldeanfragen für Telefonnummern von Firebase ist hoch genug, dass die meisten Apps nicht betroffen sind. Wenn Sie jedoch eine sehr große Anzahl von Benutzern mit Telefonauthentifizierung anmelden müssen, müssen Sie möglicherweise Ihren Preisplan aktualisieren. Siehe Preisseite .

Aktivieren Sie die App-Überprüfung

Um die Telefonnummernauthentifizierung zu verwenden, muss Firebase überprüfen können, ob Anmeldeanforderungen für Telefonnummern von Ihrer App stammen. Es gibt drei Möglichkeiten, wie die Firebase-Authentifizierung dies erreicht:

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

  Wenn Sie den SHA-256-Fingerabdruck Ihrer App noch nicht angegeben haben, tun Sie dies in den Projekteinstellungen der Firebase-Konsole, um Play Integrity zu verwenden. Weitere Informationen zum Abrufen des SHA-256-Fingerabdrucks Ihrer App finden Sie unter Authentifizierung Ihres Clients .

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

  Einige Szenarien, in denen reCAPTCHA ausgelöst wird:

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

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

Senden Sie einen Bestätigungscode an das Telefon des Benutzers

Um die Anmeldung mit Telefonnummer zu initiieren, zeigen Sie dem Benutzer eine Oberfläche, die ihn auffordert, seine Telefonnummer einzugeben. Die gesetzlichen Anforderungen sind unterschiedlich, aber als Best Practice und um die Erwartungen Ihrer Benutzer zu erfüllen, sollten Sie sie darüber informieren, dass sie bei Verwendung der telefonischen Anmeldung möglicherweise eine SMS-Nachricht zur Überprüfung erhalten und Standardgebühren anfallen.

Übergeben Sie dann ihre Telefonnummer an die Methode PhoneAuthProvider.verifyPhoneNumber , um anzufordern, dass Firebase die Telefonnummer des Benutzers überprüft. Zum Beispiel:

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

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 wiedereintrittsfähig: Wenn Sie sie mehrmals aufrufen, z. B. in der Methode onStart einer Aktivität, sendet die Methode „ verifyPhoneNumber “ keine zweite SMS, es sei denn, die ursprüngliche Anforderung ist abgelaufen.

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

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

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

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

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 Rückruffunktionen enthält, die die Ergebnisse der Anforderung verarbeiten. Zum Beispiel:

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

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ätigungsrückrufe

In den meisten Apps implementieren Sie die Rückrufe onVerificationCompleted , onVerificationFailed und onCodeSent . Abhängig von den Anforderungen Ihrer App können Sie auch onCodeAutoRetrievalTimeOut implementieren.

onVerificationCompleted(PhoneAuthCredential)

Diese Methode wird in zwei Situationen aufgerufen:

• Sofortige Verifizierung: In einigen Fällen kann die Telefonnummer sofort verifiziert werden, ohne dass ein Verifizierungscode gesendet oder eingegeben werden muss.
• Automatischer Abruf: Auf einigen Geräten können Google Play-Dienste die eingehende Bestätigungs-SMS automatisch erkennen und die Bestätigung ohne Benutzeraktion durchführen. (Diese Funktion ist möglicherweise bei einigen Netzbetreibern nicht verfügbar.) Dabei wird die SMS-Retriever-API verwendet, die am Ende der SMS-Nachricht einen 11-stelligen Hash enthält.

onVerificationFailed(FirebaseException)

Diese Methode wird als Antwort auf eine ungültige Überprüfungsanforderung aufgerufen, z. B. eine Anforderung, die eine ungültige Telefonnummer oder einen ungültigen Überprüfungscode angibt.

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, die den Benutzer auffordert, den Bestätigungscode aus der SMS-Nachricht einzugeben. (Gleichzeitig wird möglicherweise die automatische Überprüfung im Hintergrund ausgeführt.) Nachdem der Benutzer den Überprüfungscode eingegeben hat, können Sie den Überprüfungscode und die Überprüfungs-ID verwenden, die an die Methode übergeben wurden, um ein PhoneAuthCredential Objekt zu erstellen, das Sie können wiederum verwenden, um den Benutzer anzumelden. Einige Apps warten jedoch möglicherweise, bis onCodeAutoRetrievalTimeOut aufgerufen wird, bevor sie die Benutzeroberfläche des Bestätigungscodes anzeigen (nicht empfohlen).

onCodeAutoRetrievalTimeOut(String VerificationId)

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

Einige Apps blockieren Benutzereingaben, bis der Zeitraum für die automatische Überprüfung abgelaufen ist, und zeigen erst dann eine Benutzeroberfläche an, die den Benutzer auffordert, den Überprüfungscode aus der SMS-Nachricht einzugeben (nicht empfohlen).

Erstellen Sie ein PhoneAuthCredential-Objekt

Nachdem der Benutzer den Verifizierungscode eingegeben hat, den Firebase an das Telefon des Benutzers gesendet hat, erstellen Sie ein PhoneAuthCredential Objekt mit dem Verifizierungscode und der Verifizierungs-ID, die an den onCodeSent oder onCodeAutoRetrievalTimeOut Rückruf übergeben wurden. (Wenn onVerificationCompleted aufgerufen wird, erhalten Sie direkt ein PhoneAuthCredential Objekt, sodass Sie diesen Schritt überspringen können.)

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

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

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

Melden Sie den Benutzer an

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

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

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

Testen Sie mit fiktiven Telefonnummern

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

• Testen Sie die Authentifizierung von Telefonnummern, ohne Ihr Nutzungskontingent zu verbrauchen.
• Testen Sie die Authentifizierung der Telefonnummer, ohne eine tatsächliche SMS-Nachricht zu senden.
• Führen Sie aufeinanderfolgende Tests mit derselben Telefonnummer durch, ohne gedrosselt zu werden. Dadurch wird das Risiko einer Ablehnung während des Überprüfungsprozesses im App Store minimiert, wenn der Prüfer zufällig dieselbe Telefonnummer zum Testen verwendet.
• Testen Sie problemlos in Entwicklungsumgebungen ohne zusätzlichen Aufwand, z. B. die Möglichkeit, in einem iOS-Simulator oder einem Android-Emulator ohne Google Play-Dienste zu entwickeln.
• Schreiben Sie Integrationstests, ohne durch Sicherheitsprüfungen blockiert zu werden, die normalerweise auf echte Telefonnummern in einer Produktionsumgebung angewendet werden.

Diese Anforderungen müssen fiktive Telefonnummern erfüllen:

1. Stellen Sie sicher, dass Sie fiktive Telefonnummern verwenden, die noch nicht existieren. Mit der Firebase-Authentifizierung können Sie vorhandene Telefonnummern, die von echten Benutzern verwendet werden, nicht als Testnummern festlegen. Eine Option besteht darin, 555-Vorwahlnummern als US-Testtelefonnummern zu verwenden, zum Beispiel: +1 650-555-3434
2. Telefonnummern müssen hinsichtlich der Länge und anderer Beschränkungen korrekt formatiert sein. Sie durchlaufen immer noch die gleiche Validierung wie die Telefonnummer eines echten Benutzers.
3. Sie können bis zu 10 Telefonnummern für die Entwicklung hinzufügen.
4. Verwenden Sie Testtelefonnummern/-codes, die schwer zu erraten sind, und ändern Sie diese häufig.

Erstellen Sie fiktive Telefonnummern und Bestätigungscodes

1. Öffnen Sie in der Firebase-Konsole den Abschnitt Authentifizierung .
2. Aktivieren Sie auf der Registerkarte Anmeldemethode den Telefonanbieter, falls Sie dies noch nicht getan haben.
3. Öffnen Sie das Menü Telefonnummern zum Testen des Akkordeons.
4. Geben Sie die Telefonnummer an, die Sie testen möchten, zum Beispiel: +1 650-555-3434 .
5. Geben Sie den 6-stelligen Bestätigungscode für diese spezifische Nummer ein, zum Beispiel: 654321 .
6. Fügen Sie die Nummer hinzu. Bei Bedarf können Sie die Telefonnummer und ihren Code löschen, indem Sie den Mauszeiger über die entsprechende Zeile bewegen und auf das Papierkorbsymbol klicken.

Manuelles Testen

Sie können direkt mit der Verwendung einer fiktiven Telefonnummer in Ihrer Bewerbung beginnen. Auf diese Weise können Sie während der Entwicklungsphase manuelle Tests durchführen, ohne auf Kontingentprobleme oder Drosselung zu stoßen. Sie können auch direkt von einem iOS-Simulator oder Android-Emulator aus testen, ohne dass Google Play Services installiert ist.

Wenn Sie die fiktive Telefonnummer angeben und den Bestätigungscode senden, wird keine tatsächliche SMS gesendet. Stattdessen müssen Sie den zuvor konfigurierten Bestätigungscode eingeben, um die Anmeldung abzuschließen.

Nach Abschluss der Anmeldung wird ein Firebase-Benutzer mit dieser Telefonnummer erstellt. Der Benutzer hat das gleiche Verhalten und die gleichen Eigenschaften wie ein Benutzer einer echten Telefonnummer und kann auf die gleiche Weise auf Realtime Database/Cloud Firestore und andere Dienste zugreifen. Der während dieses Vorgangs geprägte ID-Token hat die gleiche Signatur wie ein echter Telefonnummernbenutzer.

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

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

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

Integrationstest

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

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

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

Der Aufruf von verifyPhoneNumber mit einer fiktiven Nummer löst den onCodeSent Rückruf aus, bei dem Sie den entsprechenden Bestätigungscode angeben müssen. Dies ermöglicht das Testen in Android-Emulatoren.

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

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

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

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

Stellen Sie sicher, dass dies deaktiviert ist und keine fiktiven Telefonnummern in Ihrer App fest codiert sind, wenn Sie Ihre Anwendung im Google Play Store veröffentlichen.

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

// 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 Benutzer zum ersten Mal angemeldet hat, wird ein neues Benutzerkonto erstellt und mit den Anmeldeinformationen verknüpft – d. h. dem Benutzernamen und Kennwort, der Telefonnummer oder den Authentifizierungsanbieterinformationen –, mit denen sich der Benutzer angemeldet hat. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um einen Benutzer in jeder App in Ihrem Projekt zu identifizieren, unabhängig davon, wie sich der Benutzer anmeldet.

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

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

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

Um einen Benutzer abzumelden, rufen Sie signOut auf:

Firebase.auth.signOut()
MainActivity.kt

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