Ajouter la fonctionnalité de connexion à votre application Android avec le SDK Auth0.Android

Utiliser l’IA pour intégrer Auth0

Si vous utilisez un assistant de programmation IA comme Claude Code, Cursor ou GitHub Copilot, vous pouvez ajouter l’authentification Auth0 automatiquement en quelques minutes à l’aide d’Agent Skills.

Installer :

npx skills add auth0/agent-skills --skill auth0

Ensuite, demandez à votre assistant IA :

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 Android Auth0, configurera les espaces réservés du manifeste et mettra en œuvre les flux de connexion et de déconnexion. Documentation complète d’Agent Skills →

​

Pour commencer

1. Créer un nouveau projet Android

   Créez un nouveau projet Android pour ce guide de 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
      • Langue : Kotlin
      • SDK minimal : API 24 (Android 7.0)
      • Langage de configuration de compilation : Kotlin DSL
   4. Cliquez sur Finish

   Cela crée une application Android moderne avec Kotlin et Gradle Kotlin DSL, conformément aux pratiques exemplaires actuelles du développement Android.

2. Ajouter le SDK Auth0 avec Gradle

   Ajoutez le SDK Android d’Auth0 à votre projet à l’aide de Gradle.

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

   app/build.gradle.kts

   dependencies {   
       // SDK Auth0
       implementation("com.auth0.android:auth0:4.0.0")
   }
   

   Ajoutez des espaces réservés du manifeste dans le fichier build.gradle.kts de votre application :

   app/build.gradle.kts

   android {
       defaultConfig {
           // Ajoutez 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 l’autorisation Internet au fichier AndroidManifest.xml :

   app/src/main/AndroidManifest.xml

   <?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>
   

   Le SDK Auth0 gère automatiquement la résolution des dépendances et offre des capacités de stockage sécurisé des jetons.

3. Configurez votre Auth0 App

   L’étape suivante consiste à créer une nouvelle application sur votre tenant Auth0 et à ajouter la configuration à votre projet Android.

   Pour commencer, préparez votre fichier app/src/main/res/values/strings.xml avec des valeurs fictives :

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

   <?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
   2. Cliquez sur Applications > Applications > Create Application
   3. Dans la fenêtre popup, entrez un nom pour votre application, sélectionnez Native comme type d’application, puis cliquez sur Create
   4. Ouvrez l’onglet Settings dans 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 du 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 (p. ex. dev-abc123.us.auth0.com).

   Allowed Callback URLs constituent une mesure de sécurité essentielle pour s’assurer que les utilisateurs sont redirigés en toute sécurité 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 callback soit acheminé vers votre application.

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

   Lorsque vous utilisez le schéma https (comme configuré ci-dessus), vous devez configurer Android App Links afin qu’Android achemine l’URL de callback directement vers votre application au lieu de l’ouvrir dans un navigateur. Consultez la section Configurer Android App Links sous Dépannage et avancé ci-dessous.

4. Initialiser le SDK Auth0

   Créez une instance d’Auth0 dans votre Activity afin de communiquer avec Auth0.

   Dans votre MainActivity.kt :

   MainActivity.kt

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

   L’instance Auth0 est initialisée avec votre ID client et 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.

5. Implement Login et Logout

   Implémentez la connexion : Utilisez WebAuthProvider pour lancer la page de connexion Universal Login.

   Ajoutez ces méthodes à votre MainActivity :

   Callback Kotlin

   MainActivity.kt

   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érez les cas d'erreur
               }
           })
   }
   

   Coroutine

   MainActivity.kt

   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érez l'erreur
           }
       }
   }
   

   Implémentez le Logout : Utilisez WebAuthProvider pour effacer la session de l’utilisateur.

   Callback Kotlin

   MainActivity.kt

   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érez l'erreur
               }
           })
   }
   

   Coroutine

   MainActivity.kt

   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érez l'erreur
           }
       }
   }
   

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

6. Exécutez votre application

   Compilez et exécutez votre application Android.

   Dans Android Studio :

   # 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 le bouton “Se connecter” et une icône de bouclier
   2. Touchez “Se connecter” → un Chrome Custom Tab s’ouvre → terminez la connexion
   3. Retour automatique à l’application
   4. Réussite !!

   Android affichera une boîte de dialogue pour choisir le navigateur si plusieurs navigateurs sont installés. Chrome Custom Tabs offrent la meilleure expérience utilisateur pour l’authentification Auth0.

