Authentifiez-vous avec Firebase à l'aide d'Email Link dans Android

Vous pouvez utiliser Firebase Authentication pour connecter un utilisateur en lui envoyant un e-mail contenant un lien sur lequel il peut cliquer pour se connecter. Au cours de ce processus, l'adresse e-mail de l'utilisateur est également validée.

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

  • Inscription et connexion simples
  • Réduction du risque de réutilisation de mots de passe dans plusieurs applications, ce qui peut compromettre la sécurité, même avec des mots de passe bien choisis
  • Possibilité d'authentifier un utilisateur tout en vérifiant qu'il 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. Il n'est pas nécessaire de posséder un numéro de téléphone ni un compte de réseau social.
  • Un utilisateur peut se connecter de manière sécurisée sans avoir à fournir (ni à mémoriser) de mot de passe, ce qui peut être fastidieux sur un appareil mobile.
  • Un utilisateur existant qui s'est déjà connecté avec un identifiant de messagerie (mot de passe ou fédéré) peut être mis à niveau pour se connecter uniquement avec son adresse e-mail. Par exemple, un utilisateur qui a oublié son mot de passe peut toujours se connecter sans avoir à le réinitialiser.

Avant de commencer

Configurer votre projet Android

  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.

    De plus, lors de la configuration de Firebase Authentication, vous devez ajouter le SDK des services Google Play à votre application.

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

    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")
    
    // Also add the dependency for the Google Play services library and specify its version
    implementation("com.google.android.gms:play-services-auth:21.5.1")    
}

Activer la connexion par lien envoyé par e-mail pour votre projet Firebase

Pour connecter des utilisateurs par lien envoyé par e-mail, vous devez d'abord activer le fournisseur d'e-mails et la méthode de connexion par lien envoyé par e-mail pour votre projet Firebase :

  1. Dans la Firebase console, ouvrez la section Auth.
  2. Dans l'onglet Mode de connexion, activez le fournisseur Adresse e-mail/Mot de passe. Notez que la connexion par adresse e-mail/mot de passe doit être activée pour utiliser la connexion par lien envoyé par e-mail.
  3. Dans la même section, activez la méthode de connexion Lien envoyé 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'adresse e-mail de l'utilisateur.

  1. Créez l'objet ActionCodeSettings, qui fournit à Firebase des instructions sur la façon de créer le lien envoyé par e-mail. Renseignez les champs ci-dessous comme suit :

    • url : 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 trouverez en accédant à l'onglet "Mode de connexion" (Authentication -> Mode de connexion). Le lien redirigera l'utilisateur vers cette URL si l'application n'est pas installée sur son appareil et qu'elle n'a pas pu être installée.
    • androidPackageName et iOSBundleId : aident Firebase Authentication à déterminer s'il doit créer un lien Web uniquement ou un lien mobile qui s'ouvre sur un appareil Android ou Apple.
    • handleCodeInApp : défini sur "true". L'opération de connexion doit toujours être effectuée dans l'application, contrairement à d'autres actions par e-mail hors bande (réinitialisation du mot de passe et validation de l'adresse e-mail). En effet, à la fin du flux, l'utilisateur doit être connecté et son état d'authentification doit être conservé dans l'application.
    • linkDomain : lorsque des domaines de liens personnalisés sont définis pour un projet, spécifiez celui à utiliser lorsque le lien doit être ouvert par une application mobile spécifiée. Sinon, le domaine par défaut est automatiquement sélectionné (par exemple, PROJECT_ID.firebaseapp.com).Hosting
    • dynamicLinkDomain : obsolète. Ne spécifiez pas ce paramètre.

    Kotlin

    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
    setIOSBundleId("com.example.ios")
    setAndroidPackageName(
        "com.example.android",
        true, // installIfNotAvailable
        "12", // minimumVersion
    )
}
    MainActivity.kt

    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();
    MainActivity.java

    Pour en savoir plus sur ActionCodeSettings, consultez la section Transmettre l'état dans les actions par e-mail.

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

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

    Kotlin

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

    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.");
                }
            }
        });
    MainActivity.java

Problèmes de sécurité

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

