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 lui envoyant un SMS sur son téléphone. L'utilisateur se connecte à l'aide d'un code à usage unique contenu dans le SMS.

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

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 la Firebase Android BoM pour contrôler la gestion des versions de la bibliothèque. 
    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:34.12.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 les Firebase Android BoM, votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.

    (Autre solution)  Ajouter des dépendances de bibliothèque Firebase sans utiliser la BoM

    Si vous choisissez de ne pas utiliser la 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, nous vous recommandons vivement d'utiliser la BoM pour gérer les versions des bibliothèques, 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:24.0.1")
}
  3. Si vous n'avez pas encore associé votre application à votre projet Firebase, faites-le depuis la Firebase console.
  4. Si vous n'avez pas encore défini le hachage SHA-1 de votre application dans la Firebase console, faites-le. Pour savoir comment trouver le hachage SHA-1 de votre application, consultez Authentifier votre client.

Problèmes de sécurité

L'authentification à l'aide d'un numéro de téléphone uniquement, bien que pratique, est moins sécurisée que les autres méthodes disponibles, car la possession d'un numéro de téléphone peut être facilement transférée entre les utilisateurs. De plus, sur les appareils comportant plusieurs profils utilisateur, tout utilisateur pouvant recevoir des SMS peut se connecter à un compte à l'aide du 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 la proposer en plus de méthodes de connexion plus sécurisées et informer les utilisateurs des compromis en matière 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 méthode de connexion par numéro de téléphone pour votre projet Firebase :

  1. Dans la Firebase console, ouvrez la section Authentication (Authentification).
  2. Sur la page Sign-in Method (Méthode de connexion), activez la méthode de connexion Phone Number (Numéro de téléphone).
  3. Sur la page Settings (Paramètres), définissez une règle sur les régions vers lesquelles vous souhaitez autoriser ou refuser l’envoi de SMS. Pour les nouveaux projets, la règle par défaut n'autorise aucune région.

Activer la vérification 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. Il existe trois manières dont Firebase Authentication y parvient :

  • API Play Integrity : si un utilisateur dispose d'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 par numéro de téléphone peut se poursuivre. L'API Play Integrity est activée sur un projet appartenant à Google par Firebase Authentication, et non sur votre projet. Cela ne contribue à aucun quota d'API Play Integrity quotas sur votre projet. L'assistance Play Integrity est disponible avec le Authentication SDK v21.2.0+ (Firebase BoM v31.4.0+).

    Pour utiliser Play Integrity, si vous n'avez pas encore spécifié l'empreinte SHA-256 de votre application, faites-le dans les Project settings (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 flux de connexion par téléphone. Le test reCAPTCHA peut souvent être relevé sans que l'utilisateur ait à résoudre quoi que ce soit. Notez que ce flux nécessite que un SHA-1 soit associé à votre application. Ce flux nécessite également que votre clé API ne soit pas limitée ou qu'elle soit ajoutée à la liste d'autorisation pour PROJECT_ID.firebaseapp.com.

    Voici quelques scénarios dans lesquels reCAPTCHA est déclenché :

    • Si Google Play services ne sont pas installés sur l'appareil de l'utilisateur final.
    • Si l'application n'est pas distribuée via Google Play Store (sur Authentication SDK v21.2.0+).
    • Si le jeton SafetyNet obtenu n'était pas valide (sur les versions du SDK Authentication < v21.2.0).

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

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

Dépannage

  • Erreur "Missing initial state" (État initial manquant) lors de l'utilisation de reCAPTCHA pour la validation des applications

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

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

Pour lancer la connexion par numéro de téléphone, présentez à l'utilisateur une interface qui l'invite à saisir son numéro de téléphone. Les exigences légales varient, mais, par souci de bonnes pratiques et pour définir les attentes de vos utilisateurs, vous devez les informer que s'ils utilisent la connexion par téléphone, ils peuvent recevoir un SMS de validation et que les tarifs standards s'appliquent.

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

Kotlin

val options = PhoneAuthOptions.newBuilder(auth)
    .setPhoneNumber(phoneNumber) // Phone number to verify
    .setTimeout(60L, TimeUnit.SECONDS) // Timeout and unit
    .setActivity(this) // Activity (for callback binding)
    .setCallbacks(callbacks) // OnVerificationStateChangedCallbacks
    .build()
PhoneAuthProvider.verifyPhoneNumber(options)

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);

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 deuxième SMS, sauf si la requête d'origine a expiré.