Vérification

Vous devriez maintenant avoir 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.

---

​

Dépannage et options avancées

Problèmes courants et solutions

​

Chrome Custom Tab ne redirige pas vers l’application

Solutions :

1. Vérifiez que les 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 utilisant un schéma personnalisé sont toutes deux configurées
4. Nettoyez et recompilez : 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 fautes 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 Android Gradle Plugin vers la version la plus récente dans build.gradle (au 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 cela correctement dans votre callback d’erreur :

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 Chrome Custom Tabs pour une meilleure expérience utilisateur
• Faites le Test sur un appareil réel avec Chrome installé

Configurer Android App Links

Android App Links permettent à votre application de se définir comme le gestionnaire par défaut des callback URLs d’Auth0, offrant une expérience d’authentification plus sécurisée et fluide. Sans App Links, Android peut afficher une boîte de dialogue de désambiguïsation demandant à l’utilisateur de choisir entre votre application et un navigateur.

Les App Links utilisent des callbacks avec schéma https vérifié. C’est plus sécuritaire que les schémas d’URL personnalisés, qui peuvent être vulnérables aux attaques d’usurpation de client.

​

Obtenez l’empreinte de votre 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 :

# Pour les compilations de débogage
keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android

# Pour les compilations de production
keytool -list -v -keystore my-release-key.keystore

Copiez la valeur de l’empreinte SHA256 à partir du résultat.

​

Configurer dans Auth0 Dashboard

1. Accédez à Auth0 Dashboard > Applications > Applications, puis sélectionnez votre application
2. Faites défiler jusqu’au bas de la page Settings et sélectionnez Show Advanced Settings
3. Sélectionnez l’onglet Device Settings
4. Sous Android, indiquez :
   • App Package Name : votre applicationId (p. 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 de votre application :

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

Le Quickstart utilise déjà https comme schéma dans les espaces réservés du manifeste et les requêtes WebAuthProvider, ce qui est requis pour les App Links. Aucun changement au code n’est nécessaire si vous avez suivi les étapes ci-dessus.

Pour en savoir plus, consultez la documentation Enable Android App Links Support et le guide Android Verify App Links.

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 configurer à la place un schéma d’URL personnalisé.

Les schémas d’URL personnalisés sont moins sécuritaires que les App Links, car ils peuvent être vulnérables aux attaques d’usurpation de client. Utilisez les App Links chaque fois que possible.

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

app/build.gradle.kts

android {
    defaultConfig {
        manifestPlaceholders += mapOf(
            "auth0Domain" to "@string/com_auth0_domain",
            "auth0Scheme" to "myapp" // Utilisez un schéma personnalisé unique
        )
    }
}

2. Mettez à jour les Allowed Callback URLs et les Allowed Logout URLs dans les paramètres de votre application du Auth0 Dashboard pour utiliser le schéma personnalisé :

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

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

MainActivity.kt

WebAuthProvider.login(auth0)
    .withScheme("myapp")
    .withScope("openid profile email offline_access")
    .start(this, callback)

Les schémas personnalisés ne peuvent contenir que des lettres minuscules.

Déploiement en production

​

Préparation pour la mise en ligne

• Configurez Android App Links pour une authentification sans friction
• Testez sur plusieurs versions d’Android et tailles d’écran
• Prévoyez une gestion adéquate des erreurs en cas de panne réseau
• Ajoutez des règles ProGuard pour l’Auth0 SDK 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 informations d’identification en production
• Mettez en œuvre l’épinglage de certificats pour renforcer la sécurité de l’API
• Envisagez Android Keystore pour mieux protéger les informations d’identification
• Activez l’authentification biométrique pour les opérations sensibles

Intégration Android avancée

​

Sécurité renforcée des informations d’identification

Mettez en œuvre l’authentification biométrique pour accéder aux informations d’identification :

AuthenticationManager.kt

class AuthenticationManager(private val context: Context) {
    
    private val credentialsManager: SecureCredentialsManager
    
    init {
        val authentication = AuthenticationAPIClient(auth0)
        val storage = SharedPreferencesStorage(context)
        credentialsManager = SecureCredentialsManager(context, authentication, storage)
        
        // Enable biometric authentication
        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 personnalisés et audience

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

AuthenticationManager.kt

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 :

app/src/main/res/xml/network_security_config.xml

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

<application
    android:networkSecurityConfig="@xml/network_security_config"
    ... />