Vous pouvez simplifier ce flux pour les utilisateurs qui ouvrent le lien de connexion sur le même appareil que celui sur lequel ils ont demandé le lien, en stockant leur adresse e-mail localement (par exemple, à l'aide de SharedPreferences) lorsque vous envoyez l'e-mail de connexion. Utilisez ensuite cette adresse pour terminer le flux. Ne transmettez pas l'adresse e-mail de l'utilisateur dans les paramètres de l'URL de redirection et ne la réutilisez pas, car cela pourrait permettre des injections de session.

Une fois la connexion terminée, tout mécanisme de connexion non validé précédent sera supprimé de l'utilisateur et toutes les sessions existantes seront invalidées. Par exemple, si une personne a déjà créé un compte non validé avec la même adresse e-mail et le même mot de passe, le mot de passe de l'utilisateur sera supprimé pour empêcher l'usurpateur qui a revendiqué la propriété et créé ce compte non validé de se connecter à nouveau avec l'adresse e-mail et le mot de passe non validé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

Firebase Authentication utilise Firebase Hosting pour envoyer le lien par e-mail à un appareil mobile. Pour terminer la connexion via une application mobile, l'application doit être configurée pour détecter le lien entrant, analyser le lien profond sous-jacent, puis terminer la connexion. Pour en savoir plus, consultez la documentation sur les liens d'application Android App.

Configurer Firebase Hosting

Firebase Authentication utilise les domaines Firebase Hosting lors de la création et de l'envoi d'un lien destiné à être ouvert dans une application mobile. Un domaine Firebase Hosting par défaut a déjà été configuré pour vous.

  1. Configurez les domaines :Firebase Hosting

    Dans la console Firebase, ouvrez la section « Hosting ».

    • Si vous souhaitez utiliser le domaine par défaut pour le lien envoyé par e-mail qui s'ouvre dans les applications mobiles, accédez à votre site par défaut et notez votre domaine Hosting par défaut. Un domaine Hosting par défaut se présente généralement comme suit : PROJECT_ID.firebaseapp.com.

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

    • Si vous souhaitez utiliser un domaine personnalisé pour le lien envoyé par e-mail, vous pouvez en enregistrer un auprès de Firebase Hosting et l'utiliser pour le domaine du lien.

  2. Configurer des applications Android :

    Pour gérer ces liens à partir de votre application Android, le nom de package de votre application doit être spécifié dans les Firebase paramètres du projet de la console. De plus, les empreintes SHA-1 et SHA-256 du certificat d'application doivent être fournies.

    Si vous souhaitez que ces liens redirigent vers une activité spécifique, vous devrez configurer un filtre d'intent dans votre fichier AndroidManifest.xml. Le filtre d'intent doit intercepter les liens envoyés par e-mail de votre domaine. Dans AndroidManifest.xml :

    <intent-filter android:autoVerify="true">
  <action android:name="android.intent.action.VIEW" />
  <category android:name="android.intent.category.BROWSABLE" />
  <category android:name="android.intent.category.DEFAULT" />
  <data
    android:scheme="https"
    android:host="<PROJECT_ID>.firebaseapp.com or your custom domain"
    android:pathPrefix="/__/auth/links" />
</intent-filter>

    Lorsque les utilisateurs ouvrent un lien d'hébergement avec le /__/auth/links chemin et le schéma et l'hôte que vous spécifiez, votre application démarre l'activité avec cet intent filtre pour gérer le lien.

Une fois que vous avez reçu le lien comme décrit ci-dessus, vérifiez qu'il est destiné à l'authentification par lien envoyé par e-mail et terminez la connexion.

Kotlin

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)
            }
        }
}
MainActivity.kt

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());
                    }
                }
            });
}
MainActivity.java

Pour savoir comment gérer la connexion par lien envoyé par e-mail dans une application Apple, consultez le guide des plates-formes Apple.

Pour savoir comment gérer la connexion par lien envoyé par e-mail dans une application Web, consultez le guide Web.

Vous pouvez également associer 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 se situe dans la seconde moitié de l'opération :

Kotlin

// 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)
        }
    }
MainActivity.kt

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());
                }
            }
        });
MainActivity.java

Cette méthode peut également être utilisée pour réauthentifier un utilisateur de lien envoyé par e-mail avant d'exécuter une opération sensible.

Kotlin

// 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)
        }
    }
MainActivity.kt

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());
                }
            }
        });
MainActivity.java

Toutefois, comme le flux peut se terminer sur un autre appareil sur lequel l'utilisateur d'origine n'était pas connecté, il est possible qu'il ne soit pas terminé. Dans ce cas, un message d'erreur peut s'afficher pour forcer l'utilisateur à 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 de l'utilisateur.

L'authentification par lien envoyé par e-mail reposait auparavant sur Firebase Dynamic Links, qui sera arrêté le 25 août 2025.

Nous avons publié une solution alternative dans le Firebase Authentication Android SDK v23.2.0+ et Firebase BoM v33.9.0+.

Si votre application utilise les anciens liens, vous devez migrer votre application vers le nouveau système Firebase Hosting basé.

Si vous avez créé votre projet le 15 septembre 2023 ou après, la protection contre l'énumération d'adresses e-mail est activée par défaut. Cette fonctionnalité améliore la sécurité des comptes utilisateur de votre projet, mais elle désactive la méthode fetchSignInMethodsForEmail(), que nous recommandions auparavant d'implémenter pour les flux d'identifiant en premier.

Bien que vous puissiez désactiver la protection contre l'énumération d'adresses e-mail pour votre projet, nous vous le déconseillons.

Pour en savoir plus, consultez la documentation sur la protection contre l'énumération d'adresses e-mail .

É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 il 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 méthode de connexion utilisée.

  • 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()
MainActivity.kt

Java

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