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

# Ajouter la connexion à votre application Android

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

<Steps>
  <Step title="Créez 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 :
       * **Nom** : `Auth0-Android-Sample`
       * **Nom du package** : `com.auth0.samples.android`
       * **Langage** : **Kotlin**
       * **Minimum SDK** : **API 24 (Android 7.0)**
       * **Langage de configuration de build** : **Kotlin DSL**
    4. Cliquez sur **Finish**

    <Tip>
      Ceci crée une application Android moderne avec Kotlin et Gradle Kotlin DSL, conformément aux meilleures pratiques actuelles en matière de développement Android.
    </Tip>
  </Step>

  <Step title="Ajouter la trousse de développement logiciel (SDK) Auth0 à l’aide de Gradle" stepNumber={2}>
    Ajoutez la Trousse de développement logiciel (SDK) Auth0 pour Android à 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.11.0")
    }
    ```

    **Ajoutez l’autorisation 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>
      La trousse de développement logiciel (SDK) Auth0 gère automatiquement la gestion des dépendances et inclut des fonctionnalités de stockage sécurisé des jetons.
    </Tip>
  </Step>

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

    Commencez par préparer votre fichier `app/src/main/res/values/strings.xml` avec des valeurs d’exemple :

    ```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. Passez à l’onglet **Settings** sur la page des détails de l’application.
    5. Remplacez `{yourDomain}` et `YOUR_AUTH0_CLIENT_ID` dans le fichier `strings.xml` par les valeurs **Domain** et **Client ID** depuis l’Auth0 Dashboard.

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

    **URL de redirection autorisées :**

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

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

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

    Remplacez `{yourDomain}` par votre véritable domaine Auth0 (par exemple, `dev-abc123.us.auth0.com`).

    <Info>
      Les **URL de redirection autorisées** sont une mesure de sécurité essentielle pour s'assurer que les utilisateurs sont renvoyés en toute sécurité vers votre application après l'authentification. Sans URL correspondante, le processus de connexion échouera et les utilisateurs seront bloqués par une page d’erreur Auth0 au lieu d’accéder à votre application.

      Les **URL de déconnexion autorisées** 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 sur une page Auth0 générique.

      Le schéma d’URL inclut votre nom de package (`com.auth0.samples.android`) pour s'assurer que le callback est dirigé vers votre application.
    </Info>

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

  <Step title="Initialiser la trousse de développement logiciel Auth0 (SDK)" stepNumber={4}>
    Créez une instance Auth0 dans votre Activity 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 avec votre ID client et votre domaine, définis dans le fichier `strings.xml` que vous avez configuré auparavant. Cette instance sera utilisée pour toutes les opérations d'authentification.
    </Tip>
  </Step>

  <Step title="Implémenter la connexion et la déconnexion" stepNumber={5}>
    **Implémentez la connexion :** Utilisez `WebAuthProvider` pour lancer la page Universal Login.

    Ajoutez ces méthodes à votre `MainActivity` :

    <Tabs>
      <Tab title="Rappel 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) {
                        // Enregistrer les informations d'identification
                        // 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)
                    // Enregistrer les informations d'identification
                    // L'utilisateur est authentifié
                } catch (exception: AuthenticationException) {
                    // Gérer l'erreur
                }
            }
        }
        ```
      </Tab>
    </Tabs>

    **Implémentez la déconnexion :** Utilisez `WebAuthProvider` pour effacer la session de l'utilisateur.

    <Tabs>
      <Tab title="Rappel 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?) {
                        // Effacer les informations d'identification enregistrées
                        // 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)
                    // Effacer les informations d'identification enregistrées
                    // 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 ouvrir des Chrome Custom Tabs et gérer le flux d'authentification.
    </Info>
  </Step>

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

    **Dans Android Studio :**

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

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

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

    **Flux attendu :**

    1. L’app se lance avec le bouton « Log In » et l’icône de bouclier
    2. Appuyez sur « Log In » → Chrome Custom Tab s’ouvre → Terminez la connexion
    3. Retour automatique à l’app
    4. Succès !

    <Warning>
      Android affichera une boîte de dialogue de sélection de navigateur si plusieurs navigateurs sont installés. Chrome Custom Tabs offrent la meilleure expérience utilisateur pour l’authentification avec 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 Chrome Custom Tabs pour une authentification sécurisée et enregistre automatiquement les identifiants.
</Check>

***

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

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

  **Solutions :**

  1. Vérifiez que **Allowed Callback URLs** dans Auth0 Dashboard correspondent exactement à votre `applicationId`
  2. Vérifiez que les espaces réservés du manifeste dans `build.gradle.kts` sont corrects
  3. Assurez-vous que les URL HTTPS et celles avec un schéma personnalisé sont configurées
  4. Nettoyez et reconstruisez : **Build** → **Clean Project** → **Rebuild Project**

  ### L'application se bloque : « 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 aucune faute de frappe dans le format du domaine (ne doit pas inclure `https://`)

  ### Erreurs de compilation avec les dépendances

  **Correctif :**

  1. Mettez à jour vers la dernière version d'Android Gradle Plugin dans `build.gradle` (niveau projet)
  2. Synchronisez le projet : **File** → **Sync Project with Gradle Files**
  3. Effectuez une compilation propre : `./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/émulateur
  * Activez les onglets Chrome personnalisés pour une meilleure expérience utilisateur
  * Effectuez des tests sur un appareil réel avec Chrome installé
</Accordion>

<Accordion title="Déploiement en production">
  ### Préparation pour l'App Store

  * Configurez Android App Links pour une authentification fluide
  * Testez sur plusieurs versions d'Android et de tailles d'écran
  * Implémentez une gestion appropriée des erreurs pour les défaillances réseau
  * Ajoutez des règles ProGuard pour la trousse de développement logiciel (SDK) Auth0 si vous utilisez l'obfuscation de code
  * Suivez les politiques de Google Play Store pour les flux d'authentification

  ### Considérations de sécurité

  * Utilisez `SecureCredentialsManager` pour le stockage des informations d'identification en production
  * Implémentez le « certificate pinning » pour une sécurité API supplémentaire
  * Envisagez d'utiliser Android Keystore pour une protection renforcée des informations d'identification
  * Activez l'authentification biométrique pour les opérations sensibles
</Accordion>

<Accordion title="Intégration Android avancée">
  ### Sécurité renforcée des informations d'identification

  Implémentez l'authentification biométrique pour l'accès aux informations d'identification :

  ```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
      }
  }
  ```

  ### Portées et audience personnalisées

  Demandez des portées et une audience spécifiques 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 le « certificate pinning » :

  ```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 ce qui suit à `AndroidManifest.xml` :

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