Vous pouvez utiliser ce comportement pour reprendre le processus de connexion par numéro de téléphone si votre application se ferme avant que l'utilisateur puisse se connecter (par exemple, pendant qu'il utilise son application de SMS). Après avoir appelé verifyPhoneNumber, définissez un indicateur indiquant que la validation est en cours. Enregistrez ensuite l'indicateur dans la méthode onSaveInstanceState de votre activité et restaurez-le dans onRestoreInstanceState. Enfin, dans la méthode onStart de votre activité, vérifiez si la validation est déjà en cours et, le cas échéant, appelez à nouveau verifyPhoneNumber. Veillez à effacer l'indicateur lorsque la validation est terminée ou échoue (voir Rappels de validation).

Pour gérer facilement la rotation de l'écran et d'autres instances de redémarrage d'activité, transmettez votre activité à la méthode verifyPhoneNumber. Les rappels seront automatiquement dissociés lorsque l'activité s'arrêtera. Vous pourrez donc écrire librement du code de transition d'interface utilisateur dans les méthodes de rappel.

Le SMS envoyé par Firebase peut également être localisé en spécifiant la langue d'authentification via la méthode setLanguageCode sur votre instance Auth.

Kotlin

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

Java

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

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 requête. Exemple :

Kotlin

callbacks = object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

    override fun onVerificationCompleted(credential: PhoneAuthCredential) {
        // This callback will be invoked in two situations:
        // 1 - Instant verification. In some cases the phone number can be instantly
        //     verified without needing to send or enter a verification code.
        // 2 - Auto-retrieval. On some devices Google Play services can automatically
        //     detect the incoming verification SMS and perform verification without
        //     user action.
        Log.d(TAG, "onVerificationCompleted:$credential")
        signInWithPhoneAuthCredential(credential)
    }

    override fun onVerificationFailed(e: FirebaseException) {
        // This callback is invoked in an invalid request for verification is made,
        // for instance if the the phone number format is not valid.
        Log.w(TAG, "onVerificationFailed", e)

        if (e is FirebaseAuthInvalidCredentialsException) {
            // Invalid request
        } else if (e is FirebaseTooManyRequestsException) {
            // The SMS quota for the project has been exceeded
        } else if (e is FirebaseAuthMissingActivityForRecaptchaException) {
            // reCAPTCHA verification attempted with null Activity
        }

        // Show a message and update the UI
    }

    override fun onCodeSent(
        verificationId: String,
        token: PhoneAuthProvider.ForceResendingToken,
    ) {
        // The SMS verification code has been sent to the provided phone number, we
        // now need to ask the user to enter the code and then construct a credential
        // by combining the code with a verification ID.
        Log.d(TAG, "onCodeSent:$verificationId")

        // Save verification ID and resending token so we can use them later
        storedVerificationId = verificationId
        resendToken = token
    }
}

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;
    }
};

Rappels de validation

Dans la plupart des applications, vous implémentez les rappels onVerificationCompleted, onVerificationFailed et onCodeSent. Vous pouvez également implémenter onCodeAutoRetrievalTimeOut, en fonction des exigences de votre application.

onVerificationCompleted(PhoneAuthCredential)

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

  • Validation instantanée : dans certains cas, le numéro de téléphone peut être validé instantanément 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 validation entrant et effectuer la validation sans intervention de l'utilisateur. (Cette fonctionnalité peut ne pas être disponible avec certains opérateurs.) Elle utilise l' API SMS Retriever, qui inclut un hachage de 11 caractères à la fin du SMS.
Dans les deux cas, le numéro de téléphone de l'utilisateur a été validé et vous pouvez utiliser l'objet PhoneAuthCredential transmis au rappel pour connecter l'utilisateur.

onVerificationFailed(FirebaseException)

Cette méthode est appelée en réponse à une demande de validation non valide, par exemple une demande qui spécifie un numéro de téléphone ou un code de validation non valide.

onCodeSent(String verificationId, PhoneAuthProvider.ForceResendingToken)

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

Lorsque cette méthode est appelée, la plupart des applications affichent une interface utilisateur qui invite l'utilisateur à saisir le code de validation du SMS. (En parallèle, la validation automatique peut être en cours en arrière-plan.) Ensuite, une fois que l'utilisateur a saisi le code de validation, vous pouvez utiliser le code de validation et l' ID de validation transmis à la méthode pour créer un PhoneAuthCredential objet, que vous pouvez ensuite utiliser pour connecter l'utilisateur. Toutefois, certaines applications peuvent attendre l'appel de onCodeAutoRetrievalTimeOut avant d'afficher l'interface utilisateur du code de validation (non recommandé).

