Ajouter Native Facebook Login à votre application Android

​

Avant de commencer

Effectuez les prérequis suivants avant de suivre ce Quickstart :

1. Configurer le SDK Facebook Login - Installez et configurez le Facebook Login SDK for Android. Créez une application Facebook sur developers.facebook.com. Une fois terminé, Facebook Login devrait fonctionner dans votre application.
2. Configurer Auth0 pour Facebook Native - Configurez votre application Auth0 pour utiliser Facebook Native Sign In. Consultez Ajouter Facebook Login aux applications natives.

​

Commencer

1. Configurer les permissions de Facebook Login

   Mettez à jour le bouton Facebook Login dans votre Activity pour demander les bonnes permissions.

   Votre application prend déjà en charge Facebook Login, mais pour obtenir un profil utilisateur détaillé, vous devez demander les permissions public_profile et email. Vous ajouterez aussi un callback pour lancer le flux d’authentification Auth0.

   MainActivity.kt

   private lateinit var fbCallbackManager: CallbackManager
   
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_login)
   
       fbCallbackManager = CallbackManager.Factory.create()
       val loginButton = findViewById<LoginButton>(R.id.login_button)
   
       // Demander les permissions email et public_profile
       loginButton.setPermissions("email", "public_profile")
   
       loginButton.registerCallback(fbCallbackManager,
           object : FacebookCallback<LoginResult> {
               override fun onSuccess(result: LoginResult) {
                   val accessToken = result.accessToken
                   performLogin(accessToken)
               }
               override fun onCancel() {
                   // L'utilisateur a fermé la boîte de dialogue. Peut être ignoré
               }
               override fun onError(error: FacebookException) {
                   // Gérer l'erreur d'authentification Facebook
               }
           })
   }
   
   private fun performLogin(accessToken: AccessToken) {
       // Les étapes 2 à 4 compléteront cette section
   }
   

   La permission email est facultative — l’utilisateur doit consentir à son partage. L’adresse courriel renvoyée par Facebook sera marquée comme non vérifiée dans le profil utilisateur Auth0.

2. Installer et configurer le SDK Auth0

   Ajoutez le SDK Android d’Auth0 à votre projet et configurez les identifiants de votre application.

   Ajoutez la dépendance à app/build.gradle.kts :

   app/build.gradle.kts

   dependencies {
       implementation("com.auth0.android:auth0:3.+")
   }
   

   Synchronisez Gradle après avoir ajouté la dépendance.

   Ajoutez vos identifiants Auth0 à strings.xml :

   Accédez à la section Applications du Auth0 Dashboard et sélectionnez l’application dans laquelle vous avez activé Facebook Native Sign In. Copiez les valeurs Domain et Client ID.

   app/src/main/res/values/strings.xml

   <resources>
       <string name="com_auth0_domain">{yourDomain}</string>
       <string name="com_auth0_client_id">{yourClientId}</string>
   </resources>
   

   Initialisez le SDK Auth0 dans votre Activity :

   MainActivity.kt

   private val account: Auth0 by lazy {
       Auth0.getInstance(
           getString(R.string.com_auth0_client_id),
           getString(R.string.com_auth0_domain)
       )
   }
   
   private val authenticationApiClient: AuthenticationAPIClient by lazy {
       AuthenticationAPIClient(account)
   }
   

   Si votre application n’utilise pas Auth0 Web Authentication, supprimez l’activité inutilisée de AndroidManifest.xml pour éviter les erreurs d’espace réservé dans le Manifest :

   app/src/main/AndroidManifest.xml

   <application>
       <activity
           android:name="com.auth0.android.provider.AuthenticationActivity"
           tools:node="remove" />
   </application>
   

   Si vous comptez prendre en charge Web Authentication, consultez l’authentification par Universal Login.

