Google is committed to advancing racial equity for Black communities. See how.
Cette page a été traduite par l'API Cloud Translation.
Switch to English

S'authentifier avec Firebase à l'aide de Email Link sous Android

Vous pouvez utiliser l'authentification Firebase pour connecter un utilisateur en lui envoyant un e-mail contenant un lien sur lequel il peut cliquer pour se connecter. Dans le processus, l'adresse e-mail de l'utilisateur est également vérifiée.

La connexion par e-mail présente de nombreux avantages:

  • Inscription et connexion à faible friction.
  • Diminution du risque de réutilisation des mots de passe entre les applications, ce qui peut compromettre la sécurité des mots de passe même bien sélectionnés.
  • La possibilité d'authentifier un utilisateur tout en vérifiant que l'utilisateur est le propriétaire légitime d'une adresse e-mail.
  • Un utilisateur n'a besoin que d'un compte de messagerie accessible pour se connecter. Aucune propriété d'un numéro de téléphone ou d'un compte de réseau social n'est requise.
  • Un utilisateur peut se connecter en toute sécurité sans avoir besoin de fournir (ou de se souvenir) d'un mot de passe, ce qui peut être fastidieux sur un appareil mobile.
  • Un utilisateur existant qui s'est précédemment connecté avec un identifiant d'e-mail (mot de passe ou fédéré) peut être mis à niveau pour se connecter uniquement avec l'e-mail. Par exemple, un utilisateur qui a oublié son mot de passe peut toujours se connecter sans avoir à réinitialiser son mot de passe.

Avant que tu commences

Configurez votre projet Android

  1. Si vous ne l'avez pas déjà fait, ajoutez Firebase à votre projet Android .

  2. À l'aide de Firebase Android BoM , déclarez la dépendance de la bibliothèque Firebase Authentication Android dans le fichier Gradle de votre module (au niveau de l'application) (généralement app/build.gradle ).

    De plus, dans le cadre de la configuration de l'authentification Firebase, vous devez ajouter le SDK des services Google Play à votre application.

    Java

    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:27.0.0')
    
        // Declare 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'
    // Also declare the dependency for the Google Play services library and specify its version implementation 'com.google.android.gms:play-services-auth:19.0.0'
    }

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

    (Alternative) Déclarez les dépendances de la bibliothèque Firebase sans utiliser 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, nous vous recommandons vivement d'utiliser BoM pour gérer les versions de bibliothèque, ce qui garantit que toutes les versions sont compatibles.

    dependencies {
        // Declare 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:20.0.4'
    // Also declare the dependency for the Google Play services library and specify its version implementation 'com.google.android.gms:play-services-auth:19.0.0'
    }

    Kotlin + KTX

    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:27.0.0')
    
        // Declare 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'
    // Also declare the dependency for the Google Play services library and specify its version implementation 'com.google.android.gms:play-services-auth:19.0.0'
    }

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

    (Alternative) Déclarez les dépendances de la bibliothèque Firebase sans utiliser 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, nous vous recommandons vivement d'utiliser BoM pour gérer les versions de bibliothèque, ce qui garantit que toutes les versions sont compatibles.

    dependencies {
        // Declare 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:20.0.4'
    // Also declare the dependency for the Google Play services library and specify its version implementation 'com.google.android.gms:play-services-auth:19.0.0'
    }

Pour connecter les utilisateurs par lien e-mail, vous devez d'abord activer la méthode de connexion Fournisseur d'e-mail et Lien e-mail pour votre projet Firebase:

  1. Dans la console Firebase , ouvrez la section Auth .
  2. Dans l'onglet Méthode de connexion, activez le fournisseur Email / Mot de passe . Notez que la connexion par e-mail / mot de passe doit être activée pour utiliser la connexion par lien de messagerie.
  3. Dans la même section, activez la méthode de connexion par lien par e-mail (connexion sans mot de passe) .
  4. Cliquez sur Enregistrer .

