> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Ajouter Native Facebook Login à votre application Android

export const HowToSchema = () => <script type="application/ld+json">
    {'{"@context":"https://schema.org","@type":"HowTo"}'}
  </script>;

<HowToSchema />

<div id="before-you-start">
  ## Avant de commencer
</div>

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](https://developers.facebook.com/docs/facebook-login/). Créez une application Facebook sur [developers.facebook.com](https://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](/docs/fr-ca/authenticate/identity-providers/social-identity-providers/facebook-native).

<div id="get-started">
  ## Commencer
</div>

<Steps>
  <Step title="Configurer les permissions de Facebook Login" stepNumber={1}>
    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.

    ```kotlin MainActivity.kt lines theme={null}
    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
    }
    ```

    <Info>
      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.
    </Info>
  </Step>

  <Step title="Installer et configurer le SDK Auth0" stepNumber={2}>
    Ajoutez le SDK Android d’Auth0 à votre projet et configurez les identifiants de votre application.

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

    ```kotlin app/build.gradle.kts lines theme={null}
    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](https://manage.auth0.com/) et sélectionnez l’application dans laquelle vous avez activé Facebook Native Sign In. Copiez les valeurs **Domain** et **Client ID**.

    ```xml app/src/main/res/values/strings.xml lines theme={null}
    <resources>
        <string name="com_auth0_domain">{yourDomain}</string>
        <string name="com_auth0_client_id">{yourClientId}</string>
    </resources>
    ```

    **Initialisez le SDK Auth0 dans votre Activity :**

    ```kotlin MainActivity.kt lines theme={null}
    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)
    }
    ```

    <Note>
      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 :

      ```xml app/src/main/AndroidManifest.xml lines theme={null}
      <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](/docs/fr-ca/libraries/auth0-android#authentication-via-universal-login).
    </Note>
  </Step>

  <Step title="Récupérer le jeton d’accès de session Facebook" stepNumber={3}>
    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` :

    ```kotlin MainActivity.kt lines theme={null}
    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()
    }
    ```

    <Info>
      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)
    </Info>
  </Step>

  <Step title="Récupérer le profil utilisateur Facebook" stepNumber={4}>
    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.

    ```kotlin MainActivity.kt lines theme={null}
    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()
    }
    ```

    <Tip>
      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.
    </Tip>
  </Step>

  <Step title="Obtenir des identifiants Auth0 en échange de jetons" stepNumber={5}>
    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 :

    ```kotlin MainActivity.kt lines theme={null}
    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)
                }
            })
    }
    ```

    <Info>
      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.
    </Info>
  </Step>

  <Step title="Tout réunir" stepNumber={6}>
    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.

    ```kotlin MainActivity.kt lines theme={null}
    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
            }
        })
    }
    ```

    <Tip>
      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.
    </Tip>
  </Step>
</Steps>

<Check>
  **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.
</Check>

***

<div id="troubleshooting-advanced">
  ## Dépannage et options avancées
</div>

<Accordion title="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`
</Accordion>

<Accordion title="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](https://developers.facebook.com/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
</Accordion>

***

<div id="next-steps">
  ## Prochaines étapes
</div>

<CardGroup cols={2}>
  <Card title="Configurer d’autres fournisseurs d’identité" icon="key" href="/docs/fr-ca/authenticate/identity-providers" iconType="solid">
    Ajoutez Google, Apple et d’autres fournisseurs de connexion avec les réseaux sociaux
  </Card>

  <Card title="Protection contre les attaques" icon="shield" href="/docs/fr-ca/secure/attack-protection" iconType="solid">
    Protégez-vous contre les attaques par force brute et les attaques de bots
  </Card>

  <Card title="Actions" icon="bolt" href="/docs/fr-ca/customize/actions/actions-overview" iconType="solid">
    Personnalisez les flux d’authentification avec du code sans serveur
  </Card>

  <Card title="Référence du SDK Android" icon="android" href="/docs/fr-ca/libraries/auth0-android" iconType="solid">
    Consultez la documentation complète du SDK Android d’Auth0
  </Card>
</CardGroup>