3. Récupérer le jeton d’accès de session Facebook

   Une fois l’authentification avec Facebook Login réussie, récupérez un jeton d’accès de session auprès de l’API Facebook. Auth0 a besoin de ce jeton pour vérifier l’identité de l’utilisateur côté serveur.

   Effectuez une requête GET vers le point de terminaison /oauth/access_token de Facebook à l’aide de la classe GraphRequest :

   MainActivity.kt

   private interface SimpleCallback<T> {
       fun onResult(result: T)
       fun onError(cause: Throwable)
   }
   
   private fun fetchSessionToken(accessToken: AccessToken, callback: SimpleCallback<String>) {
       val request = GraphRequest()
       request.graphPath = "oauth/access_token"
       val bundle = Bundle()
       bundle.putString("grant_type", "fb_attenuate_token")
       bundle.putString("client_id", getString(R.string.facebook_app_id))
       bundle.putString("fb_exchange_token", accessToken.token)
       request.parameters = bundle
       request.callback = GraphRequest.Callback { response ->
           if (response.error != null) {
               response.error?.exception?.let { callback.onError(it) }
           } else {
               response.jsonObject?.let { callback.onResult(it.getString("access_token")) }
           }
       }
       request.executeAsync()
   }
   

   Les paramètres de requête requis sont :

   • grant_type: fb_attenuate_token
   • fb_exchange_token: le jeton d’accès provenant de Facebook Login
   • client_id: votre App ID Facebook (déjà dans votre application lors de la configuration du Facebook SDK)
4. Récupérer le profil utilisateur Facebook

   Récupérez le profil de l’utilisateur sur Facebook. Auth0 utilise ces données pour créer ou mettre à jour le profil Auth0 de l’utilisateur.

   MainActivity.kt

   private fun fetchUserProfile(
       accessToken: AccessToken,
       callback: SimpleCallback<String>
   ) {
       val request = GraphRequest.newMeRequest(accessToken) { _, response ->
           val error = response?.error
           if (error != null) {
               error.exception?.let { callback.onError(it) }
           } else {
               callback.onResult(response?.rawResponse.toString())
           }
       }
       val bundle = Bundle()
       bundle.putString("fields", "first_name,last_name,email")
       request.parameters = bundle
       request.executeAsync()
   }
   

   Le paramètre fields correspond directement aux autorisations Facebook que vous avez demandées. Il suffit de demander first_name, last_name et email pour qu’Auth0 puisse créer un profil d’utilisateur complet.

5. Obtenir des identifiants Auth0 en échange de jetons

   Utilisez le jeton de session et le profil utilisateur des étapes précédentes pour vous authentifier auprès d’Auth0 et obtenir des jetons Auth0.

   Appelez loginWithNativeSocialToken sur AuthenticationAPIClient en lui transmettant le jeton de session avec le type de subject token Facebook :

   MainActivity.kt

   private fun exchangeTokens(
       sessionToken: String,
       userProfile: String,
       callback: SimpleCallback<Credentials>
   ) {
       authenticationApiClient
           .loginWithNativeSocialToken(
               sessionToken,
               "http://auth0.com/oauth/token-type/facebook-info-session-access-token"
           )
           .setScope("openid profile email offline_access")
           .addParameter(name = "user_profile", value = userProfile)
           .start(object : Callback<Credentials, AuthenticationException> {
               override fun onSuccess(result: Credentials) {
                   callback.onResult(result)
               }
               override fun onFailure(error: AuthenticationException) {
                   callback.onError(error)
               }
           })
   }
   

   Le type de jeton de sujet http://auth0.com/oauth/token-type/facebook-info-session-access-token indique à Auth0 d’utiliser la connexion Facebook native pour l’authentification.

