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

# Lock.Android : Sans mot de passe

> Guide sur la mise en œuvre de l’authentification sans mot de passe avec Lock.Android.

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 href="/docs/fr-ca/glossary?term=passwordless" tip="Sans mot de passe
Forme d’authentification qui ne repose pas sur un mot de passe comme premier facteur." cta="Voir le glossaire">Passwordless</Tooltip> authentifie les utilisateurs en leur envoyant un courriel ou un SMS contenant un mot de passe à usage unique que l’utilisateur doit entrer et confirmer pour pouvoir se connecter, de manière similaire à l’authentification de WhatsApp. Cet article expliquera comment envoyer un CODE en utilisant la bibliothèque `Lock.Android` .

Vous pouvez obtenir un résultat similaire 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 sans mot de passe, 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).

## Mise en œuvre du code sans mot de passe

### Configuration de la trousse SDK

Dans votre fichier `app/build.gradle` ajoutez les [paramètres fictifs Manifest](https://developer.android.com/studio/build/manifest-build-variables.html) pour les propriétés Auth0 Domain et Auth0 Scheme, qui vont être utilisés en interne par la bibliothèque pour enregistrer un « filtre d’intention » qui capture le résultat de l’authentification.

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

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

        // ---> Add the next line
        manifestPlaceholders = [auth0Domain: "@string/com_auth0_domain", auth0Scheme: "https"]
        // <---
    }
}
```

Une bonne pratique consiste à ajouter ces valeurs au fichier `strings.xml` en tant que ressources de type chaîne qui peuvent être référencées ultérieurement 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" />

### Utilisation de la trousse SDK

Dans l’activité où vous prévoyez invoquer Lock, créez une instance `Auth0` avec les informations de votre application. La façon la plus simple de la créer est de passer un Contexte Android. Celui-ci utilisera les valeurs définies précédemment dans le fichier `strings.xml` . Pour que cela fonctionne, les ressources doivent être définies sous forme de chaînes en utilisant les mêmes clés que celles indiquées ci-dessus.

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

Déclarez une mise en œuvre `AuthenticationCallback` qui traitera les événements d’authentification des utilisateurs. L’objet `Credentials` renvoyé dans les scénarios d’authentification réussis contiendra les jetons que votre application ou l’API consommera. Consultez [Jetons](/docs/fr-ca/secure/tokens) pour plus de détails.

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

    override fun onError(error: AuthenticationException) {
        // Exception occurred
    }
}
```

Préparez une nouvelle instance de Lock en utilisant la classe Builder pour la configurer. Fournissez les détails du compte et la mise en œuvre du rappel déclaré ci-dessus. Des valeurs telles que l'<Tooltip data-tooltip-id="react-containers-DefinitionTooltip-1" tip="">audience</Tooltip>, la permission et les connexions disponibles, entre autres, peuvent être configurées ici. Une fois que vous avez terminé, créez l’instance Lock. Cette instance, que nous pouvons réutiliser, doit disparaître lorsqu’elle n’est plus nécessaire. Une bonne façon de le faire consiste à utiliser la méthode `onDestroy` de votre activité.

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

```kotlin lines theme={null}
// This activity will show Passwordless Lock
class MyActivity : AppCompatActivity() {

    private lateinit var lock: PasswordlessLock

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

        val account = Auth0(this)
        // Instantiate Lock once
        lock = PasswordlessLock.newBuilder(account, callback)
            .useCode()
            // Customize Lock
            .build(this)
    }

    override fun onDestroy() {
        super.onDestroy()
        // Important! Release Lock and its resources
        lock.onDestroy(this)
    }

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

        override fun onError(error: AuthenticationException) {
            // An exception occurred
        }
    }
}
```

Enfin, lancez le gadget logiciel `PasswordlessLock` à partir de votre activité.

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

Selon les connexions sans mot de passe activées, Lock enverra le **CODE** par courriel ou par SMS. La connexion ’email’ est sélectionnée en premier lieu si elle est disponible. Ensuite, l’utilisateur doit saisir le CODE lors de l’étape de confirmation. Si la valeur correspond à celle que le serveur attend, l’authentification réussira.