Pour lancer le flux d'authentification, présentez à l'utilisateur une interface qui l'invite à fournir son adresse e-mail, puis appelez sendSignInLinkToEmail pour demander à Firebase d'envoyer le lien d'authentification à l'e-mail de l'utilisateur.

  1. Construisez l'objet ActionCodeSettings , qui fournit à Firebase des instructions sur la façon de créer le lien de l'e-mail. Définissez les champs suivants:

    • url : Le lien profond à intégrer et tout état supplémentaire à transmettre. Le domaine du lien doit être ajouté à la liste blanche dans la liste des domaines autorisés de la console Firebase, que vous pouvez trouver en accédant à l'onglet Méthode de connexion (Authentification -> Méthode de connexion). Le lien redirigera l'utilisateur vers cette URL si l'application n'est pas installée sur son appareil et que l'application n'a pas pu être installée.
    • androidPackageName et IOSBundleId : les applications à utiliser lorsque le lien de connexion est ouvert sur un appareil Android ou iOS. En savoir plus sur la configuration de Firebase Dynamic Links pour ouvrir des liens d'action par e-mail via des applications mobiles.
    • handleCodeInApp : défini sur true. L'opération de connexion doit toujours être effectuée dans l'application, contrairement aux autres actions d'e-mail hors bande (réinitialisation du mot de passe et vérifications d'e-mail). En effet, à la fin du flux, l'utilisateur doit être connecté et son état d'authentification persiste dans l'application.
    • dynamicLinkDomain : lorsque plusieurs domaines de liens dynamiques personnalisés sont définis pour un projet, spécifiez celui à utiliser lorsque le lien doit être ouvert via une application mobile spécifiée (par exemple, example.page.link ). Sinon, le premier domaine est automatiquement sélectionné.

    Java

    ActionCodeSettings actionCodeSettings =
            ActionCodeSettings.newBuilder()
                    // URL you want to redirect back to. The domain (www.example.com) for this
                    // URL must be whitelisted in the Firebase Console.
                    .setUrl("https://www.example.com/finishSignUp?cartId=1234")
                    // This must be true
                    .setHandleCodeInApp(true)
                    .setIOSBundleId("com.example.ios")
                    .setAndroidPackageName(
                            "com.example.android",
                            true, /* installIfNotAvailable */
                            "12"    /* minimumVersion */)
                    .build();

    Kotlin + KTX

    val actionCodeSettings = actionCodeSettings {
        // URL you want to redirect back to. The domain (www.example.com) for this
        // URL must be whitelisted in the Firebase Console.
        url = "https://www.example.com/finishSignUp?cartId=1234"
        // This must be true
        handleCodeInApp = true
        iosBundleId = "com.example.ios"
        setAndroidPackageName(
                "com.example.android",
                true, /* installIfNotAvailable */
                "12" /* minimumVersion */)
    }

    Pour en savoir plus sur ActionCodeSettings, reportez-vous à la section État de transmission dans les actions par e-mail .

  2. Demandez à l'utilisateur son e-mail.

  3. Envoyez le lien d'authentification à l'e-mail de l'utilisateur et enregistrez l'e-mail de l'utilisateur au cas où l'utilisateur terminerait la connexion par e-mail sur le même appareil.

    Java

    FirebaseAuth auth = FirebaseAuth.getInstance();
    auth.sendSignInLinkToEmail(email, actionCodeSettings)
            .addOnCompleteListener(new OnCompleteListener<Void>() {
                @Override
                public void onComplete(@NonNull Task<Void> task) {
                    if (task.isSuccessful()) {
                        Log.d(TAG, "Email sent.");
                    }
                }
            });

    Kotlin + KTX

    Firebase.auth.sendSignInLinkToEmail(email, actionCodeSettings)
            .addOnCompleteListener { task ->
                if (task.isSuccessful) {
                    Log.d(TAG, "Email sent.")
                }
            }

Problèmes de sécurité

Pour éviter qu'un lien de connexion ne soit utilisé pour se connecter en tant qu'utilisateur involontaire ou sur un appareil non souhaité, Firebase Auth requiert que l'adresse e-mail de l'utilisateur soit fournie lors de la procédure de connexion. Pour que la connexion réussisse, cette adresse e-mail doit correspondre à l'adresse à laquelle le lien de connexion a été envoyé à l'origine.

