S'authentifier auprès de 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 message SMS.

Le moyen le plus simple d'ajouter la connexion par numéro de téléphone à votre application consiste à utiliser FirebaseUI , qui comprend un widget de connexion qui implémente des flux de connexion pour la connexion par numéro de téléphone, ainsi qu'une connexion basée sur un mot de passe et fédérée. -dans. Ce document décrit comment mettre en œuvre un flux de connexion par numéro de téléphone à l'aide du SDK Firebase.

Avant que tu commences

1. Si vous ne l'avez 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 ), ajoutez la dépendance pour la bibliothèque Firebase Authentication Android. Nous vous recommandons d'utiliser Firebase Android BoM pour contrôler la gestion des versions de la bibliothèque.

   Kotlin+KTX

   dependencies {
       // Import the BoM for the Firebase platform
       implementation platform('com.google.firebase:firebase-bom:32.1.0')
   
       // Add the dependency for the Firebase Authentication library
       // When using the BoM, you don't specify versions in Firebase library dependencies
       implementation 'com.google.firebase:firebase-auth-ktx'
   }
   

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

   (Alternative) Ajouter des dépendances à la bibliothèque Firebase sans utiliser le BoM

   Si vous choisissez de ne pas utiliser la nomenclature Firebase, 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 de 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-ktx:22.0.0'
   }
   

   Java

   dependencies {
       // Import the BoM for the Firebase platform
       implementation platform('com.google.firebase:firebase-bom:32.1.0')
   
       // Add the dependency for the Firebase Authentication library
       // When using the BoM, you don't specify versions in Firebase library dependencies
       implementation 'com.google.firebase:firebase-auth'
   }
   

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

   (Alternative) Ajouter des dépendances à la bibliothèque Firebase sans utiliser le BoM

   Si vous choisissez de ne pas utiliser la nomenclature Firebase, 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 de 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:22.0.0'
   }
   

3. Si vous n'avez pas encore connecté 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 , faites-le. Voir Authentification de votre client pour plus d'informations sur la recherche du hachage SHA-1 de votre application.

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 la possession d'un numéro de téléphone peut être facilement transférée entre les utilisateurs. En outre, sur les appareils dotés de 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 basée sur le numéro de téléphone dans votre application, vous devez l'offrir avec des 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 méthode de 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 Méthode de connexion , activez la méthode de connexion par numéro de téléphone .

Le quota de demandes de connexion par numéro de téléphone de Firebase est suffisamment élevé pour que la plupart des applications ne soient pas affectées. Toutefois, si vous devez vous connecter à un très grand nombre d'utilisateurs avec une authentification par téléphone, vous devrez peut-être mettre à niveau votre plan tarifaire. Voir la page des tarifs .

Activer la vérification de l'application

Pour utiliser l'authentification par numéro de téléphone, Firebase doit être en mesure de vérifier que les demandes de connexion par numéro de téléphone proviennent de votre application. Firebase Authentication y parvient de trois façons :

• API Play Integrity : si un utilisateur possède un appareil sur lequel les services Google Play sont installés et que l'authentification Firebase 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 pas aux quotas de l'API Play Integrity sur votre projet. La prise en charge de l'intégrité de lecture est disponible avec le SDK d'authentification 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 à partir des paramètres de projet de la console Firebase. Reportez-vous à Authentification de votre client pour savoir comment obtenir l'empreinte SHA-256 de votre application.

• Vérification reCAPTCHA : dans le cas où Play Integrity ne peut pas être utilisé, par exemple lorsqu'un utilisateur dispose d'un appareil sur lequel les services Google Play ne sont pas installés, Firebase Authentication utilise une vérification reCAPTCHA pour terminer le flux de connexion par téléphone. Le défi reCAPTCHA peut souvent être complété sans que l'utilisateur ait à résoudre quoi que ce soit. Notez que ce flux nécessite qu'un SHA-1 soit associé à votre application. Ce flux nécessite également que votre clé API soit sans restriction ou sur liste blanche pour PROJECT_ID .firebaseapp.com .

  Certains scénarios dans lesquels reCAPTCHA est déclenché :

  • Si l'appareil de l'utilisateur final n'a pas de services Google Play installés.
  • 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 d'authentification < v21.2.0).

  Lorsque SafetyNet ou Play Integrity est utilisé pour la vérification de l'application, le champ %APP_NAME% du modèle de SMS est rempli 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 .

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

Pour initier 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 en tant que bonne pratique 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 message SMS pour vérification et les tarifs standard s'appliquent.

Ensuite, transmettez leur numéro de téléphone à la méthode PhoneAuthProvider.verifyPhoneNumber pour demander à Firebase de vérifier le numéro de téléphone de l'utilisateur. Par exemple:

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

La méthode verifyPhoneNumber est réentrante : si vous l'appelez plusieurs fois, comme dans la méthode onStart d'une activité, la méthode verifyPhoneNumber n'enverra pas de second SMS à moins que la demande d'origine n'ait 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 ne puisse se connecter (par exemple, lorsque l'utilisateur utilise son application SMS). Après avoir appelé verifyPhoneNumber , définissez un indicateur indiquant que la vérification est en cours. Ensuite, enregistrez l'indicateur dans la méthode onSaveInstanceState de votre activité et restaurez l'indicateur dans onRestoreInstanceState . Enfin, dans la méthode onStart de votre activité, vérifiez si la vérification est déjà en cours, et si c'est le cas, appelez à nouveau verifyPhoneNumber . Assurez-vous d'effacer l'indicateur lorsque la vérification se termine ou échoue (voir 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 . Les rappels seront automatiquement détachés lorsque l'activité s'arrêtera, vous pouvez donc écrire librement le code de transition de l'interface utilisateur dans les méthodes de rappel.

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

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

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

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

