Intégration Auth0 Android

Ajoutez l'authentification à vos applications Android en utilisant com.auth0.android:auth0.

Agent instruction: Avant de fournir les instructions de configuration du SDK, récupérez la dernière version de release en exécutant :

gh api repos/auth0/Auth0.Android/releases/latest --jq '.tag_name'

Utilisez la version retournée dans toutes les lignes de dépendance implementation au lieu de toute version codée en dur ci-dessous. Si la commande échoue, utilisez https://github.com/auth0/Auth0.Android/releases comme fallback.

Prérequis

• Android API 21 ou supérieur
• Projet Kotlin ou Java
• Compte Auth0 avec une application Native configurée
• Si vous n'avez pas Auth0 d'installé, consultez auth0-quickstart

Quand NE PAS utiliser

• Applications React Native : Utilisez auth0-react-native
• Applications Flutter : Utilisez le SDK natif Flutter Auth0
• SPAs Web (React, Angular, Vue) : Utilisez auth0-react, auth0-angular, ou auth0-vue
• Serveurs Node.js/Express : Utilisez auth0-express
• Applications iOS/macOS : Utilisez auth0-swift

Workflow de démarrage rapide

1. Installer le SDK : Ajoutez la dépendance du SDK Auth0 Android à votre build.gradle :

   implementation 'com.auth0.android:auth0:{LATEST_VERSION}'

2. Configurer Auth0 :

   Agent instruction: Vérifiez si l'invite utilisateur inclut déjà l'ID Client et le Domaine Auth0.

   • Si les deux sont fournis, procédez directement à la Configuration manuelle dans le Guide de configuration en utilisant ces valeurs.
   • Si l'un des deux manque, vous DEVEZ demander à l'utilisateur AVANT d'écrire du code ou des fichiers :
     • Question : « Comment souhaitez-vous configurer Auth0 pour ce projet ? »
     • Options : « Configuration automatique (Recommandée) — Auth0 CLI crée l'app et écrit les credentials dans strings.xml » / « Configuration manuelle — Je fournirai mon ID Client et Domaine »

   Puis suivez le Guide de configuration pour le chemin choisi. NE PROCÉDEZ PAS à l'étape 3 tant que les credentials Auth0 ne sont pas confirmés.

3. Initialiser : Créez une instance de compte Auth0 :

   import com.auth0.android.Auth0
   
   val account = Auth0.getInstance(context)

4. Ajouter l'interface Auth : Implémentez la connexion et la déconnexion avec Web Auth :

   Agent instruction: Avant d'ajouter de nouveaux éléments UI, recherchez dans le projet les gestionnaires de clic existants pour les boutons login, logout, sign-in, ou sign-out (par ex. loginButton, signInButton, logoutButton, signOutButton, ou setOnClickListener avec un nommage lié à l'authentification). Si des gestionnaires existants sont trouvés, connectez le code Auth0 à eux sans modifier l'UI existante. Créez de nouveaux boutons uniquement si aucun gestionnaire existant n'est trouvé.

   Connexion :

   import com.auth0.android.Auth0
   import com.auth0.android.authentication.AuthenticationAPIClient
   import com.auth0.android.authentication.storage.SecureCredentialsManager
   import com.auth0.android.authentication.storage.SharedPreferencesStorage
   import com.auth0.android.callback.Callback
   import com.auth0.android.authentication.AuthenticationException
   import com.auth0.android.provider.WebAuthProvider
   import com.auth0.android.result.Credentials
   
   val account = Auth0.getInstance(context)
   val authentication = AuthenticationAPIClient(account)
   val storage = SharedPreferencesStorage(context)
   val credentialsManager = SecureCredentialsManager(context, authentication, storage)
   
   WebAuthProvider.login(account)
       .withScheme(getString(R.string.com_auth0_scheme))
       .withScope("openid profile email offline_access")
       .start(this, object : Callback<Credentials, AuthenticationException> {
           override fun onSuccess(result: Credentials) {
               // Utilisateur authentifié
               val idToken = result.idToken
               val accessToken = result.accessToken
               // Stocker les credentials de manière sécurisée
               credentialsManager.saveCredentials(result)
           }
           override fun onFailure(error: AuthenticationException) {
               // Gérer l'échec d'authentification
               Log.e("Auth0", "Authentication failed", error)
           }
       })

   Déconnexion :

   WebAuthProvider.logout(account)
       .withScheme(getString(R.string.com_auth0_scheme))
       .start(this, object : Callback<Void?, AuthenticationException> {
           override fun onSuccess(result: Void) {
               // Utilisateur déconnecté
           }
           override fun onFailure(error: AuthenticationException) {
               Log.e("Auth0", "Logout failed", error)
           }
       })