Vous pouvez rationaliser ce flux pour les utilisateurs qui ouvrent le lien de connexion sur le même appareil qu'ils demandent le lien, en stockant leur adresse e-mail localement - par exemple à l'aide de SharedPreferences - lorsque vous envoyez l'e-mail de connexion. Ensuite, utilisez cette adresse pour terminer le flux. Ne transmettez pas l'e-mail de l'utilisateur dans les paramètres de l'URL de redirection et réutilisez-le car cela peut activer les injections de session.

Une fois la connexion terminée, tout mécanisme de connexion non vérifié antérieur sera supprimé de l'utilisateur et toutes les sessions existantes seront invalidées. Par exemple, si quelqu'un a précédemment créé un compte non vérifié avec le même e-mail et le même mot de passe, le mot de passe de l'utilisateur sera supprimé pour empêcher l'emprunteur qui a revendiqué la propriété et créé ce compte non vérifié de se reconnecter avec l'e-mail et le mot de passe non vérifiés.

Assurez-vous également d'utiliser une URL HTTPS en production pour éviter que votre lien ne soit potentiellement intercepté par des serveurs intermédiaires.

Terminer la connexion dans une application Android

L'authentification Firebase utilise Firebase Dynamic Links pour envoyer le lien e-mail à un appareil mobile. Pour terminer la connexion via l'application mobile, l'application doit être configurée pour détecter le lien d'application entrant, analyser le lien profond sous-jacent, puis terminer la connexion.

Firebase Auth utilise Firebase Dynamic Links lors de l'envoi d'un lien destiné à être ouvert dans une application mobile. Pour utiliser cette fonction, les liens dynamiques doivent être configurés dans la console Firebase.

  1. Activez les liens dynamiques Firebase:

    1. Dans la console Firebase , ouvrez la section Liens dynamiques .
    2. Si vous n'avez pas encore accepté les conditions des liens dynamiques et créé un domaine de liens dynamiques, faites-le maintenant.

      Si vous avez déjà créé un domaine Dynamic Links, notez-le. Un domaine Dynamic Links ressemble généralement à l'exemple suivant:

      example.page.link

      Vous aurez besoin de cette valeur lorsque vous configurerez votre application iOS ou Android pour intercepter le lien entrant.

  2. Configuration des applications Android:

    1. Pour gérer ces liens à partir de votre application Android, le nom du package Android doit être spécifié dans les paramètres du projet Firebase Console. De plus, les SHA-1 et SHA-256 du certificat d'application doivent être fournis.
    2. Maintenant que vous avez ajouté un domaine de lien dynamique et que vous vous êtes assuré que votre application Android est correctement configurée, le lien dynamique sera redirigé vers votre application, à partir de l'activité du lanceur.
    3. Si vous souhaitez que le lien dynamique redirige vers une activité spécifique, vous devrez configurer un filtre d'intention dans votre fichier AndroidManifest.xml . Cela peut être fait en spécifiant votre domaine de lien dynamique ou le gestionnaire d'action d'e-mail dans le filtre d'intention. Par défaut, le gestionnaire d'actions d'e-mail est hébergé sur un domaine comme l'exemple suivant:
      PROJECT_ID.firebaseapp.com/
    4. Mises en garde:
      1. Ne spécifiez pas l'URL que vous avez définie sur l'actionCodeSettings dans votre filtre d'intention.
      2. Lors de la création de votre domaine de lien dynamique, vous avez peut-être également créé un lien URL court. Cette URL courte ne sera pas transmise; ne configurez pas votre filtre d'intention pour l'attraper avec un attribut android:pathPrefix . Cela signifie que vous ne pourrez pas capturer différents liens dynamiques dans différentes parties de votre application. Cependant, vous pouvez vérifier le paramètre de requête de mode dans le lien pour voir quelle opération tente d'être effectuée, ou utiliser des méthodes SDK telles que isSignInWithEmailLink pour voir si un lien que votre application a reçu fait ce que vous voulez.
    5. Pour plus d'informations sur la réception de liens dynamiques, reportez-vous aux instructions de réception de liens dynamiques Android .

