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

> Guide sur l’implémentation de l’authentification Passwordless avec Lock.Android

# Lock.Android : Passwordless

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 <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> authentifie les utilisateurs en leur envoyant un courriel ou un SMS contenant un code à usage unique que l’utilisateur doit saisir et confirmer pour pouvoir se connecter, comme le fait WhatsApp. Cet article explique comment envoyer un code à l’aide de la bibliothèque `Lock.Android`.

Vous pouvez obtenir un résultat semblable en [envoyant un lien sur lequel l’utilisateur peut cliquer](/fr-CA/docs/libraries/lock-android/lock-android-passwordless-with-magic-link) pour terminer automatiquement l’authentification Passwordless, mais cela nécessite quelques étapes de configuration supplémentaires.

Pour pouvoir authentifier l’utilisateur, votre application doit avoir la connexion courriel/SMS activée et configurée dans votre [Auth0 Dashboard](https://manage.auth0.com/#/connections/passwordless).

<div id="implementing-code-passwordless">
  ## Implémenter Passwordless avec code
</div>

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

Dans votre fichier `app/build.gradle`, ajoutez les [variables de substitution du manifeste](https://developer.android.com/studio/build/manifest-build-variables.html) 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` 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îne, afin de pouvoir les référencer plus tard dans le code.

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 appeler Lock, créez une instance de `Auth0` avec les informations de votre application. La façon la plus simple de la créer consiste à lui passer 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.

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

Déclarez 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 en configurant la classe Builder. Fournissez les renseignements du compte et l’implémentation de rappel déclarée ci-dessus. Des valeurs comme <Tooltip tip="Audience : identifiant 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 (identifiant 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, entre autres, peuvent être configurées ici. Une fois la configuration terminée, créez l’instance de 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é.

L’exemple ci-dessous appelle la méthode `useCode()` pour que Lock envoie un **CODE** au courriel ou au numéro de téléphone de l’utilisateur.

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

    private lateinit var lock: PasswordlessLock

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

        val account = Auth0(this)
        // Instancier Lock une seule fois
        lock = PasswordlessLock.newBuilder(account, callback)
            .useCode()
            // 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 `PasswordlessLock` à partir de votre activité.

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

Selon les connexions Passwordless activées, Lock enverra le **CODE** par courriel ou par SMS. La connexion 'email' est sélectionnée en premier si elle est disponible. L’utilisateur doit ensuite saisir le CODE à l’étape de confirmation. Si la valeur correspond à celle attendue par le serveur, l’authentification sera réussie.