Ajouter la 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 automatiquement l’authentification Auth0 en quelques minutes à l’aide des agent skills.Installation :

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

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

Pour commencer

Créer un nouveau projet Android

Créez un nouveau projet Android pour ce démarrage rapide.Dans Android Studio :

File → New → New Project
Sélectionnez le modèle Phone and Tablet → Empty Activity
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
Cliquez sur Finish

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

Ajouter le SDK Auth0 via 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:3.14.0")
}

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

app/build.gradle.kts

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 :

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 comprend des mécanismes sécurisés de stockage des jetons.

Configurez votre application Auth0

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 :

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>

Accédez à l’Auth0 Dashboard
Cliquez sur Applications > Applications > Create Application
Dans la fenêtre contextuelle, saisissez un nom pour votre application, sélectionnez Native comme type d’application, puis cliquez sur Create
Ouvrez l’onglet Settings de la page des détails de l’application
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).

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.

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.

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 ci-dessous.

Initialiser le SDK Auth0

Créez une instance d’Auth0 dans votre activité pour 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 à 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.

Mettre en œuvre la connexion et la déconnexion

Implémenter la connexion : utilisez WebAuthProvider pour lancer la page Universal Login.Ajoutez ces méthodes à votre MainActivity :

Callback Kotlin
Coroutine

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

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

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

Callback Kotlin
Coroutine

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

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

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.

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

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

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.

Point de contrôleVous 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.

Dépannage et options avancées

Problèmes courants et solutions

onglet Chrome personnalisé ne redirige pas vers l’application

Solutions :

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

L’application plante : ‘Auth0 domain not found’

Correctif :

Vérifiez que les valeurs com_auth0_domain et com_auth0_client_id sont correctes
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 :

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

Authentification annulée par l’utilisateur

Gérez ce cas correctement dans votre rappel 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 les onglets Chrome personnalisés pour améliorer l’expérience utilisateur
Testez sur un appareil réel avec Chrome installé

Configurer Android App Links

Les Android 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.

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.

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 :

# 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

Accédez à Auth0 Dashboard > Applications > Applications, puis sélectionnez votre application
Faites défiler jusqu’au bas de la page Settings, puis sélectionnez Show Advanced Settings
Sélectionnez l’onglet Device Settings
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
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 :

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

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.

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 plutôt configurer un schéma d’URL personnalisé.

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. Utilisez les App Links chaque fois que possible.

Mettez à jour l’espace réservé auth0Scheme du manifeste dans votre 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
        )
    }
}

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

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

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

Intégration Android avancée

Sécurité renforcée des identifiants

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

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)
        
        // 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 :

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"
    ... />

​Pour commencer

​Dépannage et options avancées

​onglet Chrome personnalisé ne redirige pas vers l’application

​L’application plante : ‘Auth0 domain not found’

​Erreurs de compilation liées aux dépendances

​Authentification annulée par l’utilisateur

​Erreur : aucun navigateur compatible

​Obtenir l’empreinte du certificat de signature

​Configurer dans Auth0 Dashboard

​Vérifier la configuration

​Préparation pour la boutique d’applications

​Considérations de sécurité

​Sécurité renforcée des identifiants

​Scopes et audience personnalisés

​Configuration réseau

Pour commencer

Dépannage et options avancées

onglet Chrome personnalisé ne redirige pas vers l’application

L’application plante : ‘Auth0 domain not found’

Erreurs de compilation liées aux dépendances

Authentification annulée par l’utilisateur

Erreur : aucun navigateur compatible

Obtenir l’empreinte du certificat de signature

Configurer dans Auth0 Dashboard

Vérifier la configuration

Préparation pour la boutique d’applications

Considérations de sécurité

Sécurité renforcée des identifiants

Scopes et audience personnalisés

Configuration réseau