S'authentifier avec Firebase sur Android à l'aide d'un numéro de téléphone

Vous pouvez utiliser Firebase Authentication pour connecter un utilisateur en envoyant un SMS au téléphone de l'utilisateur. L'utilisateur se connecte à l'aide d'un code à usage unique contenu dans le message SMS.

Le moyen le plus simple d'ajouter un numéro de téléphone à votre application est d'utiliser FirebaseUI qui inclut un widget de connexion qui implémente les flux de connexion pour les la connexion avec un numéro, ainsi que la connexion fédérée et basée sur un mot de passe. Ce document explique comment implémenter une procédure de connexion par numéro de téléphone à l'aide du SDK Firebase.

Les numéros de téléphone fournis par les utilisateurs finaux pour l'authentification seront envoyés et stockés par Google afin d'améliorer la prévention du spam et des abus dans les services Google, y compris, mais sans s'y limiter, Firebase. Les développeurs doivent s'assurer d'avoir obtenu le consentement approprié de l'utilisateur final avant d'utiliser le service de connexion par numéro de téléphone Firebase Authentication.

Avant de commencer

1. Si ce n'est pas déjà fait, Ajoutez Firebase à votre projet Android.
2. Dans le fichier Gradle de votre module (au niveau de l'application) (généralement <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle), ajoutez la dépendance pour la bibliothèque Firebase Authentication pour Android. Nous vous recommandons d'utiliser Firebase Android BoM pour contrôler la gestion des versions des bibliothèques.

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

   En utilisant Firebase Android BoM, votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.

   (Alternative) Ajouter des dépendances de la bibliothèque Firebase sans utiliser l'BoM

   Si vous choisissez de ne pas utiliser Firebase BoM, vous devez spécifier chaque version de la bibliothèque Firebase dans sa ligne de dépendance.

   Notez que si vous utilisez plusieurs bibliothèques Firebase dans votre application, recommandent d'utiliser BoM pour gérer les versions de la bibliothèque, ce qui garantit que toutes les versions sont compatibles.

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

   Vous recherchez un module de bibliothèque spécifique à Kotlin ? Début dans Octobre 2023 (Firebase BoM 32.5.0), les développeurs Kotlin et Java peuvent dépendent du module de bibliothèque principal (pour en savoir plus, consultez Questions fréquentes sur cette initiative).
3. Si vous n'avez pas encore associé votre application à votre projet Firebase, faites-le depuis la console Firebase.
4. Si vous n'avez pas encore défini le hachage SHA-1 de votre application dans la console Firebase, procédez comme suit : le faire. Voir Authentifier votre client pour savoir comment trouver le certificat SHA-1 de votre application le hachage.

Problèmes de sécurité

L'authentification à l'aide d'un seul numéro de téléphone, bien que pratique, est moins sécurisée que les autres méthodes disponibles, car un numéro de téléphone peut facilement être transféré d'un utilisateur à un autre. De plus, sur les appareils dotés de plusieurs profil, tout utilisateur pouvant recevoir des SMS peut se connecter à un compte en utilisant le numéro de téléphone de l’appareil.

Si vous utilisez la connexion par numéro de téléphone dans votre application, vous devez l'offrir en plus de méthodes de connexion plus sécurisées et informer les utilisateurs des compromis de sécurité liés à l'utilisation de la connexion par numéro de téléphone.

Activer la connexion par numéro de téléphone pour votre projet Firebase

Pour connecter les utilisateurs par SMS, vous devez d'abord activer la connexion par numéro de téléphone pour votre projet Firebase:

1. Dans la console Firebase, ouvrez la section Authentification.
2. Sur la page Sign-in Method (Méthode de connexion), activez le Phone Number (Numéro de téléphone). méthode de connexion.

En activant l'authentification par numéro de téléphone sur Android, vous acceptez les Conditions d'utilisation de Play Integrity.

Activer la validation des applications

Pour utiliser l'authentification par numéro de téléphone, Firebase doit pouvoir vérifier que les demandes de connexion par numéro de téléphone proviennent de votre application. Firebase Authentication y parvient de trois manières :

• API Play Integrity : si un utilisateur possède un appareil sur lequel Google Play services est installé et que Firebase Authentication peut vérifier que l'appareil est légitime avec l'API Play Integrity, la connexion avec un numéro de téléphone peut être effectuée. L'API Play Integrity est activée sur un projet appartenant à Google par Firebase Authentication, et non sur votre projet. Cela ne contribue à aucune API Play Integrity les quotas applicables à votre projet. La prise en charge de Play Integrity est disponible avec le SDK Authentication v21.2.0 ou version ultérieure (Firebase BoM v31.4.0 ou version ultérieure).

  Pour utiliser Play Integrity, si vous n'avez pas encore spécifié l'empreinte SHA-256 de votre application, faites-le dans les paramètres du projet de la console Firebase. Pour savoir comment obtenir l'empreinte SHA-256 de votre application, consultez Authentifier votre client.

• Validation reCAPTCHA: si Play Integrity ne peut pas être utilisé, par exemple, lorsqu'un utilisateur dispose d'un appareil sans Google Play services installé, Firebase Authentication utilise une validation reCAPTCHA pour terminer le processus de connexion par téléphone. Le test reCAPTCHA peut souvent être effectué sans que l'utilisateur ait à résoudre quoi que ce soit. Notez que cette procédure nécessite SHA-1 est associé à votre application. Ce flux nécessite également que votre clé API ne soit pas soumise à des restrictions ou qu'elle figure sur la liste d'autorisation pour PROJECT_ID.firebaseapp.com.

  Exemples de scénarios dans lesquels reCAPTCHA est déclenché:

  • Si Google Play services n'est pas installé sur l'appareil de l'utilisateur final.
  • Si l'application n'est pas distribuée via Google Play Store (sur le SDK Authentication v21.2.0+) :
  • Si le jeton SafetyNet obtenu n'était pas valide (sur les versions de SDK Authentication antérieures à la version 21.2.0).

  Lorsque SafetyNet ou Play Integrity est utilisé pour valider une application, le nom de l'application déterminé à partir de Google Play Store est inséré dans le champ %APP_NAME% du modèle de SMS. Dans les scénarios où reCAPTCHA est déclenché, %APP_NAME% est renseigné en tant que PROJECT_ID.firebaseapp.com.

  Authentication versions du SDK antérieures à la version 22.0.0 utilisent SafetyNet comme solution de remplacement si Play Integrity la récupération du jeton échoue. Le flux reCAPTCHA ne sera déclenché que lorsque Play Integrity ou safetyNet ne sera pas disponible. Néanmoins, assurez-vous que les deux scénarios fonctionnent correctement.
  À partir de SDK Authentication v21.2.0 (Firebase BoM v31.4.0), le paramètre "activity" est facultatif. Toutefois, si l'activité est non défini et une tentative de validation reCAPTCHA est effectuée, une Une exception FirebaseAuthMissingActivityForRecaptchaException est générée, ce qui peut être géré dans le rappel onVerificationFailed.

Vous pouvez forcer le flux de validation reCAPTCHA à l'aide de forceRecaptchaFlowForTesting Vous pouvez désactiver la validation des applications (lorsque vous utilisez des numéros de téléphone fictifs) en utilisant setAppVerificationDisabledForTesting

Dépannage

• "État initial manquant" lors de l'utilisation de reCAPTCHA pour la validation de l'application

  Cela peut se produire lorsque le flux reCAPTCHA aboutit, mais ne redirige pas l'utilisateur vers l'application native. Dans ce cas, l'utilisateur est redirigé vers l'URL de remplacement PROJECT_ID.firebaseapp.com/__/auth/handler. Dans les navigateurs Firefox, l'ouverture des liens d'application native est désactivée par défaut. Si l'erreur ci-dessus s'affiche dans Firefox, suivez la procédure décrite dans Configurer Firefox pour Android pour ouvrir les liens dans les applications natives afin d'activer l'ouverture des liens d'application.

Envoyer un code de validation sur le téléphone de l'utilisateur

Pour lancer la connexion avec un numéro de téléphone, présentez à l'utilisateur une invite de saisir son numéro de téléphone. Les exigences légales varient, mais il est recommandé d'informer vos utilisateurs qu'ils peuvent recevoir un SMS de validation s'ils utilisent la connexion par téléphone et que les tarifs standards s'appliquent.

Transmettez ensuite son numéro de téléphone à la méthode PhoneAuthProvider.verifyPhoneNumber pour demander à Firebase de le valider. Exemple :

Kotlin+KTX

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

Remarque : Consultez Firebase AuthenticationLimites pour connaître les limites d'utilisation et les quotas applicables.

La méthode verifyPhoneNumber est réentrante (si vous l'appelez), plusieurs fois, par exemple dans la méthode onStart d'une activité, La méthode verifyPhoneNumber n'enverra pas de second SMS, sauf si le La requête d'origine a expiré.

Vous pouvez utiliser ce comportement pour reprendre la procédure de connexion au numéro de téléphone si votre L'application se ferme avant que l'utilisateur puisse se connecter (par exemple, lorsqu'il utilise son application de SMS). Après avoir appelé verifyPhoneNumber, définissez une option qui indique que la validation est en cours. Ensuite, enregistrez l'indicateur dans le onSaveInstanceState et restaurez l'option dans onRestoreInstanceState Enfin, dans la méthode onStart de votre activité, vérifiez si la validation est déjà en cours. Si c'est le cas, appelez à nouveau verifyPhoneNumber. N'oubliez pas d'effacer le drapeau lorsque la vérification est terminée ou échoue (voir la section les rappels de vérification).

Pour gérer facilement la rotation de l'écran et d'autres instances de redémarrage de l'activité, transmettez votre activité à la méthode verifyPhoneNumber. Rappels sera déconnecté automatiquement à l'arrêt de l'activité, ce qui vous permettra d'écrire librement dans les méthodes de rappel.

Le SMS envoyé par Firebase peut également être localisé en spécifiant le auth via la méthode setLanguageCode de votre Auth. Compute Engine.

Kotlin+KTX

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

Lorsque vous appelez PhoneAuthProvider.verifyPhoneNumber, vous devez également fournir une instance de OnVerificationStateChangedCallbacks, qui contient des implémentations des fonctions de rappel qui gèrent les résultats de la demande. Exemple :

Kotlin+KTX

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

Rappels de validation

Dans la plupart des applications, vous implémentez onVerificationCompleted, onVerificationFailed et onCodeSent. Toi peut également implémenter onCodeAutoRetrievalTimeOut, en fonction de votre exigences de l'application.

onVerificationCompleted(PhoneAuthCredential)

Cette méthode est appelée dans deux situations:

• Validation instantanée: dans certains cas, le numéro de téléphone peut être instantanément validé sans avoir à envoyer ni à saisir de code de validation.
• Récupération automatique: sur certains appareils, les services Google Play peuvent détecter automatiquement le SMS de vérification entrant et effectuer sans intervention de l'utilisateur. (Cette fonctionnalité peut ne pas être disponible avec certains opérateurs.) Cette méthode utilise le l'API SMS Retriever, qui permet inclut un hachage de 11 caractères à la fin du message SMS.

Dans les deux cas, le numéro de téléphone de l’utilisateur a été vérifié et vous pouvez utiliser l'objet PhoneAuthCredential transmis à rappel pour connecter l'utilisateur.

onVerificationFailed(FirebaseException)

Cette méthode est appelée en réponse à une requête de validation non valide, telle que en tant que requête spécifiant un numéro de téléphone ou un code de validation non valides.

onCodeSent(String verificationId, PhoneAuthProvider.ForcereferreringToken)

Facultatif. Cette méthode est appelée après l'envoi du code de validation. par SMS au numéro de téléphone indiqué.

Lorsque cette méthode est appelée, la plupart des applications affichent une UI qui invite l'utilisateur pour saisir le code de validation envoyé par SMS. Dans le même temps, la vérification automatique se poursuit en arrière-plan.) Puis, après que l’utilisateur saisissez le code de validation, vous pouvez utiliser le code de validation transmis à la méthode pour créer PhoneAuthCredential, que vous pouvez ensuite utiliser pour vous connecter l'utilisateur. Cependant, certaines applications peuvent attendre onCodeAutoRetrievalTimeOut est appelé avant d'afficher la UI des codes de validation (non recommandé).

onCodeAutoRetrievalTimeOut(String verificationId)

Facultatif. Cette méthode est appelée après le délai avant expiration spécifié pour verifyPhoneNumber a réussi sans Déclenchement de onVerificationCompleted en premier. Sur les appareils sans carte SIM, cette méthode est appelée immédiatement, car la récupération automatique des SMS n'est pas possible.

Certaines applications bloquent les entrées utilisateur jusqu'à l'expiration du délai de validation automatique. et seulement afficher une interface utilisateur qui invite l'utilisateur à saisir le code de validation à partir du message SMS (non recommandé).

Créer un objet PhoneAuthCredential

Une fois que l'utilisateur a saisi le code de validation que Firebase a envoyé au téléphone, créez un objet PhoneAuthCredential à l'aide de la méthode et l'ID de validation transmis au onCodeSent ou onCodeAutoRetrievalTimeOut. (Quand onVerificationCompleted s'appelle, vous obtenez une PhoneAuthCredential directement. Vous pouvez donc ignorer cette étape.)

Pour créer l'objet PhoneAuthCredential, appelez PhoneAuthProvider.getCredential :

Kotlin+KTX

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

Java

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

Pour éviter les abus, Firebase limite le nombre de SMS qui peuvent être envoyés à un seul numéro de téléphone dans un certain laps de temps. Si vous dépassez cette limite, les demandes de validation de numéro de téléphone risquent d'être limitées. Si vous rencontrez ce problème pendant le développement, utilisez un autre numéro de téléphone pour test, ou réitérez la requête ultérieurement.

Connecter l'utilisateur

Après avoir obtenu un objet PhoneAuthCredential, que ce soit dans onVerificationCompleted ou en appelant PhoneAuthProvider.getCredential, suivez la procédure de connexion en transmettant l'objet PhoneAuthCredential FirebaseAuth.signInWithCredential:

Kotlin+KTX

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

Tester avec des numéros de téléphone fictifs

Vous pouvez configurer des numéros de téléphone fictifs pour le développement via la console Firebase. Test avec un téléphone fictif offrent les avantages suivants:

• Testez l'authentification par numéro de téléphone sans consommer votre quota d'utilisation.
• Testez l'authentification par numéro de téléphone sans envoyer de SMS.
• Exécutez des tests consécutifs avec le même numéro de téléphone, sans être limité. Ce réduit le risque de refus lors du processus d'examen de la plate-forme de téléchargement d'applications si l'examinateur utilise le même numéro de téléphone à des fins de test.
• Effectuez des tests facilement dans des environnements de développement, sans effort supplémentaire la possibilité de développer dans un simulateur iOS ou un émulateur Android sans les services Google Play.
• Écrire des tests d'intégration sans être bloqué par des contrôles de sécurité normalement appliqués sur de vrais numéros de téléphone dans un environnement de production.

Les numéros de téléphone fictifs doivent respecter les exigences suivantes:

1. Assurez-vous d'utiliser des numéros de téléphone fictifs et qui n'existent pas déjà. Firebase Authentication ne vous permet pas de définir des numéros de téléphone existants utilisés par des utilisateurs réels en tant que numéros de test. Vous pouvez, par exemple, utiliser les numéros préfixés 555 comme numéros de téléphone de test aux États-Unis: [phone]
2. Le format des numéros de téléphone doit respecter les règles de longueur de contraintes. Ils seront toujours soumis à la même validation que le numéro de téléphone de l'utilisateur réel.
3. Vous pouvez ajouter jusqu'à 10 numéros de téléphone pour le développement.
4. Utilisez des numéros de téléphone/codes de test difficiles à deviner et à modifier. fréquemment.

Créer des numéros de téléphone et des codes de validation fictifs

1. Dans la console Firebase, ouvrez le section Authentification.
2. Dans l'onglet Mode de connexion, activez l'opérateur téléphonique, si ce n'est pas déjà fait.
3. Ouvrez le menu de l'accordéon Numéros de téléphone à tester.
4. Indiquez le numéro de téléphone que vous souhaitez tester, par exemple: [phone].
5. Indiquez le code de validation à six chiffres correspondant à ce numéro spécifique, par exemple: 654321.
6. Ajoutez le numéro. Si nécessaire, vous pouvez supprimer le numéro de téléphone et en plaçant le pointeur de la souris sur la ligne correspondante et en cliquant sur l'icône de la corbeille.

Tests manuels

Vous pouvez commencer directement à utiliser un numéro de téléphone fictif dans votre demande. Cela vous permet effectuer des tests manuels pendant les étapes de développement sans rencontrer de problèmes de quota ou de limitation. Vous pouvez également effectuer des tests directement depuis un simulateur iOS ou un émulateur Android sans les services Google Play. installés.

Lorsque vous indiquez le numéro de téléphone fictif et envoyez le code de validation, aucun SMS n'est envoyé. Vous devrez fournir le code de validation précédemment configuré pour finaliser la signature. po.

Une fois la connexion terminée, un compte utilisateur Firebase est créé avec ce numéro de téléphone. La l'utilisateur a le même comportement et les mêmes propriétés qu'un utilisateur de numéro de téléphone réel et peut accéder Realtime Database/Cloud Firestore et les autres services de la même manière. Le jeton d'ID créé lors de ce processus a la même signature qu'un utilisateur disposant d'un numéro de téléphone réel.

Comme le jeton d'identification du numéro de téléphone fictif a la même signature qu'un utilisateur de numéro de téléphone réel, il est important de stocker ces numéros et de les recycler en continu.

Vous pouvez aussi définir un rôle de test via des revendications sur ces utilisateurs afin de les différencier en tant que faux utilisateurs si vous souhaitez y accéder.

Pour déclencher manuellement le flux reCAPTCHA à des fins de test, utilisez la méthode forceRecaptchaFlowForTesting().

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

Tests d'intégration

En plus des tests manuels, Firebase Authentication fournit des API pour vous aider à écrire des tests d'intégration pour les tests d'authentification des téléphones. Ces API désactivent la validation des applications en désactivant reCAPTCHA pour les notifications push Web et silencieuses sur iOS. Cela permet d'effectuer des tests d'automatisation ces flux et plus faciles à implémenter. De plus, ils permettent de tester flux de validation sur Android.

Assurez-vous que la validation de l'application n'est pas désactivée pour les applications de production et qu'aucun numéro de téléphone fictif n'est codé en dur dans votre application de production.

Sur Android, appelez setAppVerificationDisabledForTesting() avant l'appel signInWithPhoneNumber. Cela désactive automatiquement la vérification des applications, ce qui vous permet de transmettre le numéro de téléphone sans le résoudre manuellement. Même si Play Integrity et reCAPTCHA sont désactivés, mais l'utilisation d'un vrai numéro de téléphone ne permettra toujours pas terminer la procédure de connexion. Seuls des numéros de téléphone fictifs peuvent être utilisés avec cette API.

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

Appeler verifyPhoneNumber avec un numéro fictif déclenche le rappel onCodeSent, dans lequel vous devrez fournir le code de validation correspondant. Cela permet d'effectuer des tests dans Android Emulator.

Java

String phoneNum = "[phone]";
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+KTX

val phoneNum = "[phone]"
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.
            [e-mail]ode()
        }

        override fun onVerificationCompleted(phoneAuthCredential: PhoneAuthCredential) {
            // Sign in with the credential
            // ...
        }

        override fun onVerificationFailed(e: FirebaseException) {
            // ...
        }
    })
    .build()
