Créer une interface libre-service de sécurité du compte avec My Account API sur Android

Explique comment utiliser Universal Components pour créer des interfaces libre-service de sécurité du compte avec My Account API d’Auth0 sur Android.

Auth0 Universal Components pour Android vous permet de créer une interface libre-service de sécurité du compte dans votre application Android native.

Avec AuthenticatorSettingsComponent, les utilisateurs peuvent gérer leurs propres méthodes d’authentification — facteurs d’authentification multifacteur (MFA), clés d’accès et codes de récupération — directement dans votre application, sans avoir à ouvrir un navigateur Web ni à contacter le soutien.

​

Fonctionnement

Le AuthenticatorSettingsComponent utilise les méthodes d’authentification de l’API My Account d’Auth0 pour afficher, dans votre application, une interface permettant de gérer les méthodes d’authentification.

L’API My Account impose actuellement des limites de débit basses, particulièrement pour les tenants du niveau Free. Cela peut entraîner des erreurs lors de l’utilisation de ces composants.

Lorsqu’un utilisateur authentifié ouvre l’écran des paramètres de son compte, le SDK Auth0.Android récupère un jeton d’accès limité à l’audience de l’API My Account.

Le AuthenticatorSettingsComponent utilise le jeton d’accès pour appeler les endpoints /me/v1/authentication-methods de l’API My Account au nom de l’utilisateur connecté. Ainsi, chaque utilisateur ne peut modifier que ses propres méthodes d’authentification.

• Le AuthenticatorSettingsComponent crée des interfaces de libre-service destinées aux utilisateurs finaux. Les utilisateurs finaux peuvent inscrire, consulter et supprimer toutes les méthodes d’authentification de leur compte : OTP par courriel, OTP par SMS, TOTP (application d’authentification), notifications push par Auth0 Guardian, clés d’accès et codes de récupération.

• Pour les interfaces d’administration déléguée dans lesquelles un utilisateur gère une Auth0 Organization, consultez Créer une interface d’administration déléguée.

​

Prérequis

​

Activer l’API My Account

1. Accédez à Dashboard > Applications > APIs.
2. Sélectionnez Activer l’API My Account pour vous assurer qu’elle est activée pour votre tenant.

​

Créer une application et configurer les permissions de My Account API

1. Accédez à Dashboard > Applications.

2. Sélectionnez Create Application.

3. Sélectionnez Native.

4. Sélectionnez l’onglet Settings pour ajouter les URL de callback suivantes dans Allowed Callback URLs :

   https://YOUR_AUTH0_DOMAIN/android/YOUR_PACKAGE_NAME/callback, YOUR_SCHEME://YOUR_AUTH0_DOMAIN/android/YOUR_PACKAGE_NAME/callback
   

5. Ajoutez les mêmes URL dans Allowed Logout URLs.

   https://YOUR_AUTH0_DOMAIN/android/YOUR_PACKAGE_NAME/callback, YOUR_SCHEME://YOUR_AUTH0_DOMAIN/android/YOUR_PACKAGE_NAME/callback
   

6. Sélectionnez l’onglet API Access.

7. Sélectionnez Edit pour Auth0 My Account API afin d’ajouter les permissions d’accès délégué par l’utilisateur :

   create:me:authentication_methods read:me:authentication_methods update:me:authentication_methods delete:me:authentication_methods

8. Sélectionnez Save pour enregistrer les permissions.

• Le jeton d’accès de l’utilisateur ne comprend que les permissions qui lui ont été accordées lors de la connexion.
• Demandez les quatre scopes si vous voulez permettre aux utilisateurs de s’inscrire, de consulter et de supprimer des méthodes d’authentification.

​

Installer le SDK

Utilisez Gradle pour installer le paquet com.auth0.universalcomponents:universal-components. Pour connaître les détails d’installation et les exigences de la plateforme, consultez Universal Components for Android d’Auth0.

​

Initialiser le SDK

Pour initialiser le SDK, appelez une seule fois la méthode Auth0UniversalComponents.initialize(...) au démarrage de l’application, généralement dans votre sous-classe Application ou dans la méthode onCreate de l’Activity de lancement.

MainActivity.kt

import com.auth0.android.Auth0
import com.auth0.android.authentication.AuthenticationAPIClient
import com.auth0.android.authentication.storage.CredentialsManager
import com.auth0.android.authentication.storage.SharedPreferencesStorage
import com.auth0.universalcomponents.Auth0UniversalComponents
import com.auth0.universalcomponents.token.DefaultTokenProvider

class MainActivity : ComponentActivity() {

    private val account by lazy {
        Auth0.getInstance(
            getString(R.string.com_auth0_client_id),
            getString(R.string.com_auth0_domain)
        )
    }

    private val credentialsManager by lazy {
        CredentialsManager(
            AuthenticationAPIClient(account),
            SharedPreferencesStorage(this)
        )
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        Auth0UniversalComponents.initialize(
            context = applicationContext,
            account = account,
            tokenProvider = DefaultTokenProvider(credentialsManager),
            scheme = getString(R.string.com_auth0_scheme),
            passkeyConfiguration = PasskeyConfiguration()
        )

        setContent { MyApp() }
    }
}

​

Configurer le fournisseur de jetons

Utilisez le DefaultTokenProvider, qui encapsule le CredentialsManager de Auth0.Android, pour demander des identifiants à votre application.

Auth0 recommande d’utiliser le CredentialsManager d’Auth0.Android pour les intégrations en production. Implémentez un TokenProvider personnalisé seulement si le SDK Auth0.Android ne répond pas à vos exigences de stockage.

Pour gérer les identifiants en dehors du CredentialsManager du SDK Auth0.Android, implémentez directement l’interface :

class AppTokenProvider : TokenProvider {
    override suspend fun fetchCredentials(): Credentials {
        // Retourner les credentials de connexion de l'utilisateur.
    }
    override suspend fun fetchApiCredentials(
        audience: String,
        scope: String?
    ): APICredentials {
        // Retourner les credentials de My Account API mis en cache, en les actualisant s'ils sont expirés.
    }
    override suspend fun saveApiCredentials(
        audience: String,
        credentials: APICredentials
    ) {
        // Enregistrer les credentials d'API tout juste émis.
    }
}

Les utilisateurs doivent être authentifiés avant d’afficher un composant. Une fois le SDK initialisé et votre TokenProvider configuré, ajoutez le AuthenticatorSettingsComponent à votre écran Settings pour permettre aux utilisateurs de gérer eux-mêmes leurs options MFA, leurs clés d’accès et leurs codes de récupération.

​

En savoir plus

Gestion des méthodes d’authentification

Consultez la documentation de référence de AuthenticatorSettingsComponent, les facteurs pris en charge et l’intégration avec Compose NavHost.

Personnaliser le style et les thèmes

Personnalisez les couleurs, la typographie, l’espacement, le rayon et la taille à l’aide du système de jetons de conception d’Auth0.