Après avoir reçu le lien comme décrit ci-dessus, vérifiez qu'il est destiné à l'authentification du lien de messagerie et terminez la connexion.

Java

FirebaseAuth auth = FirebaseAuth.getInstance();
Intent intent = getIntent();
String emailLink = intent.getData().toString();

// Confirm the link is a sign-in with email link.
if (auth.isSignInWithEmailLink(emailLink)) {
    // Retrieve this from wherever you stored it
    String email = "someemail@domain.com";

    // The client SDK will parse the code from the link for you.
    auth.signInWithEmailLink(email, emailLink)
            .addOnCompleteListener(new OnCompleteListener<AuthResult>() {
                @Override
                public void onComplete(@NonNull Task<AuthResult> task) {
                    if (task.isSuccessful()) {
                        Log.d(TAG, "Successfully signed in with email link!");
                        AuthResult result = task.getResult();
                        // You can access the new user via result.getUser()
                        // Additional user info profile *not* available via:
                        // result.getAdditionalUserInfo().getProfile() == null
                        // You can check if the user is new or existing:
                        // result.getAdditionalUserInfo().isNewUser()
                    } else {
                        Log.e(TAG, "Error signing in with email link", task.getException());
                    }
                }
            });
}

Kotlin + KTX

val auth = Firebase.auth
val intent = intent
val emailLink = intent.data.toString()

// Confirm the link is a sign-in with email link.
if (auth.isSignInWithEmailLink(emailLink)) {
    // Retrieve this from wherever you stored it
    val email = "someemail@domain.com"

    // The client SDK will parse the code from the link for you.
    auth.signInWithEmailLink(email, emailLink)
            .addOnCompleteListener { task ->
                if (task.isSuccessful) {
                    Log.d(TAG, "Successfully signed in with email link!")
                    val result = task.result
                    // You can access the new user via result.getUser()
                    // Additional user info profile *not* available via:
                    // result.getAdditionalUserInfo().getProfile() == null
                    // You can check if the user is new or existing:
                    // result.getAdditionalUserInfo().isNewUser()
                } else {
                    Log.e(TAG, "Error signing in with email link", task.exception)
                }
            }
}

Pour en savoir plus sur la gestion de la connexion avec un lien de messagerie dans une application iOS, reportez-vous au guide iOS .

Pour savoir comment gérer la connexion avec un lien de messagerie dans une application Web, reportez-vous au guide Web .

Vous pouvez également lier cette méthode d'authentification à un utilisateur existant. Par exemple, un utilisateur précédemment authentifié auprès d'un autre fournisseur, tel qu'un numéro de téléphone, peut ajouter cette méthode de connexion à son compte existant.

La différence serait dans la seconde moitié de l'opération:

Java

// Construct the email link credential from the current URL.
AuthCredential credential =
        EmailAuthProvider.getCredentialWithLink(email, emailLink);

// Link the credential to the current user.
auth.getCurrentUser().linkWithCredential(credential)
        .addOnCompleteListener(new OnCompleteListener<AuthResult>() {
            @Override
            public void onComplete(@NonNull Task<AuthResult> task) {
                if (task.isSuccessful()) {
                    Log.d(TAG, "Successfully linked emailLink credential!");
                    AuthResult result = task.getResult();
                    // You can access the new user via result.getUser()
                    // Additional user info profile *not* available via:
                    // result.getAdditionalUserInfo().getProfile() == null
                    // You can check if the user is new or existing:
                    // result.getAdditionalUserInfo().isNewUser()
                } else {
                    Log.e(TAG, "Error linking emailLink credential", task.getException());
                }
            }
        });

Kotlin + KTX

// Construct the email link credential from the current URL.
val credential = EmailAuthProvider.getCredentialWithLink(email, emailLink)

// Link the credential to the current user.
Firebase.auth.currentUser!!.linkWithCredential(credential)
        .addOnCompleteListener { task ->
            if (task.isSuccessful) {
                Log.d(TAG, "Successfully linked emailLink credential!")
                val result = task.result
                // You can access the new user via result.getUser()
                // Additional user info profile *not* available via:
                // result.getAdditionalUserInfo().getProfile() == null
                // You can check if the user is new or existing:
                // result.getAdditionalUserInfo().isNewUser()
            } else {
                Log.e(TAG, "Error linking emailLink credential", task.exception)
            }
        }

