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

> Découvrez Lock pour Android, un widget qui offre une expérience de connexion et d’inscription fluide pour vos applications Android natives.

# Lock.Android : Premiers pas

export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
  const [displayText, setDisplayText] = useState(children);
  const [copyText, setCopyText] = useState(children);
  const wrapperRef = React.useRef(null);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      if (!window.autorun || !window.rootStore) {
        return;
      }
      unsubscribe = window.autorun(() => {
        let processedChildrenForDisplay = children;
        let processedChildrenForCopy = children;
        for (const [key, value] of window.rootStore.variableStore.values.entries()) {
          const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
          let displayValue = value;
          if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
            displayValue = value.substring(0, 3) + "*****MASQUÉ*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

Lock pour Android peut s’intégrer à vos applications Android natives pour offrir à vos utilisateurs une façon élégante de se connecter et de s’inscrire dans votre application. Il prend en charge les <Tooltip tip="Fournisseur d’identité (IdP) : service qui stocke et gère les identités numériques." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=identity+providers">fournisseurs d’identité</Tooltip> sociaux comme Facebook, Google ou X, ainsi que des fournisseurs d’identité d’entreprise comme Active Directory.

Consultez le [dépôt Lock.Android](https://github.com/auth0/Lock.Android) sur GitHub.

<div id="requirements">
  ## Exigences
</div>

Pour utiliser l’UI de Lock ou votre propre UI au moyen de la [bibliothèque Auth0.Android](https://github.com/auth0/Auth0.Android), le niveau d’API Android minimal requis est 21+ et la version de Java doit être 8 ou plus récente. Vous aurez aussi besoin d’une application Auth0 de type "Native".

Voici ce qu’il vous faut dans `build.gradle` pour cibler le bytecode Java 8 pour les plugins Android et Kotlin, respectivement.

```kotlin lines theme={null}
android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = '1.8'
    }
}
```

<div id="installation">
  ## Installation
</div>

Lock est disponible sur [Maven Central](https://central.sonatype.com/). Pour commencer à utiliser Lock, ajoutez ces lignes à votre fichier de dépendances `build.gradle` :

`implementation 'com.auth0.android:lock:3.+'`

Vous pouvez consulter la version la plus récente dans le [README](https://github.com/auth0/Lock.Android#install) du dépôt ou sur [Maven](https://central.sonatype.com/artifact/com.auth0.android/lock).

Après avoir ajouté votre dépendance Gradle, n’oubliez pas de synchroniser votre projet avec les fichiers Gradle.

<div id="dashboard-settings">
  ## Paramètres du Dashboard
</div>

Vous devez définir quelques paramètres dans votre [Auth0 Dashboard](https://manage.auth0.com/#) avant de commencer.

<div id="callback-url">
  ### URL de rappel
</div>

Allez dans votre <Tooltip tip="Auth0 Dashboard : le principal produit d’Auth0 pour configurer vos services." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip>, puis ouvrez les paramètres de l’application. Ajoutez l’URL suivante aux **Allowed Callback URLs** de l’application :

`https://{yourDomain}/android/{yourAppPackageName}/callback`

Remplacez `{yourAppPackageName}` par le véritable nom de package de votre application, que vous trouverez dans votre fichier `app/build.gradle` sous la valeur `applicationId`.

<div id="keystores-and-key-hashes">
  ### Keystores et hachages de clés
</div>

Les applications Android doivent être signées avant de pouvoir être installées sur un appareil. Pour ce faire, l’IDE Android Studio génère, à sa première exécution, un « Android Debug Keystore » par défaut qu’il utilisera pour signer les versions de développement. Ce [Keystore](https://developer.android.com/studio/publish/app-signing) sera probablement différent de celui de votre version de production, puisqu’il servira à vous identifier en tant que développeur.

Lors de l’utilisation de la fonctionnalité Web Authentication (c.-à-d. les connexions sociales), Lock sera configuré par défaut pour tenter d’utiliser Android App Links. Cela nécessite un paramètre supplémentaire dans le Dashboard de l’application Auth0. Utilisez notre [guide Android Keystores and Key Hashes](/docs/fr-ca/libraries/auth0-android/android-development-keystores-hashes) pour terminer cette étape.

<div id="implementing-lock-social-database-enterprise">
  ## Implémentation de Lock (Social, Database, Enterprise)
</div>

Les instructions suivantes portent sur l’implémentation de Classic Lock pour Android. Si vous cherchez plutôt à implémenter <Tooltip tip="Passwordless : forme d’authentification qui ne repose pas sur un mot de passe comme premier facteur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Passwordless">Passwordless</Tooltip> Lock pour Android, consultez [Lock.Android: Passwordless](/docs/fr-ca/libraries/lock-android/lock-android-passwordless).

<div id="configuring-the-sdk">
  ### Configurer le SDK
</div>

Dans votre fichier `app/build.gradle`, ajoutez les [espaces réservés du manifeste](https://developer.android.com/build/manage-manifests) pour les propriétés Auth0 Domain et Auth0 Scheme, qui seront utilisées en interne par la bibliothèque pour enregistrer un intent-filter capturant le résultat de l’authentification.

```kotlin lines theme={null}
plugins {
    id "com.android.application"
    id "kotlin-android"
}

android {
    compileSdkVersion 30
    defaultConfig {
        applicationId "com.auth0.samples"
        minSdkVersion 21
        targetSdkVersion 30
        // ...

        // ---> Ajouter la ligne suivante
        manifestPlaceholders = [auth0Domain: "@string/com_auth0_domain", auth0Scheme: "https"]
        // <---
    }
}
```

Il est recommandé d’ajouter ces valeurs au fichier `strings.xml` sous forme de ressources de chaînes auxquelles le code pourra faire référence plus tard. Ce guide suivra cette pratique.

export const codeExample = `<resources>
    <string name="com_auth0_client_id">{yourClientId}</string>
    <string name="com_auth0_domain">{yourDomain}</string>
</resources>`;

<AuthCodeBlock children={codeExample} language="xml" />

<div id="sdk-usage">
  ### Utilisation du SDK
</div>

Dans l’activité où vous prévoyez appeler Lock, créez une instance de `Auth0` avec les renseignements de votre application. La façon la plus simple de la créer consiste à lui passer un `Context` Android. Cela utilisera les valeurs définies précédemment dans le fichier `strings.xml`. Pour que cela fonctionne, les ressources de chaîne doivent être définies avec les mêmes clés que celles indiquées ci-dessus.

```text lines theme={null}
val account = Auth0(context)
```

Déclarez une mise en œuvre de `AuthenticationCallback` qui gérera les événements d’authentification des utilisateurs. L’objet `Credentials` renvoyé en cas d’authentification réussie contiendra les jetons que votre application ou votre API utilisera ensuite. Consultez [Tokens](/docs/fr-ca/secure/tokens) pour plus de détails.

```kotlin lines theme={null}
private val callback = object : AuthenticationCallback() {
    override fun onAuthentication(credentials: Credentials) {
        // Authentifié
    }

    override fun onError(error: AuthenticationException) {
        // Une exception s'est produite
    }
}
```

Préparez une nouvelle instance de Lock à l’aide de la classe Builder pour la configurer. Fournissez les détails du compte et l’implémentation du callback déclarée ci-dessus. Des valeurs comme <Tooltip tip="Audience : identifiant unique de l’audience d’un token émis. Appelée aud dans un token, sa valeur contient l’ID d’une application (Client ID) pour un ID Token ou d’une API (API Identifier) pour un access token." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=audience">audience</Tooltip>, le scope et les connexions disponibles peuvent être configurés ici.

Une fois que c’est fait, créez l’instance Lock. Cette instance est conçue pour être réutilisée et doit être libérée lorsqu’elle n’est plus nécessaire. La méthode `onDestroy` de votre activité est un bon endroit pour le faire.

```kotlin lines expandable theme={null}
// Cette activité affichera Lock
class MyActivity : AppCompatActivity() {

    private lateinit var lock: Lock

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

        val account = Auth0(this)
        // Instancier Lock une seule fois
        lock = Lock.newBuilder(account, callback)
            // Personnaliser Lock
            .build(this)
    }

    override fun onDestroy() {
        super.onDestroy()
        // Important ! Libérer Lock et ses ressources
        lock.onDestroy(this)
    }

    private val callback = object : AuthenticationCallback() {
        override fun onAuthentication(credentials: Credentials) {
            // Authentifié
        }

        override fun onError(error: AuthenticationException) {
            // Une exception s'est produite
        }
    }
}
```

Enfin, lancez le widget `Lock` à partir de votre activité.

```kotlin lines theme={null}
startActivity(lock.newIntent(this))
```

Et voilà ! Lock s’occupera du reste pour vous.

<div id="android-app-links-custom-scheme">
  #### Android App Links - schéma personnalisé
</div>

Le schéma d’URI de rappel utilisé dans cet article, et par défaut par Lock, est `https`. Cela fonctionne mieux sur Android Marshmallow (API 23) et les versions ultérieures si vous utilisez [Android App Links](https://developer.android.com/training/app-links). Toutefois, sur les versions antérieures d’Android, la boîte de dialogue du sélecteur d’intention peut s’afficher et inviter l’utilisateur à choisir soit votre application, soit le navigateur pour traiter l’intention. C’est ce qu’on appelle la « boîte de dialogue de désambiguïsation ». Vous pouvez modifier ce comportement en utilisant un schéma personnalisé unique afin que le système d’exploitation ouvre directement le lien dans votre application.

1. Mettez à jour la valeur de l’espace réservé `auth0Scheme` dans le fichier `app/build.gradle`, ou directement dans la définition d’Intent Filter du fichier `AndroidManifest.xml`, en remplaçant le schéma actuel par le nouveau.
2. Mettez à jour les « Allowed Callback URLs » dans les paramètres de votre Application du Auth0 Dashboard afin qu’elles correspondent à des URL qui commencent par le nouveau schéma.
3. Appelez `withScheme()` lors de la configuration de Lock avec le builder, en lui passant le schéma que vous souhaitez utiliser.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  La valeur du schéma doit être entièrement en minuscules. Un message d’avertissement sera consigné dans le log si ce n’est pas le cas, et l’authentification ne se terminera jamais.
</Callout>

<div id="lock-configuration">
  ## Configuration de Lock
</div>

Pour consulter la liste complète des options de configuration de Lock, consultez [Lock.Android : Configuration](/docs/fr-ca/libraries/lock-android/lock-android-configuration).

<div id="error-messages">
  ## Messages d’erreur
</div>

Si votre callback reçoit une `AuthenticationException`, vous pouvez consulter le [code source](https://github.com/auth0/Auth0.Android/blob/main/auth0/src/main/java/com/auth0/android/authentication/AuthenticationException.kt) pour voir comment identifier chaque scénario d’erreur.

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

* [Lock.Android : personnalisation du thème](/docs/fr-ca/libraries/lock-android/lock-android-custom-theming)
* [Lock.Android : Configuration](/docs/fr-ca/libraries/lock-android/lock-android-configuration)
* [Lock.Android : champs personnalisés lors de l’inscription](/docs/fr-ca/libraries/lock-android/lock-android-custom-fields-at-signup)
* [Internationalisation de Lock.Android](/docs/fr-ca/customize/internationalization-and-localization/lock-android-internationalization)
* [Logout](/docs/fr-ca/authenticate/login/logout)