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

Du kannst Firebase Authentication verwenden, um einen Nutzer durch Senden einer SMS anzumelden auf das Smartphone der Nutzenden übertragen. Der Nutzer meldet sich mit einem einmaligen Code an, der im SMS.

Am einfachsten können Sie die Anmeldung mit einer Telefonnummer in Ihrer App mit FirebaseUI mit einem Widget für die Anmeldung, das Anmeldevorgänge für das Smartphone implementiert. Zahlenanmeldung sowie passwortbasierte und föderierte Anmeldung. Dieses Dokument wird beschrieben, wie Sie mit dem Firebase SDK einen Anmeldevorgang für eine Telefonnummer implementieren.

Hinweis

1. Falls noch nicht geschehen, Fügen Sie Firebase zu Ihrem Android-Projekt hinzu.
2. In der Gradle-Datei des Moduls (auf App-Ebene) (normalerweise <project>/<app-module>/build.gradle.kts oder <project>/<app-module>/build.gradle) Fügen Sie die Abhängigkeit für die Firebase Authentication-Bibliothek für Android hinzu. Wir empfehlen die Verwendung des Firebase Android BoM um die Versionsverwaltung der Bibliothek zu steuern.

   dependencies {
       // Import the BoM for the Firebase platform
       implementation(platform("com.google.firebase:firebase-bom:33.2.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, Bibliotheksversionen mit der BoM zu verwalten. Dadurch wird sichergestellt, dass alle Versionen kompatibel.

   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.0.0")
   }

   Sie suchen nach einem Kotlin-spezifischen Bibliotheksmodul? Beginnt in Oktober 2023 (Firebase BoM 32.5.0) können sowohl Kotlin- als auch Java-Entwickler sind vom Modul der Hauptbibliothek abhängig (Details finden Sie in der FAQs zu dieser Initiative).
3. Wenn Sie Ihre App noch nicht mit Ihrem Firebase-Projekt verbunden haben, tun Sie dies über Firebase-Konsole
4. Falls Sie den SHA-1-Hash Ihrer App noch nicht in der Firebase-Konsole festgelegt haben, gehen Sie so vor: tun Sie dies. Siehe Client authentifizieren, um Informationen zum Ermitteln des SHA-1-Codes Ihrer App zu erhalten Hashwert.

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 Nutzern Profilen hinzugefügt, kann sich jeder Nutzer, der SMS-Nachrichten empfangen kann, über Telefonnummer des Geräts.

Wenn Sie sich in Ihrer App über eine Telefonnummer anmelden, sollten Sie diese anbieten und sicherere Anmeldemethoden nutzen und die Nutzer über die Sicherheit informieren, welche Nachteile es bei der Anmeldung über die Telefonnummer hat.

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

Für die Authentifizierung der Telefonnummer muss Firebase in der Lage sein, zu bestätigen, Anfragen zur Anmeldung mit einer Telefonnummer stammen von Ihrer App. Es gibt drei Möglichkeiten, Firebase Authentication erreicht dies:

• Play Integrity API: Wenn ein Nutzer ein Gerät hat, auf dem Google Play services installiert ist, und Firebase Authentication kann das Gerät mit dem Play Integrity API mit der Telefonnummer anmelden können. Die Play Integrity API wird für ein Projekt von Google aktiviert, Firebase Authentication, nicht für Ihr Projekt. Dies trägt zu keiner Play Integrity API bei Kontingente für Ihr Projekt. 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 du den SHA-256-Fingerabdruck deiner App noch nicht angegeben hast, kannst du Play Integrity verwenden aus der Projekt Einstellungen der Firebase-Konsole Weitere Informationen zum Abrufen des SHA-256-Fingerabdrucks Ihrer App finden Sie unter Client authentifizieren.

• reCAPTCHA-Überprüfung: Falls Play Integrity nicht verwendet werden kann, Beispiel: Ein Nutzer hat ein Gerät, ohne Google Play services installiert zu haben, Firebase Authentication verwendet eine reCAPTCHA-Überprüfung, um die Anmeldung per Smartphone abzuschließen. Die reCAPTCHA-Aufgabe kann ohne dass die Nutzenden etwas lösen müssen. Beachten Sie, dass für diesen Ablauf Ihrer App ein SHA-1 zugewiesen ist. Außerdem muss Ihr API-Schlüssel uneingeschränkt oder für PROJECT_ID.firebaseapp.com auf die Zulassungsliste gesetzt sein.

  Einige 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 (über Authentication SDK Version 21.2.0 oder höher).
  • Wenn das abgerufene SafetyNet-Token nicht gültig war (in Authentication SDK-Versionen < v21.2.0).

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

Fehlerbehebung

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

  Dies kann auftreten, wenn der reCAPTCHA-Ablauf erfolgreich abgeschlossen, der Nutzer aber nicht zurück zur nativen Anwendung weitergeleitet wird. In diesem Fall wird der Nutzer zur Fallback-URL PROJECT_ID.firebaseapp.com/__/auth/handler weitergeleitet. In Firefox-Browsern ist das Öffnen nativer App-Links standardmäßig deaktiviert. Wenn der Fehler oben in Firefox angezeigt wird, folgen Sie der Anleitung unter Firefox für Android zum Öffnen von Links in systemeigenen Apps einrichten, um das Öffnen von App-Links zu aktivieren.

Bestätigungscode an die Telefonnummer des Nutzers senden

Um die Anmeldung über die Telefonnummer zu starten, müssen Sie dem Nutzer eine Oberfläche einblenden, um ihre Telefonnummer einzugeben. Als Best Practice gelten unterschiedliche rechtliche Anforderungen. und die Erwartungen der Nutzenden zu definieren, sollten Sie sie informieren, erhalten sie zur Bestätigung per SMS fallen Gebühren an.

Übergeben Sie dann die Telefonnummer an die Methode PhoneAuthProvider.verifyPhoneNumber, um Firebase zu bitten, die Telefonnummer des Nutzers zu bestätigen. 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 kommt nicht zum Einsatz: wenn Sie sie aufrufen, mehrmals, wie z. B. bei der onStart-Methode einer Aktivität, Bei der Methode verifyPhoneNumber wird keine zweite SMS gesendet, es sei denn, Zeitüberschreitung bei der ursprünglichen Anfrage.

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. Speichere dann die Flagge in der Aktivität onSaveInstanceState und stellen Sie das Flag wieder her in: onRestoreInstanceState. Gehen Sie schließlich in der onStart-Methode prüfen, ob die Überprüfung bereits läuft Rufen Sie in diesem Fall noch einmal verifyPhoneNumber auf. Vergessen Sie nicht, die Markierung zu löschen, abgeschlossen ist oder fehlschlägt (siehe Bestätigungs-Callbacks.

Um die Bildschirmdrehung und andere Fälle von Neustarts von Aktivitäten einfach zu handhaben, Ihre Aktivität an die Methode verifyPhoneNumber übergeben. Die Callbacks wird automatisch getrennt, wenn die Aktivität beendet wird, sodass Sie frei Benutzeroberfläche schreiben können in den Callback-Methoden enthalten ist.

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

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 du PhoneAuthProvider.verifyPhoneNumber anrufst, musst du außerdem eine Instanz von OnVerificationStateChangedCallbacks angeben, die enthält Implementierungen der Callback-Funktionen, die die Ergebnisse von der Anfrage. 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ätigungs-Callbacks

In den meisten Apps implementierst du das onVerificationCompleted, onVerificationFailed- und onCodeSent-Callbacks. Ich kann auch onCodeAutoRetrievalTimeOut implementieren, je nachdem, App-Anforderungen erfüllen.

onVerificationCompleted(PhoneAuthCredential)

Diese Methode wird in zwei Situationen aufgerufen:

• Sofortige Bestätigung: Manchmal kann die Telefonnummer sofort bestätigt werden. ohne einen Bestätigungscode senden oder eingeben zu müssen.
• 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. Dabei werden die SMS Retriever API, die enthält einen 11-stelligen Hash-Wert am Ende der SMS-Nachricht.

onVerificationFailed(FirebaseException)

Diese Methode wird als Reaktion auf eine ungültige Bestätigungsanfrage aufgerufen, z. B. als Anforderung mit einer ungültigen Telefonnummer oder einem ungültigen Bestätigungscode.

onCodeSent(String verificationId, PhoneAuthProvider.ForceResendingToken)

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

Wenn diese Methode aufgerufen wird, zeigen die meisten Apps eine Benutzeroberfläche an, auf der der Nutzer um den Bestätigungscode aus der SMS einzugeben. (Gleichzeitig erfolgt die automatische Bestätigung möglicherweise im Hintergrund.) Nachdem die Nutzenden den Bestätigungscode eingibt, können Sie diesen Bestätigungs-ID, die an die Methode zur Erstellung eines PhoneAuthCredential-Objekt, mit dem Sie sich wiederum anmelden können Nutzenden. Einige Apps warten jedoch, bis onCodeAutoRetrievalTimeOut wird aufgerufen, bevor das Ereignis UI für Bestätigungscode (nicht empfohlen)

onCodeAutoRetrievalTimeOut(String verificationId)

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

Einige Apps blockieren Nutzereingaben, bis der Zeitraum für die automatische Bestätigung abgelaufen ist. und erst dann eine UI anzeigen, auf der der Nutzer zur Eingabe des Bestätigungscodes aufgefordert wird. aus der SMS-Nachricht (nicht empfohlen).

PhoneAuthCredential-Objekt erstellen

Nachdem der Nutzer den Bestätigungscode eingegeben hat, den Firebase an das erstellen Sie mithilfe der Bestätigungsmethode ein PhoneAuthCredential-Objekt. und die Bestätigungs-ID, die an die onCodeSent oder onCodeAutoRetrievalTimeOut-Callback. (Wenn onVerificationCompleted wird angerufen, Sie erhalten eine PhoneAuthCredential-Objekt direkt, sodass Sie diesen Schritt überspringen können.)

Rufen Sie zum Erstellen des PhoneAuthCredential-Objekts PhoneAuthProvider.getCredential:

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

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 weitergibst:

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

Mit fiktiven Telefonnummern testen

Über die Firebase-Konsole können Sie fiktive Telefonnummern für die Entwicklung einrichten. Mit fiktivem Smartphone testen Zahlen bietet folgende Vorteile:

• Testen Sie die Authentifizierung der Telefonnummer, ohne Ihr Nutzungskontingent zu verbrauchen.
• Testen Sie die Authentifizierung der Telefonnummer, ohne eine SMS zu senden.
• Aufeinanderfolgende Tests mit derselben Telefonnummer ausführen, ohne dass dies gedrosselt wird. Dieses minimiert das Risiko einer Ablehnung während der Überprüfung im App-Shop, falls der Prüfer die App Telefonnummer für den Test.
• 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.
• Integrationstests schreiben, ohne durch normale Sicherheitsprüfungen blockiert zu werden echte Telefonnummern in einer Produktionsumgebung verwenden.

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

1. Verwenden Sie Telefonnummern, die tatsächlich fiktiv sind und noch nicht vergeben wurden. In Firebase Authentication ist es nicht möglich, vorhandene Telefonnummern, die von echten Nutzern verwendet werden, als Testnummern festzulegen. Eine Möglichkeit besteht darin, 555-Präfixnummern als US-Testtelefonnummern zu verwenden. Beispiel: +1 650 555 3434
2. Telefonnummern müssen im Hinblick auf Länge und andere Einschränkungen. Sie durchlaufen weiterhin dieselbe Überprüfung wie die Telefonnummer eines echten Nutzers.
3. Sie können bis zu zehn Telefonnummern für die Entwicklungszwecke hinzufügen.
4. Verwenden Sie Testtelefonnummern/-codes, die schwer zu erraten und zu ändern sind häufig verwendet wird.

Fiktive Telefonnummern und Bestätigungscodes erstellen

1. Öffnen Sie in der Firebase-Konsole das Authentifizierung.
2. Aktivieren Sie auf dem Tab Anmeldemethode den Telefonanbieter, falls Sie dies noch nicht getan haben.
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 ein, 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 sofort mit der Verwendung einer fiktiven Telefonnummer in Ihrer Anwendung beginnen. So können Sie manuelle Tests in Entwicklungsphasen ohne Kontingentprobleme oder Drosselung durchführen. Sie können Tests auch ohne die Google Play-Dienste direkt über einen iOS-Simulator oder einen Android-Emulator durchführen. installiert haben.

Wenn Sie die fiktive Telefonnummer angeben und den Bestätigungscode senden, wird keine SMS gesendet. Sie müssen stattdessen den zuvor konfigurierten Bestätigungscode angeben, um die Unterschrift abzuschließen. .

Nach Abschluss der Anmeldung wird ein Firebase-Nutzer mit dieser Telefonnummer erstellt. Die das gleiche Verhalten und die gleichen Eigenschaften wie ein echter Telefonnummern-Nutzer und kann auf Realtime Database/Cloud Firestore und anderen Diensten auf dieselbe Weise verwenden. Das während des hat dieser Prozess dieselbe Signatur wie ein echter Nutzer einer Telefonnummer.

Alternativ können Sie eine Testrolle über ein benutzerdefiniertes Behauptungen auf diese Nutzer, um sie als gefälschte Nutzer zu unterscheiden, wenn Sie Zugriff haben.

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. Bei diesen APIs wird die App-Überprüfung deaktiviert, indem das reCAPTCHA deaktiviert wird im Web und stille Push-Benachrichtigungen unter iOS. Dadurch werden automatisierte Tests in und einfacher zu implementieren. Darüber hinaus ermöglichen sie es, Instant- für die Bestätigung unter Android.

Rufen Sie unter Android setAppVerificationDisabledForTesting() vor dem signInWithPhoneNumber-Anruf auf. Dadurch wird die App-Überprüfung automatisch deaktiviert, So können Sie die Telefonnummer übergeben, ohne sie manuell eingeben zu müssen. Obwohl Play Integrity und reCAPTCHA sind deaktiviert. Die Verwendung einer echten Telefonnummer funktioniert trotzdem nicht. um die Anmeldung abzuschließen. Mit dieser API können nur fiktive Telefonnummern verwendet werden.

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

Wenn verifyPhoneNumber mit einer fiktiven Nummer aufgerufen wird, wird das Ereignis onCodeSent-Callback, bei dem du die entsprechende Bestätigung vorlegen musst Code. Dies ermöglicht Tests 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

Außerdem können Sie automatische Abrufabläufe in Android testen, indem Sie die fiktive Zahl und erhalten Sie über den Aufruf setAutoRetrievedSmsCodeForPhoneNumber

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

Diese Funktion darf deaktiviert sein und es dürfen keine fiktiven Telefonnummern hartcodiert sein. wenn Sie Ihre App 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 Nutzer zum ersten Mal angemeldet hat, wird ein neues Nutzerkonto erstellt und die mit den Anmeldedaten verknüpft sind, d. h. Nutzername und Passwort, oder Authentifizierungsanbieter-Informationen – also für den Nutzer, mit dem sich der Nutzer angemeldet hat. Diese neue -Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um in jeder App in Ihrem Projekt einen Nutzer erreichen, unabhängig davon, wie er sich anmeldet.

• Die grundlegenden Profilinformationen der Nutzer finden Sie in Ihren Apps über die FirebaseUser-Objekt. Weitere Informationen finden Sie unter . Nutzer verwalten.

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

Sie können Nutzern erlauben, sich mit Mehrfachauthentifizierung in Ihrer App anzumelden indem Sie die Anmeldedaten des Authentifizierungsanbieters mit einem eines bestehenden Nutzerkontos.

Rufen Sie auf, um einen Nutzer abzumelden. signOut:

Firebase.auth.signOut()
MainActivity.kt

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