> ## 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 d’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) + "*****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 <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> authentifie les utilisateurs en leur envoyant un courriel ou un SMS contenant un mot de passe à usage unique que l’utilisateur doit saisir et confirmer pour pouvoir se connecter, un peu comme avec 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](/docs/fr-ca/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 Email/SMS activée et configurée dans votre [Auth0 Dashboard](https://manage.auth0.com/#/connections/passwordless).

<div id="implementing-code-passwordless">
  ## Mise en place du Passwordless par code
</div>

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

Dans votre fichier `app/build.gradle`, ajoutez les [espaces réservés du Manifest](https://developer.android.com/studio/build/manifest-build-variables.html) 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 qui intercepte 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 prévoyez d’appeler Lock, créez une instance de `Auth0` avec les informations de votre application. La façon la plus simple de la créer est de 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 type chaîne doivent être définies à l’aide des 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é lorsque l’authentification réussit contiendra les jetons que votre application ou votre API utilisera. Consultez [Jetons](/docs/fr-ca/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 détails du compte et l’implémentation de callback 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 (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>, scope et les connexions disponibles, entre autres, peuvent être configurées ici. Une fois terminé, 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. La méthode `onDestroy` de votre activité est un bon endroit pour le faire.

L’exemple ci-dessous appelle la méthode `useCode()` pour que Lock envoie un **CODE** à l’adresse 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 Email 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 réussira.