Rappels de vérification

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

onVerificationCompleted(PhoneAuthCredential)

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

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

onVerificationFailed(FirebaseException)

Cette méthode est appelée en réponse à une demande de vérification non valide, telle qu'une demande qui spécifie un numéro de téléphone ou un code de vérification non valide.

onCodeSent(String verificationId, PhoneAuthProvider.ForceResendingToken)

Facultatif. Cette méthode est appelée après que le code de vérification a été envoyé 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 vérification à partir du message SMS. (Dans le même temps, la vérification automatique peut se dérouler en arrière-plan.) Ensuite, une fois que l'utilisateur a saisi le code de vérification, vous pouvez utiliser le code de vérification et l'ID de vérification transmis à la méthode pour créer un objet PhoneAuthCredential , qui vous pouvez à son tour utiliser pour vous connecter à l'utilisateur. Cependant, certaines applications peuvent attendre que onCodeAutoRetrievalTimeOut soit appelé avant d'afficher l'interface utilisateur du code de vérification (non recommandé).

onCodeAutoRetrievalTimeOut(String verificationId)

Facultatif. Cette méthode est appelée une fois que le délai d'attente spécifié pour verifyPhoneNumber s'est écoulé sans que onVerificationCompleted n'ait été déclenché au préalable. 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 l'entrée de l'utilisateur jusqu'à ce que la période de vérification automatique ait expiré, et seulement ensuite affichent une interface utilisateur qui invite l'utilisateur à saisir le code de vérification du message SMS (non recommandé).

Créer un objet PhoneAuthCredential

Une fois que l'utilisateur a saisi le code de vérification que Firebase a envoyé au téléphone de l'utilisateur, créez un objet PhoneAuthCredential à l'aide du code de vérification et de l'ID de vérification 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 :

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

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

Connectez-vous l'utilisateur

Après avoir 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 :

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

Test 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. Tester avec des numéros de téléphone fictifs offre les avantages suivants :

• Testez l'authentification par numéro de téléphone sans consommer votre quota d'utilisation.
• Testez l'authentification du numéro de téléphone sans envoyer de message SMS réel.
• Exécutez des tests consécutifs avec le même numéro de téléphone sans être limité. Cela minimise le risque de rejet pendant le processus d'examen de l'App Store si l'examinateur utilise le même numéro de téléphone pour les tests.
• Testez facilement dans des environnements de développement sans aucun effort supplémentaire, comme la possibilité de développer dans un simulateur iOS ou un émulateur Android sans les services Google Play.
• Rédigez des tests d'intégration sans être bloqué par les 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 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 de vrais utilisateurs comme numéros de test. Une option consiste à utiliser 555 numéros préfixés comme numéros de téléphone de test aux États-Unis, par exemple : +1 650-555-3434
2. Les numéros de téléphone doivent être correctement formatés pour la longueur et d'autres contraintes. Ils subiront toujours 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 de téléphone/codes de test difficiles à deviner et changez-les fréquemment.

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

1. Dans la console Firebase , ouvrez la section Authentification .
2. Dans l'onglet Méthode de connexion , activez le fournisseur de téléphone si vous ne l'avez pas déjà fait.
3. Ouvrez le menu Numéros de téléphone pour tester l'accordéon.
4. Indiquez le numéro de téléphone que vous souhaitez tester, par exemple : +1 650-555-3434 .
5. Fournissez le code de vérification à 6 chiffres pour ce numéro spécifique, par exemple : 654321 .
6. Ajoutez le numéro. En cas de besoin, vous pouvez supprimer le numéro de téléphone et son code en survolant la ligne correspondante et en cliquant sur l'icône de la corbeille.

Test manuel

Vous pouvez commencer directement à utiliser un numéro de téléphone fictif dans votre application. Cela vous permet d'effectuer des tests manuels pendant les étapes de développement sans rencontrer de problèmes de quotas ou de limitation. Vous pouvez également tester 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 envoyez le code de vérification, aucun SMS réel n'est envoyé. Au lieu de cela, vous devez fournir le code de vérification précédemment configuré 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'identification créé au cours de ce processus a la même signature qu'un utilisateur de numéro de téléphone réel.

Une autre option consiste à définir un rôle de test via des revendications personnalisées sur ces utilisateurs pour les différencier en tant que faux utilisateurs si vous souhaitez restreindre davantage l'accès.

Pour déclencher manuellement le flux reCAPTCHA pour le 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 aider à écrire des tests d'intégration pour les tests d'authentification par téléphone. Ces API désactivent la vérification des applications en désactivant l'exigence reCAPTCHA dans les notifications Web et push silencieuses dans iOS. Cela rend les tests d'automatisation possibles dans ces flux et plus faciles à mettre en œuvre. En outre, ils permettent de tester des flux de vérification instantanés sur Android.

Sur Android, appelez setAppVerificationDisabledForTesting() avant l'appel signInWithPhoneNumber . Cela désactive automatiquement la vérification de l'application, vous permettant 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 vrai numéro de téléphone ne permettra toujours pas de se connecter. 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();

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

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

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 vérification correspondant pour la récupération automatique en appelant setAutoRetrievedSmsCodeForPhoneNumber .

Lorsque verifyPhoneNumber est appelé, il déclenche directement onVerificationCompleted 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 lors de la publication de votre application sur le Google Play Store.

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

Prochaines étapes

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

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

• Dans vos règles de sécurité Firebase Realtime Database et Cloud Storage, 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 liant les informations d'identification du fournisseur d'authentification à un compte d'utilisateur existant.

Pour déconnecter un utilisateur, appelez signOut :

Firebase.auth.signOut()
MainActivity.kt

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