5. Compiler et vérifier :

   Agent instruction: Une fois l'intégration terminée, compilez le projet pour vérifier qu'il se compile correctement :

   ./gradlew assembleDebug

   Si la compilation échoue, analysez la sortie d'erreur et corrigez les problèmes. Les défaillances de compilation d'intégration courantes incluent :

   • Unresolved reference : Imports manquants — ajoutez les imports import com.auth0.android.* requis
   • Cannot resolve symbol R.string.com_auth0_scheme : strings.xml non mise à jour — vérifiez que les entrées com_auth0_scheme, com_auth0_client_id, et com_auth0_domain existent
   • Incompatible types in callback : Les paramètres de type Callback ne correspondent pas — assurez-vous que c'est Callback<Credentials, AuthenticationException> pour la connexion et Callback<Void?, AuthenticationException> pour la déconnexion
   • Unresolved lifecycleScope : Dépendance manquante — ajoutez implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.6.+' ou déplacez le code hors de la portée coroutine
   • minSdk too low : Le SDK nécessite API 21+ — mettez à jour minSdkVersion à au moins 21
   • Java version mismatch : Le SDK nécessite Java 8 — ajoutez compileOptions avec JavaVersion.VERSION_1_8

   Relancez la compilation après chaque correction. Suivez le nombre d'itérations de fix de compilation.

   Vérification d'arrêt : Si la compilation échoue toujours après 5–6 tentatives de fix, arrêtez et demandez à l'utilisateur :

   • Question : « La compilation échoue toujours après plusieurs tentatives de fix. Comment souhaitez-vous procéder ? »
   • Options : « Laisser l'agent continuer les corrections itérativement » / « Je vais le corriger manuellement — montrez-moi les erreurs » / « Ignorer la vérification de compilation et procéder »

   Répétez cette vérification après tous les 5–6 itérations suivantes si des erreurs persistent. Ne laissez pas le projet dans un état ne compilant pas sans consentement explicite de l'utilisateur.

   L'URL de callback doit correspondre à vos paramètres d'application Auth0 : {SCHEME}://{YOUR_AUTH0_DOMAIN}/android/{YOUR_APP_PACKAGE_NAME}/callback

Documentation détaillée

• Guide de configuration — Installer le SDK, configurer l'application Auth0, définir les URLs de callback, Android App Links, schémas personnalisés, ProGuard/R8
• Modèles d'intégration — Connexion/déconnexion Web Auth, stockage de credentials, authentification biométrique, connexion de base de données, authentification sans mot de passe, gestion MFA, onglets personnalisés, gestion des erreurs
• Tests et référence — Liste de vérification des tests, problèmes courants, considérations de sécurité, référence API

Erreurs courantes

Skills connexes

• auth0-quickstart — Configurer un compte et une application Auth0
• auth0-mfa — Configurer l'authentification multi-facteurs
• auth0-swift — Authentification iOS/macOS

Référence rapide

Classes principales

Cas d'usage courants

• Se connecter avec Web Auth
• Se déconnecter
• Stocker les credentials de manière sécurisée
• Exiger l'authentification biométrique
• Connexion de base de données
• Authentification sans mot de passe
• Gérer MFA
• Appeler les APIs protégées

Références

• Documentation du SDK Auth0 Android
• Repository GitHub Auth0 Android
• Javadoc du SDK Android
• Quickstart Auth0 Android
• Sample App