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

> Empiece a usar Lock para Android, un widget que ofrece una experiencia fluida de Login y registro para sus aplicaciones nativas de Android.

# Lock.Android: Primeros pasos

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 para Android puede integrarse en sus aplicaciones nativas de Android para ofrecer una forma atractiva de iniciar sesión y registrarse en su aplicación. Ofrece compatibilidad con <Tooltip tip="Proveedor de identidad (IdP): Servicio que almacena y administra identidades digitales." cta="Ver glosario" href="/es/docs/glossary?term=identity+providers">proveedores de identidad</Tooltip> sociales como Facebook, Google o X, así como con proveedores empresariales como Active Directory.

Consulte el [repositorio de Lock.Android](https://github.com/auth0/Lock.Android) en GitHub.

<div id="requirements">
  ## Requisitos
</div>

Para usar la interfaz de usuario de Lock o tu propia interfaz de usuario mediante la biblioteca [Auth0.Android library](https://github.com/auth0/Auth0.Android), el nivel mínimo de API de Android requerido es 21 o superior y la versión de Java debe ser la 8 o una posterior. También necesitarás una aplicación de Auth0 de tipo "Native".

Esto es lo que necesitas en `build.gradle` para generar bytecode de Java 8 con los plugins de Android y Kotlin, respectivamente.

```kotlin lines theme={null}
android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = '1.8'
    }
}
```

<div id="installation">
  ## Instalación
</div>

Lock está disponible en [Maven Central](https://central.sonatype.com/). Para empezar a usar Lock, agrega estas líneas al archivo de dependencias `build.gradle`:

`implementation 'com.auth0.android:lock:3.+'`

Puedes consultar la versión más reciente en el archivo [Readme](https://github.com/auth0/Lock.Android#install) del repositorio o en [Maven](https://central.sonatype.com/artifact/com.auth0.android/lock).

Después de agregar la dependencia de Gradle, recuerda sincronizar el proyecto con los archivos de Gradle.

<div id="dashboard-settings">
  ## Configuración del Dashboard
</div>

Debe completar algunos ajustes en su [Auth0 Dashboard](https://manage.auth0.com/#) antes de empezar.

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

Ve a tu <Tooltip tip="Auth0 Dashboard: el producto principal de Auth0 para configurar tus servicios." cta="Ver glosario" href="/es/docs/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip> y abre la configuración de la aplicación. Agrega la siguiente URL a **Allowed Callback URLs** de la aplicación:

`https://{yourDomain}/android/{yourAppPackageName}/callback`

Reemplaza `{yourAppPackageName}` por el nombre del paquete real de tu aplicación, disponible en el archivo `app/build.gradle` como el valor de `applicationId`.

<div id="keystores-and-key-hashes">
  ### Keystores y hashes de clave
</div>

Las aplicaciones de Android deben firmarse antes de poder instalarse en un dispositivo. Para ello, Android Studio genera, la primera vez que se ejecuta, un "Android Debug Keystore" predeterminado que usará para firmar las compilaciones de desarrollo. Es probable que este [Keystore](https://developer.android.com/studio/publish/app-signing) sea diferente del de la compilación de producción, ya que se utilizará para identificarlo como desarrollador.

Al usar la funcionalidad de Web Authentication (es decir, conexiones sociales), Lock se configurará de forma predeterminada para intentar usar Android App Links. Esto requiere una configuración adicional en el Dashboard de la aplicación de Auth0. Use nuestra [guía de Keystores de Android y hashes de clave](/es/docs/libraries/auth0-android/android-development-keystores-hashes) para completar este paso.

<div id="implementing-lock-social-database-enterprise">
  ## Implementación de Lock (Social, Base de datos, Enterprise)
</div>

Las siguientes instrucciones explican cómo implementar Classic Lock para Android. Si lo que buscas específicamente es implementar <Tooltip tip="Sin contraseña: forma de autenticación que no depende de una contraseña como primer factor." cta="Ver glosario" href="/es/docs/glossary?term=Passwordless">Lock sin contraseña</Tooltip> para Android, consulta [Lock.Android: sin contraseña](/es/docs/libraries/lock-android/lock-android-passwordless).

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

En el archivo `app/build.gradle`, agregue los [placeholders del Manifest](https://developer.android.com/build/manage-manifests) para las propiedades de dominio de Auth0 y esquema de Auth0, que la biblioteca usará internamente para registrar un filtro de intents 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
        // ...

        // ---> Añade 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 cadena a los que luego se pueda hacer referencia desde el código. Esta guía seguirá esa práctica.

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 donde planea invocar Lock, cree una instancia de `Auth0` con la información de su aplicación. La forma más sencilla de crearla es pasar un contexto de Android. Esto usará los valores definidos previamente en el archivo `strings.xml`. Para que esto funcione, los recursos de cadena deben definirse con las mismas claves que las indicadas anteriormente.

```text 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 cuando la autenticación se realiza correctamente 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 datos de la cuenta y la implementación del callback declarada anteriormente. Aquí puede configurar valores como <Tooltip tip="Audiencia: identificador único de la audiencia de un token emitido. Se llama aud en un token, y su valor contiene el ID de una aplicación (ID de cliente) para un ID Token o de una API (identificador de API) para un Token de acceso." cta="Ver glosario" href="/es/docs/glossary?term=audience">audiencia</Tooltip>, scope y las conexiones disponibles.

Cuando haya terminado, 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 en el método `onDestroy` de su actividad.

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

    private lateinit var lock: Lock

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

        val account = Auth0(this)
        // Instanciar Lock una vez
        lock = Lock.newBuilder(account, callback)
            // 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, inicie el widget `Lock` desde su actividad.

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

¡Eso es todo! Lock se encargará del resto.

<div id="android-app-links-custom-scheme">
  #### Android App Links - Esquema personalizado
</div>

El esquema de URI de callback que se usa en este artículo y que Lock utiliza de forma predeterminada es `https`. Esto funciona mejor en Android Marshmallow (API 23) o versiones posteriores si usa [Android App Links](https://developer.android.com/training/app-links), pero en versiones anteriores de Android puede aparecer el cuadro de diálogo del selector de intents, que pide al usuario elegir entre su aplicación y el navegador para resolver el intent. Esto se conoce como el "cuadro de diálogo de desambiguación". Puede cambiar este comportamiento usando un esquema personalizado único para que el sistema operativo abra el enlace directamente en su aplicación.

1. Actualice el valor del marcador de posición del manifiesto `auth0Scheme` en el archivo `app/build.gradle` o directamente en la definición del Intent Filter en el archivo `AndroidManifest.xml`, cambiando el esquema actual por el nuevo.
2. Actualice las "Allowed Callback URLs" en la configuración de la aplicación en su Auth0 Dashboard para que coincidan con las URL que comienzan con el nuevo esquema.
3. Llame a `withScheme()` al configurar Lock con el builder y pase el esquema que desea usar.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  El valor del esquema debe estar completamente en minúsculas. Si no es así, se registrará un mensaje de advertencia y la autenticación nunca se completará.
</Callout>

<div id="lock-configuration">
  ## Configuración de Lock
</div>

Para ver la lista completa de opciones de configuración de Lock, consulta [Lock.Android: Configuración](/es/docs/libraries/lock-android/lock-android-configuration).

<div id="error-messages">
  ## Mensajes de error
</div>

Si tu callback recibe una `AuthenticationException`, puedes consultar el [código fuente](https://github.com/auth0/Auth0.Android/blob/main/auth0/src/main/java/com/auth0/android/authentication/AuthenticationException.kt) para saber cómo identificar cada escenario de error.

<div id="learn-more">
  ## Más información
</div>

* [Lock.Android: Personalización del tema](/es/docs/libraries/lock-android/lock-android-custom-theming)
* [Lock.Android: Configuración](/es/docs/libraries/lock-android/lock-android-configuration)
* [Lock.Android: Campos personalizados en el registro](/es/docs/libraries/lock-android/lock-android-custom-fields-at-signup)
* [Internacionalización de Lock.Android](/es/docs/customize/internationalization-and-localization/lock-android-internationalization)
* [Cerrar sesión](/es/docs/authenticate/login/logout)