PhoneAuthProvider.verifyPhoneNumber(options)
MainActivity.kt

En outre, vous pouvez tester les flux de récupération automatique dans Android en définissant le numéro fictif et son code de validation correspondant pour la récupération automatique en appelant setAutoRetrievedSmsCodeForPhoneNumber.

Lorsque verifyPhoneNumber est appelée, elle déclenche onVerificationCompleted avec l'événement PhoneAuthCredential. directement. Cela ne fonctionne qu'avec des numéros de téléphone fictifs.

Assurez-vous que cette option est désactivée et qu'aucun numéro de téléphone fictif n'est codé en dur dans votre application lorsque vous la publiez sur le Google Play Store.

Java

// The test phone number and code should be whitelisted in the console.
String phoneNumber = "[phone]";
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+KTX

// The test phone number and code should be whitelisted in the console.
val phoneNumber = "[phone]"
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

Étapes suivantes

Lorsqu'un utilisateur se connecte pour la première fois, un compte utilisateur est créé et associés aux identifiants, c'est-à-dire au nom d'utilisateur et au mot de passe, ou des informations sur le fournisseur d'authentification, c'est-à-dire l'utilisateur avec lequel il s'est connecté. Ce nouveau compte est stocké dans votre projet Firebase et peut être utilisé pour identifier un utilisateur dans toutes les applications de votre projet, quelle que soit la manière dont il se connecte.

• Dans vos applications, vous pouvez obtenir les informations de profil de base de l'utilisateur à partir de l'objet FirebaseUser. Consultez Gérer les utilisateurs.

• Dans votre Firebase Realtime Database et votre Cloud Storage Règles de sécurité, vous pouvez obtenez l'ID utilisateur unique de l'utilisateur connecté à partir de la variable auth et l'utiliser pour contrôler les données auxquelles un utilisateur peut accéder.

Vous pouvez autoriser les utilisateurs à se connecter à votre application à l'aide de plusieurs fournisseurs d'authentification en associant les identifiants du fournisseur d'authentification à un compte utilisateur existant.

Pour déconnecter un utilisateur, appelez signOut :

Kotlin+KTX

Firebase.auth.signOut()
MainActivity.kt

Java

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