Passer au contenu principal

​
Pour commencer

1

Créez un nouveau projet Android

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
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.
2

Ajouter la trousse de développement logiciel (SDK) Auth0 à l’aide de Gradle

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 :
app/build.gradle.kts
dependencies {   
    // SDK Auth0
    implementation("com.auth0.android:auth0:3.11.0")
}
Ajoutez l’autorisation 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>
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.
3

Configurez votre application Auth0

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 :
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 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).
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.
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.
4

Initialiser la trousse de développement logiciel Auth0 (SDK)

Créez une instance Auth0 dans votre Activity 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 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.
5

Implémenter la connexion et la déconnexion

Implémentez la connexion : Utilisez WebAuthProvider pour lancer la page Universal Login.Ajoutez ces méthodes à votre MainActivity :
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) {
                // Enregistrer les informations d'identification
                // L'utilisateur est authentifié
            }

            override fun onFailure(exception: AuthenticationException) {
                // Gérer les cas d'erreur
            }
        })
}
Implémentez la déconnexion : Utilisez WebAuthProvider pour effacer la session de l’utilisateur.
MainActivity.kt
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
            }
        })
}
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.
6

Lancez votre application

Générez et exécutez votre application Android.Dans Android Studio :
# 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 !
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.
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 Chrome Custom Tabs pour une authentification sécurisée et enregistre automatiquement les identifiants.

​
Dépannage et fonctionnalités avancées

​
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 :
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é

​
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

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

Implémentez l’authentification biométrique pour l’accès 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)
        
        // 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 :
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 le « certificate pinning » :
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 ce qui suit à AndroidManifest.xml :
<application
    android:networkSecurityConfig="@xml/network_security_config"
    ... />