onCodeAutoRetrievalTimeOut(String verificationId)

Facultatif. Cette méthode est appelée une fois la durée du délai d'inactivité spécifiée pour verifyPhoneNumber écoulée sans que onVerificationCompleted ne soit déclenché 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 la saisie de l'utilisateur jusqu'à l'expiration du délai de validation automatique, puis affichent une interface utilisateur qui invite l'utilisateur à saisir le code de validation du SMS (non recommandé).

Créer un objet PhoneAuthCredential

Une fois que l'utilisateur a saisi le code de validation que Firebase lui a envoyé, créez un objet PhoneAuthCredential à l'aide du code de validation et de l'ID de validation transmis au rappel onCodeSent ou onCodeAutoRetrievalTimeOut. (Lorsque onVerificationCompleted est appelé, vous obtenez directement un objet PhoneAuthCredential. Vous pouvez donc ignorer cette étape.)

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

Kotlin

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

Java

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

Connecter l'utilisateur

Une fois que vous avez obtenu un objet PhoneAuthCredential, que ce soit dans le rappel onVerificationCompleted ou en appelant PhoneAuthProvider.getCredential, terminez le flux de connexion en transmettant l'objet PhoneAuthCredential à FirebaseAuth.signInWithCredential :

Kotlin

private fun signInWithPhoneAuthCredential(credential: PhoneAuthCredential) {
    auth.signInWithCredential(credential)
        .addOnCompleteListener(this) { task ->
            if (task.isSuccessful) {
                // Sign in success, update UI with the signed-in user's information
                Log.d(TAG, "signInWithCredential:success")

                val user = task.result?.user
            } else {
                // Sign in failed, display a message and update the UI
                Log.w(TAG, "signInWithCredential:failure", task.exception)
                if (task.exception is FirebaseAuthInvalidCredentialsException) {
                    // The verification code entered was invalid
                }
                // Update UI
            }
        }
}

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

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. Les tests avec des numéros de téléphone fictifs présentent les avantages suivants :

  • Tester l'authentification par numéro de téléphone sans consommer votre quota d'utilisation.
  • Tester l'authentification par numéro de téléphone sans envoyer de SMS.
  • Exécuter des tests consécutifs avec le même numéro de téléphone sans être limité. Cela réduit le risque de refus lors du processus d'examen de l'App Store si l'examinateur utilise le même numéro de téléphone pour les tests.
  • Tester facilement dans des environnements de développement sans effort supplémentaire, par exemple 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 les contrôles de sécurité normalement appliqués aux numéros de téléphone réels dans un environnement de production.

Les numéros de téléphone fictifs doivent répondre aux exigences suivantes :

  1. Assurez-vous d'utiliser des numéros de téléphone qui sont effectivement 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 comme numéros de test. Vous pouvez par exemple utiliser des numéros commençant par 555 comme numéros de téléphone de test aux États-Unis : +1 650-555-3434
  2. Les numéros de téléphone doivent être au bon format en termes de longueur et d'autres contraintes. Ils seront toujours soumis à la même validation que le numéro de téléphone d'un utilisateur réel.
  3. Vous pouvez ajouter jusqu'à 10 numéros de téléphone pour le développement.
  4. Utilisez des numéros/codes de téléphone de test difficiles à deviner et modifiez les fréquemment.

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

  1. Dans la Firebase console, ouvrez la section Authentication (Authentification).
  2. Dans l'onglet Sign in method (Méthode de connexion), activez le fournisseur de téléphonie si ce n'est pas déjà fait.
  3. Ouvrez le menu accordéon Phone numbers for testing (Numéros de téléphone de test).
  4. Indiquez le numéro de téléphone que vous souhaitez tester, par exemple : +1 650-555-3434.
  5. Indiquez le code de validation à six chiffres pour 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 son code en pointant sur la ligne correspondante et en cliquant sur l'icône de la corbeille.

Tests manuels

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

Lorsque vous fournissez le numéro de téléphone fictif et que vous envoyez le code de validation, aucun SMS n'est envoyé. Vous devez plutôt fournir le code de validation configuré précédemment pour terminer la connexion.

Une fois la connexion terminée, un utilisateur Firebase est créé avec ce numéro de téléphone. 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 à d'autres services de la même manière. Le jeton d'ID généré au cours de ce processus a la même signature qu'un utilisateur de numéro de téléphone réel.

Vous pouvez également définir un rôle de test via des revendications personnalisées sur ces utilisateurs pour les différencier en tant qu'utilisateurs fictifs si vous souhaitez restreindre davantage l'accès.

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

