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

> Guía para implementar la autenticación sin contraseña con 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) + "*****ENMASCARADO*****";
          }
          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: Forma de autenticación que no depende de una contraseña como primer factor." cta="Ver glosario" href="/es/docs/glossary?term=Passwordless">Passwordless</Tooltip> autentica a los usuarios enviándoles un correo electrónico o un SMS con una contraseña de un solo uso que deben introducir y confirmar para poder iniciar sesión, de forma similar a como lo hace WhatsApp. En este artículo se explica cómo enviar un CÓDIGO con la biblioteca `Lock.Android`.

Puedes conseguir un resultado similar [enviando un enlace en el que el usuario pueda hacer clic](/es/docs/libraries/lock-android/lock-android-passwordless-with-magic-link) para completar automáticamente la autenticación passwordless, pero requiere algunos pasos de configuración adicionales.

Para poder autenticar al usuario, tu aplicación debe tener habilitada y configurada la conexión de correo electrónico/SMS en el [panel de Auth0](https://manage.auth0.com/#/connections/passwordless).

<div id="implementing-code-passwordless">
  ## Implementación del Passwordless por código
</div>

<div id="configuring-the-sdk">
  ### Configuración del SDK
</div>

En tu archivo `app/build.gradle`, agrega los [marcadores de posición del manifiesto](https://developer.android.com/studio/build/manifest-build-variables.html) para las propiedades Auth0 Domain y Auth0 Scheme, que la biblioteca utilizará internamente para registrar un intent-filter que capture el resultado de la autenticación.

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

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

        // ---> Agrega la siguiente línea
        manifestPlaceholders = [auth0Domain: "@string/com_auth0_domain", auth0Scheme: "https"]
        // <---
    }
}
```

Es una buena práctica agregar estos valores al archivo `strings.xml` como recursos de texto a los que luego se puede hacer referencia desde el código.

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">
  ### Uso del SDK
</div>

En la actividad en la que vayas a invocar Lock, crea una instancia de `Auth0` con la información de tu aplicación. La forma más sencilla de hacerlo es pasar un Android Context. Esto usará los valores definidos previamente en el archivo `strings.xml`. Para que funcione, los recursos de cadena deben definirse con las mismas claves que las indicadas anteriormente.

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

Declara una implementación de `AuthenticationCallback` que gestione los eventos de autenticación del usuario. El objeto `Credentials` que se devuelve en los casos de autenticación satisfactoria contendrá los tokens que tu aplicación o API utilizará. Consulta [Tokens](/es/docs/secure/tokens) para obtener más información.

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

    override fun onError(error: AuthenticationException) {
        // Ocurrió una excepción
    }
}
```

Prepare una nueva instancia de Lock con la clase Builder para configurarla. Proporcione los detalles de la cuenta y la implementación del callback declarada anteriormente. Aquí se pueden configurar valores como <Tooltip tip="Audiencia: identificador único de la audiencia para un token emitido. Denominado aud en un token, su valor contiene el ID de una aplicación (Client ID) para un ID Token o de una API (API Identifier) para un Access Token." cta="Ver glosario" href="/es/docs/glossary?term=audience">audience</Tooltip>, `scope` y las conexiones disponibles, entre otros. Cuando termine, cree la instancia de Lock. Esta instancia está pensada para reutilizarse y debe liberarse cuando ya no sea necesaria. Un buen lugar para hacerlo es el método `onDestroy` de su actividad.

En el ejemplo siguiente se llama al método `useCode()` para hacer que Lock envíe un **código** al correo electrónico o al número de teléfono del usuario.

```kotlin lines expandable theme={null}
// Esta actividad mostrará Passwordless Lock
class MyActivity : AppCompatActivity() {

    private lateinit var lock: PasswordlessLock

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

        val account = Auth0(this)
        // Instanciar Lock una vez
        lock = PasswordlessLock.newBuilder(account, callback)
            .useCode()
            // Personalizar Lock
            .build(this)
    }

    override fun onDestroy() {
        super.onDestroy()
        // ¡Importante! Liberar Lock y sus recursos
        lock.onDestroy(this)
    }

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

        override fun onError(error: AuthenticationException) {
            // Se produjo una excepción
        }
    }
}
```

Por último, abre el widget `PasswordlessLock` desde tu actividad.

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

Según qué conexiones passwordless estén habilitadas, Lock enviará el **código** por correo electrónico o SMS. La conexión 'email' se selecciona primero si está disponible. Luego, el usuario debe introducir el código en el paso de confirmación. Si el valor coincide con el que espera el servidor, la autenticación se realizará correctamente.