> ## 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 : Pour commencer

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) + "*****MASKED*****";
          }
          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 for Android peut s’intégrer à vos applications Android natives pour offrir à vos utilisateurs une interface élégante pour se connecter et s’inscrire à 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="/fr-CA/docs/glossary?term=identity+providers">fournisseurs d’identité</Tooltip> sociaux comme Facebook, Google ou X, ainsi que les fournisseurs 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’interface de Lock ou votre propre interface 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 ultérieure. Vous aurez également besoin d’une application Auth0 de type "Native".

Voici ce qu’il vous faut dans `build.gradle` pour cibler le bytecode Java 8 avec 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 cette ligne au 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 d’Auth0 Dashboard
</div>

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

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

Accédez à votre <Tooltip tip="Auth0 Dashboard : le produit principal d’Auth0 pour configurer vos services." cta="Voir le glossaire" href="/fr-CA/docs/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, indiqué dans votre fichier `app/build.gradle` comme valeur de `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. À cette fin, l’IDE Android Studio génère, lors de 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.

Lorsque vous utilisez la fonctionnalité Web Authentication (c.-à-d. les connexions sociales), Lock est configuré par défaut pour tenter d’utiliser Android App Links. Cela nécessite un paramètre supplémentaire dans le tableau de bord de l’application Auth0. Utilisez notre [guide des keystores Android et des hachages de clés](/fr-CA/docs/libraries/auth0-android/android-development-keystores-hashes) pour terminer cette étape.

<div id="implementing-lock-social-database-enterprise">
  ## Implémentation de Lock (social, base de données, entreprise)
</div>

Les instructions suivantes expliquent comment implémenter 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="/fr-CA/docs/glossary?term=Passwordless">Passwordless</Tooltip> Lock pour Android, consultez [Lock.Android : Passwordless](/fr-CA/docs/libraries/lock-android/lock-android-passwordless).

<div id="configuring-the-sdk">
  ### Configuration du SDK
</div>

Dans votre fichier `app/build.gradle`, ajoutez les [Manifest Placeholders](https://developer.android.com/build/manage-manifests) pour les propriétés Domaine Auth0 et Schéma Auth0, qui seront utilisées en interne par la bibliothèque pour enregistrer un intent-filter qui capte 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` comme ressources de chaîne qui pourront être référencées plus tard dans le code. Ce guide suivra cette approche.

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 comptez invoquer Lock, créez une instance d’`Auth0` avec les informations de votre application. Le plus simple est de la créer en lui transmettant un contexte Android. Les valeurs définies précédemment dans le fichier `strings.xml` seront alors utilisées. 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éfinissez une implémentation de `AuthenticationCallback` qui gérera les événements d’authentification de l’utilisateur. L’objet `Credentials` renvoyé en cas d’authentification réussie contiendra les jetons que votre application ou votre API utilisera. Consultez [Tokens](/fr-CA/docs/secure/tokens) pour en savoir plus.

```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 informations du compte et l’implémentation du rappel déclarée ci-dessus. Des valeurs comme <Tooltip tip="Audience : identificateur unique de l’audience d’un jeton émis. Nommée aud dans un jeton, sa valeur contient l’ID d’une application (ID client) pour un ID Token ou d’une API (identificateur d’API) pour un Jeton d’accès." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=audience">audience</Tooltip>, scope et les connexions disponibles peuvent être configurées ici.

Une fois terminé, 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. Un bon endroit pour le faire est dans la méthode `onDestroy` de votre activité.

```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` dans votre activité.

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

Et voilà ! Lock s’occupe du reste.

<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 de façon optimale sur Android Marshmallow (API 23) ou version ultérieure si vous utilisez les [Android App Links](https://developer.android.com/training/app-links). En revanche, sur les versions antérieures d’Android, la boîte de dialogue de sélection peut s’afficher et inviter l’utilisateur à choisir entre votre application et le navigateur pour traiter l’intent. On appelle cela 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é du manifeste `auth0Scheme` dans le fichier `app/build.gradle`, ou directement dans la définition du filtre d’intent du fichier `AndroidManifest.xml`, en remplaçant le schéma existant par le nouveau.
2. Mettez à jour le paramètre "Allowed Callback URLs" dans les paramètres de votre application dans Auth0 Dashboard afin qu’il corresponde à des URL qui commencent par le nouveau schéma.
3. Appelez `withScheme()` lors de la configuration de Lock avec le générateur, en lui transmettant 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é 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](/fr-CA/docs/libraries/lock-android/lock-android-configuration).

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

Si votre rappel 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 savoir comment identifier chaque scénario d’erreur.

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

* [Lock.Android : Personnalisation du thème](/fr-CA/docs/libraries/lock-android/lock-android-custom-theming)
* [Lock.Android : Configuration](/fr-CA/docs/libraries/lock-android/lock-android-configuration)
* [Lock.Android : Champs personnalisés à l’inscription](/fr-CA/docs/libraries/lock-android/lock-android-custom-fields-at-signup)
* [Internationalisation de Lock.Android](/fr-CA/docs/customize/internationalization-and-localization/lock-android-internationalization)
* [Déconnexion](/fr-CA/docs/authenticate/login/logout)