// 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 par téléphone. Ces API désactivent la validation des applications en désactivant l'exigence reCAPTCHA dans les notifications push Web et silencieuses sous iOS. Cela permet de tester l'automatisation dans ces flux et de les implémenter plus facilement. De plus, elles permettent de tester les flux de validation instantanée sur Android.

Sur Android, appelez setAppVerificationDisabledForTesting() avant l' signInWithPhoneNumber appel. Cela désactive automatiquement la validation 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, l'utilisation d'un numéro de téléphone réel ne permettra pas de terminer la connexion. Seuls les numéros de téléphone fictifs peuvent être utilisés avec cette API. 

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

L'appel de verifyPhoneNumber avec un numéro fictif déclenche le rappel onCodeSent, dans lequel vous devrez fournir le code de validation correspondant. Cela permet de tester dans les émulateurs Android.

Java

String phoneNum = "+16505554567";
String testVerificationCode = "123456";

// Whenever verification is triggered with the whitelisted number,
// provided it is not set for auto-retrieval, onCodeSent will be triggered.
FirebaseAuth auth = FirebaseAuth.getInstance();
PhoneAuthOptions options = PhoneAuthOptions.newBuilder(auth)
        .setPhoneNumber(phoneNum)
        .setTimeout(60L, TimeUnit.SECONDS)
        .setActivity(this)
        .setCallbacks(new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
            @Override
            public void onCodeSent(@NonNull String verificationId,
                                   @NonNull PhoneAuthProvider.ForceResendingToken forceResendingToken) {
                // Save the verification id somewhere
                // ...

                // The corresponding whitelisted code above should be used to complete sign-in.
                MainActivity.this.enableUserManuallyInputCode();
            }

            @Override
            public void onVerificationCompleted(@NonNull PhoneAuthCredential phoneAuthCredential) {
                // Sign in with the credential
                // ...
            }

            @Override
            public void onVerificationFailed(@NonNull FirebaseException e) {
                // ...
            }
        })
        .build();
PhoneAuthProvider.verifyPhoneNumber(options);

Kotlin

val phoneNum = "+16505554567"
val testVerificationCode = "123456"

// Whenever verification is triggered with the whitelisted number,
// provided it is not set for auto-retrieval, onCodeSent will be triggered.
val options = PhoneAuthOptions.newBuilder(Firebase.auth)
    .setPhoneNumber(phoneNum)
    .setTimeout(30L, TimeUnit.SECONDS)
    .setActivity(this)
    .setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

        override fun onCodeSent(
            verificationId: String,
            forceResendingToken: PhoneAuthProvider.ForceResendingToken,
        ) {
            // Save the verification id somewhere
            // ...

            // The corresponding whitelisted code above should be used to complete sign-in.
            this@MainActivity.enableUserManuallyInputCode()
        }

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

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

De plus, 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é, il déclenche onVerificationCompleted directement avec PhoneAuthCredential. 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 = "+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);

Kotlin

// The test phone number and code should be whitelisted in the console.
val phoneNumber = "+16505554567"
val smsCode = "123456"

val firebaseAuth = Firebase.auth
val firebaseAuthSettings = firebaseAuth.firebaseAuthSettings

// Configure faking the auto-retrieval with the whitelisted numbers.
firebaseAuthSettings.setAutoRetrievedSmsCodeForPhoneNumber(phoneNumber, smsCode)

val options = PhoneAuthOptions.newBuilder(firebaseAuth)
    .setPhoneNumber(phoneNumber)
    .setTimeout(60L, TimeUnit.SECONDS)
    .setActivity(this)
    .setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
        override fun onVerificationCompleted(credential: PhoneAuthCredential) {
            // Instant verification is applied and a credential is directly returned.
            // ...
        }

        // ...
    })
    .build()
PhoneAuthProvider.verifyPhoneNumber(options)

Étapes suivantes

Lorsqu'un utilisateur se connecte pour la première fois, un compte utilisateur est créé et associé aux identifiants (nom d'utilisateur et mot de passe, numéro de téléphone ou informations du fournisseur d'authentification) avec lesquels l'utilisateur s'est connecté. Ce nouveau compte est stocké dans votre projet Firebase et peut être utilisé pour identifier un utilisateur dans chaque application de votre projet, quelle que soit la manière dont il se connecte.

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

  • Dans vos Firebase Realtime Database et Cloud Storage règles de sécurité, vous pouvez obtenir 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

Firebase.auth.signOut()

Java

FirebaseAuth.getInstance().signOut();