> ## 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 la connexion à votre application Android avec le SDK Auth0.Android

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

<HowToSchema />

<Accordion title="Utiliser l’IA pour intégrer Auth0" icon="microchip-ai" iconType="solid" defaultOpen>
  Si vous utilisez un assistant de programmation IA comme Claude Code, Cursor ou GitHub Copilot, vous pouvez ajouter automatiquement l’authentification Auth0 en quelques minutes à l’aide des [agent skills](https://agentskills.io/home).

  **Installation :**

  ```bash theme={null}
  npx skills add auth0/agent-skills --skill auth0-quickstart --skill auth0-android
  ```

  **Ensuite, demandez à votre assistant IA :**

  ```text theme={null}
  Add Auth0 authentication to my Android app
  ```

  Votre assistant IA créera automatiquement votre application Auth0, récupérera les identifiants, ajoutera la dépendance du SDK Auth0 Android, configurera les variables de substitution du manifeste et implémentera les flux de connexion et de déconnexion. [Documentation complète sur les agent skills →](/fr-CA/docs/quickstart/agent-skills)
</Accordion>

<div id="get-started">
  ## Pour commencer
</div>

<Steps>
  <Step title="Créer un nouveau projet Android" stepNumber={1}>
    Créez un nouveau projet Android pour ce démarrage rapide.

    **Dans Android Studio :**

    1. **File** → **New** → **New Project**
    2. Sélectionnez le modèle **Phone and Tablet** → **Empty Activity**
    3. Configurez votre projet :
       * **Name**: `Auth0-Android-Sample`
       * **Package name**: `com.auth0.samples.android`
       * **Language**: **Kotlin**
       * **Minimum SDK**: **API 24 (Android 7.0)**
       * **Build configuration language**: **Kotlin DSL**
    4. Cliquez sur **Finish**

    <Tip>
      Cela crée une application Android moderne avec Kotlin et Gradle Kotlin DSL, conformément aux bonnes pratiques actuelles du développement Android.
    </Tip>
  </Step>

  <Step title="Ajouter le SDK Auth0 via Gradle" stepNumber={2}>
    Ajoutez le SDK Android d’Auth0 à votre projet à l’aide de Gradle.

    **Mettez à jour le fichier `build.gradle.kts` de votre application :**

    ```kotlin app/build.gradle.kts lines theme={null}
    dependencies {   
        // SDK Auth0
        implementation("com.auth0.android:auth0:3.14.0")
    }
    ```

    **Ajoutez des variables de remplacement du manifeste dans le fichier `build.gradle.kts` de votre application :**

    ```kotlin app/build.gradle.kts lines theme={null}
    android {
        defaultConfig {
            // Ajouter ces espaces réservés du manifeste
            manifestPlaceholders += mapOf(
                "auth0Domain" to "@string/com_auth0_domain", // sera défini à l'étape suivante
                "auth0Scheme" to "https"
            )
        }
    }

    ```

    **Ajoutez la permission d’accès à Internet à `AndroidManifest.xml` :**

    ```xml app/src/main/AndroidManifest.xml lines theme={null}
    <?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools">
        <uses-permission android:name="android.permission.INTERNET" />
    </manifest>
    ```

    <Tip>
      Le SDK Auth0 gère automatiquement la résolution des dépendances et comprend des mécanismes sécurisés de stockage des jetons.
    </Tip>
  </Step>

  <Step title="Configurez votre application Auth0" stepNumber={3}>
    Ensuite, vous devez créer une nouvelle application dans votre locataire Auth0 et ajouter la configuration à votre projet Android.

    D’abord, préparez votre fichier `app/src/main/res/values/strings.xml` avec des valeurs fictives :

    ```xml app/src/main/res/values/strings.xml theme={null}
    <?xml version="1.0" encoding="utf-8"?>
    <resources>
        <string name="com_auth0_domain">{yourDomain}</string>
        <string name="com_auth0_client_id">YOUR_AUTH0_CLIENT_ID</string>
        <string name="com_auth0_scheme">https</string>
    </resources>
    ```

    1. Accédez à l’[Auth0 Dashboard](https://manage.auth0.com/dashboard/)
    2. Cliquez sur **Applications** > **Applications** > **Create Application**
    3. Dans la fenêtre contextuelle, saisissez un nom pour votre application, sélectionnez `Native` comme type d’application, puis cliquez sur **Create**
    4. Ouvrez l’onglet **Settings** de la page des détails de l’application
    5. Remplacez `{yourDomain}` et `YOUR_AUTH0_CLIENT_ID` dans le fichier `strings.xml` par les valeurs **Domaine** et **ID client** de l’Auth0 Dashboard

    Enfin, dans l’onglet **Settings** de la page des détails de votre application, configurez les URL suivantes :

    **Allowed Callback URLs :**

    ```
    https://{yourDomain}/android/PACKAGE_NAME/callback
    ```

    **URLs de déconnexion autorisées :**

    ```
    https://{yourDomain}/android/PACKAGE_NAME/callback
    ```

    Remplacez `{yourDomain}` par votre domaine Auth0 réel (par ex. : `dev-abc123.us.auth0.com`).

    <Info>
      **Allowed Callback URLs** constituent une mesure de sécurité essentielle pour s’assurer que les utilisateurs sont redirigés de façon sécuritaire vers votre application après l’authentification. Sans URL correspondante, le processus de connexion échouera et les utilisateurs verront une page d’erreur Auth0 au lieu d’accéder à votre application.

      **Allowed Logout URLs** sont essentielles pour offrir une expérience utilisateur fluide lors de la déconnexion. Sans URL correspondante, les utilisateurs ne seront pas redirigés vers votre application après la déconnexion et resteront plutôt sur une page Auth0 générique.

      Le schéma d’URL inclut le nom de votre package (`com.auth0.samples.android`) afin que le rappel soit acheminé vers votre application précise.
    </Info>

    <Warning>
      **Important** : Assurez-vous que le nom du package dans vos URL de rappel correspond à votre `applicationId` dans `build.gradle.kts`. Si l’authentification échoue, vérifiez que ces valeurs sont identiques.
    </Warning>

    <Tip>
      Lorsque vous utilisez le schéma `https` (comme configuré ci-dessus), vous devez configurer les Android App Links pour qu’Android achemine l’URL de rappel directement vers votre application au lieu de l’ouvrir dans un navigateur. Consultez la section **Configure Android App Links** sous [Dépannage et options avancées](#troubleshooting--advanced) ci-dessous.
    </Tip>
  </Step>

  <Step title="Initialiser le SDK Auth0" stepNumber={4}>
    Créez une instance d’Auth0 dans votre activité pour communiquer avec Auth0.

    **Dans votre `MainActivity.kt` :**

    ```kotlin MainActivity.kt lines theme={null}
    import com.auth0.android.Auth0
    import com.auth0.android.authentication.AuthenticationException
    import com.auth0.android.callback.Callback
    import com.auth0.android.provider.WebAuthProvider
    import com.auth0.android.result.Credentials

    class MainActivity : ComponentActivity() {
        private lateinit var auth0: Auth0

        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            
            // Initialiser Auth0
            auth0 = Auth0.getInstance(
                getString(R.string.com_auth0_client_id),
                getString(R.string.com_auth0_domain)
            )
        }
    }
    ```

    <Tip>
      L’instance Auth0 est initialisée à l’aide de votre ID client et de votre domaine provenant du fichier `strings.xml` que vous avez configuré précédemment. Cette instance sera utilisée pour toutes les opérations d’authentification.
    </Tip>
  </Step>

  <Step title="Mettre en œuvre la connexion et la déconnexion" stepNumber={5}>
    **Implémenter la connexion :** utilisez WebAuthProvider pour lancer la page Universal Login.

    Ajoutez ces méthodes à votre `MainActivity` :

    <Tabs>
      <Tab title="Callback Kotlin">
        ```kotlin MainActivity.kt lines theme={null}
        private fun login() {
            WebAuthProvider.login(auth0)
                .withScheme("https")
                .withScope("openid profile email offline_access")
                .start(this, object : Callback<Credentials, AuthenticationException> {
                    override fun onSuccess(credentials: Credentials) {
                        // Enregistrez les identifiants
                        // L'utilisateur est authentifié
                    }

                    override fun onFailure(exception: AuthenticationException) {
                        // Gérer les cas d'erreur
                    }
                })
        }
        ```
      </Tab>

      <Tab title="Coroutine">
        ```kotlin MainActivity.kt lines theme={null}
        private fun login() {
            lifecycleScope.launch {
                try {
                    val credentials = WebAuthProvider.login(auth0)
                        .withScheme("https")
                        .withScope("openid profile email offline_access")
                        .await(this@MainActivity)
                    // Enregistrez les identifiants
                    // L'utilisateur est authentifié
                } catch (exception: AuthenticationException) {
                    // Gérer l'erreur
                }
            }
        }
        ```
      </Tab>
    </Tabs>

    **Implémenter la déconnexion :** utilisez WebAuthProvider pour effacer la session de l'utilisateur.

    <Tabs>
      <Tab title="Callback Kotlin">
        ```kotlin MainActivity.kt lines theme={null}
        private fun logout() {
            WebAuthProvider.logout(auth0)
                .withScheme("https")
                .start(this, object : Callback<Void?, AuthenticationException> {
                    override fun onSuccess(result: Void?) {
                        // Effacez les identifiants enregistrés
                        // L'utilisateur est déconnecté
                    }

                    override fun onFailure(exception: AuthenticationException) {
                        // Gérer l'erreur
                    }
                })
        }
        ```
      </Tab>

      <Tab title="Coroutine">
        ```kotlin MainActivity.kt lines theme={null}
        private fun logout() {
            lifecycleScope.launch {
                try {
                    WebAuthProvider.logout(auth0)
                        .withScheme("https")
                        .await(this@MainActivity)
                    // Effacez les identifiants enregistrés
                    // L'utilisateur est déconnecté
                } catch (exception: AuthenticationException) {
                    // Gérer l'erreur
                }
            }
        }
        ```
      </Tab>
    </Tabs>

    <Info>
      Les méthodes `login()` et `logout()` doivent être appelées lorsque l’utilisateur appuie sur les boutons correspondants dans votre interface utilisateur. Le code utilise `this` (qui fait référence à l’Activity) comme paramètre de contexte, ce qui est requis pour que WebAuthProvider puisse lancer Chrome Custom Tabs et gérer le flux d’authentification.
    </Info>
  </Step>

  <Step title="Lancez votre application" stepNumber={6}>
    Compilez et exécutez votre application Android.

    **Dans Android Studio :**

    ```shellscript theme={null}
    # Synchroniser le projet avec les fichiers Gradle (ou utiliser « Sync Now » dans Android Studio)
    ./gradlew clean build

    # Compiler et installer sur l'appareil connecté ou l'émulateur
    ./gradlew installDebug

    # Ou exécuter directement depuis Android Studio
    # Cliquer sur le bouton « Run » ou appuyer sur Shift+F10
    ```

    **Déroulement attendu :**

    1. L’application s’ouvre avec un bouton "Se connecter" et une icône de bouclier
    2. Touchez "Se connecter" → une Chrome Custom Tab s’ouvre → Terminez la connexion
    3. Retour automatique à l’application
    4. Succès !!

    <Warning>
      Android affiche une boîte de dialogue de sélection du navigateur si plusieurs navigateurs sont installés. Les Chrome Custom Tabs offrent la meilleure expérience utilisateur pour l’authentification Auth0.
    </Warning>
  </Step>
</Steps>

<Check>
  **Point de contrôle**

  Vous devriez maintenant disposer d’une expérience de connexion à Auth0 entièrement fonctionnelle sur votre appareil Android ou votre émulateur. L’application utilise les onglets Chrome personnalisés pour assurer une authentification sécurisée et stocke automatiquement les identifiants.
</Check>

***

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

<Accordion title="Problèmes courants et solutions">
  ### onglet Chrome personnalisé ne redirige pas vers l’application

  **Solutions :**

  1. Vérifiez que **Allowed Callback URLs** dans Auth0 Dashboard correspond exactement à votre `applicationId`
  2. Vérifiez que les variables de substitution du manifeste dans `build.gradle.kts` sont correctes
  3. Assurez-vous que les URL HTTPS et les URL avec schéma personnalisé sont toutes les deux configurées
  4. Nettoyez et regénérez le projet : **Build** → **Clean Project** → **Rebuild Project**

  ### L’application plante : 'Auth0 domain not found'

  **Correctif :**

  1. Vérifiez que les valeurs `com_auth0_domain` et `com_auth0_client_id` sont correctes
  2. Assurez-vous qu’il n’y a pas de faute de frappe dans le format du domaine (il ne doit pas inclure `https://`)

  ### Erreurs de compilation liées aux dépendances

  **Correctif :**

  1. Mettez à jour le plugin Android Gradle vers la version la plus récente dans `build.gradle` (niveau du projet)
  2. Synchronisez le projet : **File** → **Sync Project with Gradle Files**
  3. Nettoyez la compilation : `./gradlew clean build`

  ### Authentification annulée par l’utilisateur

  Gérez ce cas correctement dans votre rappel d’erreur :

  ```kotlin {3,4,5,6} expandable theme={null}
  override fun onFailure(exception: AuthenticationException) {
      when {
          exception.isAuthenticationCanceled -> 
              showMessage("Login was cancelled")
          exception.isBrowserAppNotAvailable -> 
              showMessage("No browser available")
          else -> 
              showMessage("Login failed: ${exception.getDescription()}")
      }
  }
  ```

  ### Erreur : aucun navigateur compatible

  * Installez Chrome ou un autre navigateur moderne sur votre appareil ou émulateur
  * Activez les onglets Chrome personnalisés pour améliorer l’expérience utilisateur
  * Testez sur un appareil réel avec Chrome installé
</Accordion>

<Accordion title="Configurer Android App Links">
  Les [Android App Links](https://developer.android.com/training/app-links) permettent à votre application de se définir comme gestionnaire par défaut des URL de rappel Auth0, pour une expérience d’authentification plus sécurisée et fluide. Sans App Links, Android peut afficher une boîte de dialogue de choix demandant à l’utilisateur de choisir entre votre application et un navigateur.

  <Note>
    Les App Links utilisent des URL de rappel vérifiées avec le schéma `https`. C’est plus sécuritaire que les schémas d’URL personnalisés, qui peuvent être vulnérables aux [attaques d’usurpation de client](https://datatracker.ietf.org/doc/html/rfc8252#section-8.6).
  </Note>

  ### Obtenir l’empreinte du certificat de signature

  Vous avez besoin de l’empreinte SHA256 du certificat de signature de votre application. Exécutez la commande suivante dans votre terminal :

  ```shellscript theme={null}
  # Pour les builds de débogage
  keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android

  # Pour les builds de publication
  keytool -list -v -keystore my-release-key.keystore
  ```

  Copiez la valeur de l’empreinte **SHA256** dans la sortie.

  ### Configurer dans Auth0 Dashboard

  1. Accédez à [Auth0 Dashboard > Applications > Applications](https://manage.auth0.com/#/applications), puis sélectionnez votre application
  2. Faites défiler jusqu’au bas de la page **Settings**, puis sélectionnez **Show Advanced Settings**
  3. Sélectionnez l’onglet **Device Settings**
  4. Sous **Android**, indiquez :
     * **App Package Name** : votre `applicationId` (par ex. `com.auth0.samples.android`)
     * **SHA256 Cert Fingerprints** : l’empreinte que vous avez copiée ci-dessus
  5. Cliquez sur **Save Changes**

  ### Vérifier la configuration

  Auth0 génère automatiquement le fichier `assetlinks.json` utilisé par Android pour vérifier votre application. Testez-le en accédant à :

  ```
  https://{yourDomain}/.well-known/assetlinks.json
  ```

  Vous devriez voir une réponse JSON contenant le nom du package et l’empreinte du certificat :

  ```json theme={null}
  [{
    "relation": ["delegate_permission/common.handle_all_urls"],
    "target": {
      "namespace": "android_app",
      "package_name": "[YOUR_PACKAGE_NAME]",
      "sha256_cert_fingerprints": ["YOUR_SHA256_FINGERPRINT"]
    }
  }]
  ```

  <Info>
    Le guide de démarrage rapide utilise déjà `https` comme schéma dans les variables de substitution du manifeste et les appels `WebAuthProvider`, ce qui est requis pour les App Links. Aucun changement de code n’est nécessaire si vous avez suivi les étapes ci-dessus.
  </Info>

  Pour en savoir plus, consultez la documentation [Enable Android App Links Support](/fr-CA/docs/get-started/applications/enable-android-app-links-support) et le guide Android [Verify App Links](https://developer.android.com/training/app-links/verify-site-associations).
</Accordion>

<Accordion title="Utiliser un schéma d’URL personnalisé">
  Si vous ne pouvez pas utiliser Android App Links (par exemple, si vous ciblez des versions de l’API Android inférieures à 23), vous pouvez plutôt configurer un schéma d’URL personnalisé.

  <Warning>
    Les schémas d’URL personnalisés sont moins sécurisés que les App Links, car ils peuvent être vulnérables aux [attaques d’usurpation de client](https://datatracker.ietf.org/doc/html/rfc8252#section-8.6). Utilisez les App Links chaque fois que possible.
  </Warning>

  1. Mettez à jour l’espace réservé `auth0Scheme` du manifeste dans votre `app/build.gradle.kts` :

  ```kotlin app/build.gradle.kts lines theme={null}
  android {
      defaultConfig {
          manifestPlaceholders += mapOf(
              "auth0Domain" to "@string/com_auth0_domain",
              "auth0Scheme" to "myapp" // Utilisez un schéma personnalisé unique
          )
      }
  }
  ```

  2. Mettez à jour les paramètres **Allowed Callback URLs** et **Allowed Logout URLs** de votre application dans l’[Auth0 Dashboard](https://manage.auth0.com/#/applications) pour utiliser le schéma personnalisé :

  ```
  myapp://{yourDomain}/android/PACKAGE_NAME/callback
  ```

  3. Indiquez le schéma personnalisé lors de l’appel à `WebAuthProvider` :

  ```kotlin MainActivity.kt lines theme={null}
  WebAuthProvider.login(auth0)
      .withScheme("myapp")
      .withScope("openid profile email offline_access")
      .start(this, callback)
  ```

  <Note>
    Les schémas personnalisés [ne peuvent contenir que des lettres minuscules](https://developer.android.com/guide/topics/manifest/data-element).
  </Note>
</Accordion>

<Accordion title="Déploiement en production">
  ### Préparation pour la boutique d’applications

  * Configurez Android App Links pour une authentification sans friction
  * Testez sur plusieurs versions d’Android et tailles d’écran
  * Implémentez une gestion adéquate des erreurs en cas de défaillance réseau
  * Ajoutez des règles ProGuard pour le SDK Auth0 si vous utilisez l’obfuscation du code
  * Respectez les politiques du Google Play Store pour les flux d’authentification

  ### Considérations de sécurité

  * Utilisez `SecureCredentialsManager` pour stocker les identifiants en production
  * Implémentez l’épinglage de certificats pour renforcer la sécurité de l’API
  * Envisagez Android Keystore pour mieux protéger les identifiants
  * Activez l’authentification biométrique pour les opérations sensibles
</Accordion>

<Accordion title="Intégration Android avancée">
  ### Sécurité renforcée des identifiants

  Implémentez l’authentification biométrique pour accéder aux identifiants :

  ```kotlin AuthenticationManager.kt expandable lines theme={null}
  class AuthenticationManager(private val context: Context) {
      
      private val credentialsManager: SecureCredentialsManager
      
      init {
          val authentication = AuthenticationAPIClient(auth0)
          val storage = SharedPreferencesStorage(context)
          credentialsManager = SecureCredentialsManager(context, authentication, storage)
          
          // Activer l’authentification biométrique
          credentialsManager.requireAuthentication(
              context as FragmentActivity,
              REQUEST_CODE_BIOMETRIC,
              "Biometric Authentication",
              "Please authenticate to access your account"
          )
      }
      
      companion object {
          private const val REQUEST_CODE_BIOMETRIC = 321
      }
  }
  ```

  ### Scopes et audience personnalisés

  Demandez des scopes et une audience précis pour votre API :

  ```kotlin AuthenticationManager.kt expandable lines theme={null}
  fun login() {
      WebAuthProvider.login(auth0)
          .withScheme("https")
          .withScope("openid profile email offline_access read:posts")
          .withAudience("https://myapi.example.com")
          .withParameter("prompt", "login")
          .start(context as MainActivity, loginCallback)
  }
  ```

  ### Configuration réseau

  Gérez la sécurité réseau et l’épinglage de certificats :

  ```xml app/src/main/res/xml/network_security_config.xml expandable lines theme={null}
  <?xml version="1.0" encoding="utf-8"?>
  <network-security-config>
      <domain-config>
          <domain includeSubdomains="true">your-auth0-domain.auth0.com</domain>
          <pin-set>
              <pin digest="SHA-256">AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</pin>
          </pin-set>
      </domain-config>
  </network-security-config>
  ```

  Ajoutez ceci à `AndroidManifest.xml` :

  ```xml theme={null}
  <application
      android:networkSecurityConfig="@xml/network_security_config"
      ... />
  ```
</Accordion>