6. Tout réunir

   Complétez la méthode performLogin pour enchaîner les trois étapes : récupérer le jeton de session → récupérer le profil utilisateur → obtenir des jetons Auth0 en échange.

   MainActivity.kt

   private fun performLogin(accessToken: AccessToken) {
       fetchSessionToken(accessToken, object : SimpleCallback<String> {
           override fun onResult(sessionToken: String) {
               fetchUserProfile(accessToken, object : SimpleCallback<String> {
                   override fun onResult(userProfile: String) {
                       exchangeTokens(sessionToken, userProfile, object : SimpleCallback<Credentials> {
                           override fun onResult(result: Credentials) {
                               // Authentifié! Utilisez result.accessToken ou result.idToken
                           }
                           override fun onError(cause: Throwable) {
                               // Gérer l'erreur d'échange de jeton
                           }
                       })
                   }
                   override fun onError(cause: Throwable) {
                       // Gérer l'erreur de requête de profil
                   }
               })
           }
           override fun onError(cause: Throwable) {
               // Gérer l'erreur de requête de jeton de session
           }
       })
   }
   

   Gardez les constantes (type de jeton du sujet, autorisations Facebook, scopes Auth0) au début de votre classe pour éviter d’éparpiller des chaînes codées en dur dans le code.

Vérification

Vous devriez maintenant pouvoir vous authentifier avec Facebook de façon native. Si l’application Facebook est installée sur l’appareil, l’authentification se fait directement dans l’application — sans navigateur.

---

​

Dépannage et options avancées

Problèmes courants et solutions

​

L’échange de jetons échoue avec une erreur d’authentication

Solutions :

1. Vérifiez que Facebook Native Sign In est activé pour votre application Auth0 dans le Dashboard
2. Vérifiez que le Facebook App ID dans votre strings.xml correspond à celui de la console de développement Facebook
3. Confirmez que la chaîne du type de subject token correspond exactement à : http://auth0.com/oauth/token-type/facebook-info-session-access-token
4. Assurez-vous que le jeton d’accès Facebook n’a pas expiré avant d’appeler performLogin

​

La requête de jeton de session renvoie une erreur

Correctif :

• Vérifiez que R.string.facebook_app_id est correctement défini dans votre strings.xml
• Assurez-vous que fb_exchange_token correspond à la chaîne de jeton brute de l’objet Facebook AccessToken
• Vérifiez que votre application Facebook n’est pas en mode développement si vous faites des tests avec des utilisateurs non administrateurs

​

AuthenticationException : “Connection not found”

Correctif :

1. Allez à Auth0 Dashboard → Authentication → Social
2. Vérifiez que Sign in with Facebook est activé
3. Confirmez que Facebook Native Social Login est activé dans les paramètres de la connexion
4. Vérifiez que l’application Auth0 est associée à la connexion Facebook

​

Certains champs du profil utilisateur sont manquants

• Confirmez que public_profile et email figurent dans l’appel setPermissions
• Il se peut que l’utilisateur ait refusé la permission email — gérez les adresses courriel nulles correctement
• Vérifiez que les mêmes champs figurent dans le bundle fields de fetchUserProfile

Considérations pour la production

​

Meilleures pratiques de sécurité

• Désactivez la journalisation en production : supprimez enableLogging = true du DefaultClient ou limitez-le selon l’environnement — cela consigne le trafic réseau
• Stockage sécurisé des jetons : utilisez SecureCredentialsManager pour stocker les jetons Auth0 dans l’Android Keystore
• Refresh tokens : demandez la portée offline_access et implémentez l’actualisation des jetons pour maintenir les sessions

​

Configuration de l’application Facebook

• Faites passer votre application Facebook de Development Mode à Live avant son lancement
• Ajoutez l’empreinte de clé SHA-1 de votre application dans la console de développement Facebook
• Consultez les exigences de la Data Policy de Facebook pour les applications qui utilisent le SDK Login

​

Google Play Store

• Respectez les politiques de Google Play pour les applications qui utilisent une authentification tierce
• Incluez Facebook Login dans la politique de confidentialité de votre application

---

​

Prochaines étapes

Configurer d’autres fournisseurs d’identité

Ajoutez Google, Apple et d’autres fournisseurs de connexion avec les réseaux sociaux

Protection contre les attaques

Protégez-vous contre les attaques par force brute et les attaques de bots

Actions

Personnalisez les flux d’authentification avec du code sans serveur

Référence du SDK Android

Consultez la documentation complète du SDK Android d’Auth0