> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

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

export const ReleaseStageNotice = ({feature, stage, plans, contact, terms}) => {
  const stageTextMap = {
    "beta": "bêta",
    "ea": "Accès anticipé"
  };
  const stageText = stageTextMap[stage] || "une phase de lancement du produit";
  const prsLink = "/docs/troubleshoot/product-lifecycle/product-release-stages";
  const linkify = (text, url) => {
    return <a href={url} target="_blank" rel="noreferrer" class="link">{text}</a>;
  };
  const includeDetails = (plans, contact, terms) => {
    const hasDetails = terms || plans || contact;
    if (!hasDetails) return null;
    return <span data-as="p">
            {plans && <>Cette fonctionnalité est offerte avec les forfaits {linkify(`${plans}`, "https://auth0.com/pricing")}. </>}
            {contact && "Pour y participer, communiquez avec " + contact + ". "}
            {terms && <>En utilisant cette fonctionnalité, vous acceptez les conditions applicables de l’essai gratuit énoncées dans le {linkify("Master Subscription Agreement", "https://www.okta.com/legal")} d’Okta.</>}
        </span>;
  };
  return <Warning>
            <span data-as="p">
                <strong>La fonctionnalité {feature} est en {linkify(stageText, prsLink)}.</strong>
            </span>

            {includeDetails(plans, contact, terms)}
        </Warning>;
};

<ReleaseStageNotice feature="Auth0 Universal Components" stage="beta" terms="true" contact="Auth0 Support" />

Auth0 Universal Components pour Android vous permet de créer une interface libre-service de sécurité du compte dans votre [application Android native](/docs/fr-ca/get-started/auth0-overview/create-applications#create-application-in-auth0).

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.

<div id="how-it-works">
  ## Fonctionnement
</div>

Le `AuthenticatorSettingsComponent` utilise les [méthodes d’authentification de l’API My Account d’Auth0](/docs/fr-ca/manage-users/my-account-api#manage-authentication-methods) pour afficher, dans votre application, une interface permettant de gérer les méthodes d’authentification.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  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.
</Callout>

Lorsqu’un utilisateur authentifié ouvre l’écran des paramètres de son compte, le SDK [Auth0.Android](https://github.com/auth0/Auth0.Android) récupère un [jeton d’accès](/docs/fr-ca/secure/tokens/access-tokens) limité à l’audience de l’API My Account.

Le `AuthenticatorSettingsComponent` utilise le jeton d’accès pour appeler les endpoints [`/me/v1/authentication-methods`](/docs/fr-ca/api/myaccount/authentication-methods/get-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.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  * 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](/docs/fr-ca/get-started/universal-components/web/components/build-delegated-admin).
</Callout>

<div id="prerequisites">
  ## Prérequis
</div>

<div id="enable-the-my-account-api">
  ### Activer l’API My Account
</div>

1. Accédez à [Dashboard > Applications > APIs](https://manage.auth0.com/#/apis).
2. Sélectionnez **Activer l’API My Account** pour vous assurer qu’elle est activée pour votre tenant.

<div id="create-an-application-and-configure-my-account-api-permissions">
  ### Créer une application et configurer les permissions de My Account API
</div>

1. Accédez à [Dashboard > Applications](https://manage.auth0.com/#/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** :

   ```text theme={null}
   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**.

   ```text theme={null}
   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.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  * 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.
</Callout>

<div id="install-the-sdk">
  ### Installer le SDK
</div>

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](/docs/fr-ca/get-started/universal-components/android/android-overview) d’Auth0.

<div id="initialize-the-sdk">
  ### Initialiser le SDK
</div>

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.

```kotlin MainActivity.kt wrap lines theme={null}
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() }
    }
}
```

<div id="configure-the-token-provider">
  ### Configurer le fournisseur de jetons
</div>

Utilisez le `DefaultTokenProvider`, qui encapsule le `CredentialsManager` de [`Auth0.Android`](https://github.com/auth0/Auth0.Android), pour demander des identifiants à votre application.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  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.
</Callout>

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

```kotlin wrap lines theme={null}
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.
    }
}
```

<Check>
  Les utilisateurs doivent être authentifiés avant d’afficher un composant. Une fois le SDK initialisé et votre `TokenProvider` configuré, ajoutez le [`AuthenticatorSettingsComponent`](/docs/fr-ca/get-started/universal-components/android/components/auth-methods-management) à 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.
</Check>

<div id="learn-more">
  ## En savoir plus
</div>

<CardGroup cols={2}>
  <Card title="Gestion des méthodes d’authentification" icon="shield" href="/docs/fr-ca/get-started/universal-components/android/components/auth-methods-management">
    Consultez la documentation de référence de `AuthenticatorSettingsComponent`, les facteurs pris en charge et l’intégration avec Compose NavHost.
  </Card>

  <Card title="Personnaliser le style et les thèmes" icon="palette" href="/docs/fr-ca/get-started/universal-components/android/android-theming">
    Personnalisez les couleurs, la typographie, l’espacement, le rayon et la taille à l’aide du système de jetons de conception d’Auth0.
  </Card>
</CardGroup>