Cela peut également être utilisé pour ré-authentifier un utilisateur de lien de messagerie avant d'exécuter une opération sensible.

Java

// Construct the email link credential from the current URL.
AuthCredential credential =
        EmailAuthProvider.getCredentialWithLink(email, emailLink);

// Re-authenticate the user with this credential.
auth.getCurrentUser().reauthenticateAndRetrieveData(credential)
        .addOnCompleteListener(new OnCompleteListener<AuthResult>() {
            @Override
            public void onComplete(@NonNull Task<AuthResult> task) {
                if (task.isSuccessful()) {
                    // User is now successfully reauthenticated
                } else {
                    Log.e(TAG, "Error reauthenticating", task.getException());
                }
            }
        });

Kotlin + KTX

// Construct the email link credential from the current URL.
val credential = EmailAuthProvider.getCredentialWithLink(email, emailLink)

// Re-authenticate the user with this credential.
Firebase.auth.currentUser!!.reauthenticateAndRetrieveData(credential)
        .addOnCompleteListener { task ->
            if (task.isSuccessful) {
                // User is now successfully reauthenticated
            } else {
                Log.e(TAG, "Error reauthenticating", task.exception)
            }
        }

Cependant, comme le flux peut se retrouver sur un appareil différent sur lequel l'utilisateur d'origine n'était pas connecté, ce flux peut ne pas être terminé. Dans ce cas, une erreur peut être montrée à l'utilisateur pour le forcer à ouvrir le lien sur le même appareil. Un état peut être transmis dans le lien pour fournir des informations sur le type d'opération et l'uid utilisateur.

Si vous prenez en charge à la fois la connexion par mot de passe et par lien par e-mail, pour différencier la méthode de connexion d'un utilisateur de mot de passe / lien, utilisez fetchSignInMethodsForEmail . Ceci est utile pour les flux identifiant d'abord où l'utilisateur est d'abord invité à fournir son e-mail, puis présenté avec la méthode de connexion:

Java

auth.fetchSignInMethodsForEmail(email)
        .addOnCompleteListener(new OnCompleteListener<SignInMethodQueryResult>() {
            @Override
            public void onComplete(@NonNull Task<SignInMethodQueryResult> task) {
                if (task.isSuccessful()) {
                    SignInMethodQueryResult result = task.getResult();
                    List<String> signInMethods = result.getSignInMethods();
                    if (signInMethods.contains(EmailAuthProvider.EMAIL_PASSWORD_SIGN_IN_METHOD)) {
                        // User can sign in with email/password
                    } else if (signInMethods.contains(EmailAuthProvider.EMAIL_LINK_SIGN_IN_METHOD)) {
                        // User can sign in with email/link
                    }
                } else {
                    Log.e(TAG, "Error getting sign in methods for user", task.getException());
                }
            }
        });

Kotlin + KTX

Firebase.auth.fetchSignInMethodsForEmail(email)
        .addOnSuccessListener { result ->
            val signInMethods = result.signInMethods!!
            if (signInMethods.contains(EmailAuthProvider.EMAIL_PASSWORD_SIGN_IN_METHOD)) {
                // User can sign in with email/password
            } else if (signInMethods.contains(EmailAuthProvider.EMAIL_LINK_SIGN_IN_METHOD)) {
                // User can sign in with email/link
            }
        }
        .addOnFailureListener { exception ->
            Log.e(TAG, "Error getting sign in methods for user", exception)
        }

Comme décrit ci-dessus, l'adresse e-mail / mot de passe et l'adresse e-mail / lien sont considérés comme le même EmailAuthProvider (même PROVIDER_ID ) avec des méthodes de connexion différentes.

Prochaines étapes

Lorsqu'un utilisateur se connecte pour la première fois, un nouveau compte 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 lesquels 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 profil de base 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 l' signOut

Java

FirebaseAuth.getInstance().signOut();

Kotlin + KTX

Firebase.auth.signOut()