> ## 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. # Añade el inicio de sesión a tu aplicación Android con el SDK de Auth0.Android export const HowToSchema = () => ; Si usas un asistente de programación con IA como Claude Code, Cursor o GitHub Copilot, puedes añadir la autenticación de Auth0 automáticamente en minutos usando [agent skills](https://agentskills.io/home). **Instala:** ```bash theme={null} npx skills add auth0/agent-skills --skill auth0-quickstart --skill auth0-android ``` **Después, pídele a tu asistente de IA:** ```text theme={null} Add Auth0 authentication to my Android app ``` Tu asistente de IA creará automáticamente tu aplicación de Auth0, obtendrá las credenciales, añadirá la dependencia del SDK de Auth0 para Android, configurará los marcadores de posición del manifiesto e implementará los flujos de inicio y cierre de sesión. [Documentación completa de agent skills →](/es/docs/quickstart/agent-skills)
## Primeros pasos
Crea un nuevo proyecto de Android para esta guía de inicio rápido. **En Android Studio:** 1. **File** → **New** → **New Project** 2. Selecciona la plantilla **Phone and Tablet** → **Empty Activity** 3. Configura el proyecto: * **Name**: `Auth0-Android-Sample` * **Package name**: `com.auth0.samples.android` * **Language**: **Kotlin** * **Minimum SDK**: **API 24 (Android 7.0)** * **Build configuration language**: **Kotlin DSL** 4. Haz clic en **Finish** Esto crea una aplicación moderna de Android con Kotlin y Gradle Kotlin DSL, siguiendo las prácticas recomendadas actuales del desarrollo para Android. Añade el SDK de Auth0 para Android a tu proyecto con Gradle. **Actualiza el archivo `build.gradle.kts` de tu aplicación:** ```kotlin app/build.gradle.kts lines theme={null} dependencies { // SDK de Auth0 implementation("com.auth0.android:auth0:3.14.0") } ``` **Agrega los marcadores de posición del manifiesto en el `build.gradle.kts` de tu aplicación:** ```kotlin app/build.gradle.kts lines theme={null} android { defaultConfig { // Agrega estos marcadores de posición del manifiesto manifestPlaceholders += mapOf( "auth0Domain" to "@string/com_auth0_domain", // esto se configurará en el siguiente paso "auth0Scheme" to "https" ) } } ``` **Añade el permiso de acceso a Internet a `AndroidManifest.xml`:** ```xml app/src/main/AndroidManifest.xml lines theme={null} ``` El SDK de Auth0 gestiona automáticamente la resolución de dependencias e incluye almacenamiento seguro de tokens. A continuación, debes crear una nueva aplicación en tu tenant de Auth0 y añadir la configuración a tu proyecto Android. Primero, prepara el archivo `app/src/main/res/values/strings.xml` con valores de marcador de posición: ```xml app/src/main/res/values/strings.xml theme={null} {yourDomain} YOUR_AUTH0_CLIENT_ID https ``` 1. Ve al [Auth0 Dashboard](https://manage.auth0.com/dashboard/) 2. Haz clic en **Applications** > **Applications** > **Create Application** 3. En la ventana emergente, introduce un nombre para tu aplicación, selecciona `Native` como tipo de aplicación y haz clic en **Create** 4. Ve a la pestaña **Settings** en la página de detalles de la aplicación 5. Sustituye `{yourDomain}` y `YOUR_AUTH0_CLIENT_ID` en el archivo `strings.xml` por los valores de **Domain** y **Client ID** del panel Por último, en la pestaña **Settings** de la página de detalles de tu aplicación, configura las siguientes URL: **Allowed Callback URLs:** ``` https://{yourDomain}/android/PACKAGE_NAME/callback ``` **URL de cierre de sesión permitidas:** ``` https://{yourDomain}/android/PACKAGE_NAME/callback ``` Sustituye `{yourDomain}` por tu dominio real de Auth0 (por ejemplo, `dev-abc123.us.auth0.com`). Las **Allowed Callback URLs** son una medida de seguridad fundamental para garantizar que, tras la autenticación, los usuarios vuelvan de forma segura a tu aplicación. Si no hay una URL que coincida, el proceso de inicio de sesión fallará y los usuarios verán una página de error de Auth0 en lugar de acceder a tu aplicación. Las **Allowed Logout URLs** son esenciales para ofrecer una experiencia fluida al cerrar sesión. Si no hay una URL que coincida, los usuarios no serán redirigidos de vuelta a tu aplicación al cerrar sesión y, en su lugar, permanecerán en una página genérica de Auth0. El esquema de la URL incluye el nombre de tu paquete (`com.auth0.samples.android`) para garantizar que el callback se dirija a tu aplicación concreta. **Importante**: Asegúrate de que el nombre del paquete en tus URL de callback coincida con tu `applicationId` en `build.gradle.kts`. Si la autenticación falla, comprueba que estos valores sean idénticos. Al usar el esquema `https` (como se configuró antes), debes configurar Android App Links para que Android dirija la URL de callback directamente a tu aplicación en lugar de abrirla en el navegador. Consulta la sección **Configurar Android App Links** en [Resolución de problemas y opciones avanzadas](#troubleshooting--advanced) más abajo. Crea una instancia de Auth0 en tu Activity para poder comunicarte con Auth0. **En tu `MainActivity.kt`:** ```kotlin MainActivity.kt lines theme={null} import com.auth0.android.Auth0 import com.auth0.android.authentication.AuthenticationException import com.auth0.android.callback.Callback import com.auth0.android.provider.WebAuthProvider import com.auth0.android.result.Credentials class MainActivity : ComponentActivity() { private lateinit var auth0: Auth0 override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Inicializar Auth0 auth0 = Auth0.getInstance( getString(R.string.com_auth0_client_id), getString(R.string.com_auth0_domain) ) } } ``` La instancia de Auth0 se inicializa con tu ID de cliente y el dominio del archivo `strings.xml` que configuraste anteriormente. Esta instancia se utilizará para todas las operaciones de autenticación. **Implementa el inicio de sesión:** Usa WebAuthProvider para abrir la página universal de inicio de sesión. Agrega estos métodos a tu `MainActivity`: ```kotlin MainActivity.kt lines theme={null} private fun login() { WebAuthProvider.login(auth0) .withScheme("https") .withScope("openid profile email offline_access") .start(this, object : Callback { override fun onSuccess(credentials: Credentials) { // Guarda las credenciales // El usuario está autenticado } override fun onFailure(exception: AuthenticationException) { // Gestiona los casos de error } }) } ``` ```kotlin MainActivity.kt lines theme={null} private fun login() { lifecycleScope.launch { try { val credentials = WebAuthProvider.login(auth0) .withScheme("https") .withScope("openid profile email offline_access") .await(this@MainActivity) // Guarda las credenciales // El usuario está autenticado } catch (exception: AuthenticationException) { // Gestiona el error } } } ``` **Implementa el cierre de sesión:** Usa WebAuthProvider para cerrar la sesión del usuario. ```kotlin MainActivity.kt lines theme={null} private fun logout() { WebAuthProvider.logout(auth0) .withScheme("https") .start(this, object : Callback { override fun onSuccess(result: Void?) { // Borra las credenciales guardadas // El usuario ha cerrado sesión } override fun onFailure(exception: AuthenticationException) { // Gestiona el error } }) } ``` ```kotlin MainActivity.kt lines theme={null} private fun logout() { lifecycleScope.launch { try { WebAuthProvider.logout(auth0) .withScheme("https") .await(this@MainActivity) // Borra las credenciales guardadas // El usuario ha cerrado sesión } catch (exception: AuthenticationException) { // Gestiona el error } } } ``` Los métodos `login()` y `logout()` deben llamarse cuando el usuario pulse los botones correspondientes en tu interfaz. El código usa `this` (en referencia a la Activity) como parámetro de contexto, lo cual es necesario para que WebAuthProvider abra Chrome Custom Tabs y gestione el flujo de autenticación. Compila y ejecuta tu aplicación para Android. **En Android Studio:** ```shellscript theme={null} # Sincronizar el proyecto con los archivos de Gradle (o usar "Sync Now" en Android Studio) ./gradlew clean build # Compilar e instalar en el dispositivo conectado o en el emulador ./gradlew installDebug # O ejecutar directamente desde Android Studio # Hacer clic en el botón "Run" o pulsar Shift+F10 ``` **Flujo esperado:** 1. La app se abre con el botón "Iniciar sesión" y el ícono de escudo 2. Toca "Iniciar sesión" → se abre una pestaña personalizada de Chrome → completa el inicio de sesión 3. Vuelve a la app automáticamente 4. ¡Éxito! Android mostrará un cuadro de selección de navegador si hay varios navegadores instalados. Las pestañas personalizadas de Chrome ofrecen la mejor experiencia de usuario para la autenticación con Auth0. **Punto de control** Ahora deberías tener una experiencia de inicio de sesión con Auth0 totalmente funcional ejecutándose en tu dispositivo Android o emulador. La aplicación usa Chrome Custom Tabs para ofrecer una autenticación segura y almacena automáticamente las credenciales. ***
## Solución de problemas y opciones avanzadas
### Chrome Custom Tab no redirige de vuelta a la app **Soluciones:** 1. Comprueba que las **Allowed Callback URLs** del Auth0 Dashboard coincidan exactamente con tu `applicationId` 2. Verifica que los marcadores de posición del manifiesto en `build.gradle.kts` sean correctos 3. Asegúrate de tener configuradas tanto las URL `https` como las URL con esquema personalizado 4. Limpia y recompila: **Build** → **Clean Project** → **Rebuild Project** ### La app se cierra: 'Auth0 domain not found' **Solución:** 1. Comprueba que los valores de `com_auth0_domain` y `com_auth0_client_id` sean correctos 2. Asegúrate de que no haya errores tipográficos en el formato del dominio (no debe incluir `https://`) ### Errores de compilación con dependencias **Solución:** 1. Actualiza a la versión más reciente del Android Gradle Plugin en `build.gradle` (nivel de proyecto) 2. Sincroniza el proyecto: **File** → **Sync Project with Gradle Files** 3. Limpia la compilación: `./gradlew clean build` ### Autenticación cancelada por el usuario Manéjalo correctamente en tu callback de error: ```kotlin {3,4,5,6} expandable theme={null} override fun onFailure(exception: AuthenticationException) { when { exception.isAuthenticationCanceled -> showMessage("Login was cancelled") exception.isBrowserAppNotAvailable -> showMessage("No browser available") else -> showMessage("Login failed: ${exception.getDescription()}") } } ``` ### Error de navegador no compatible * Instala Chrome u otro navegador moderno en tu dispositivo o emulador * Habilita Chrome Custom Tabs para mejorar la experiencia de usuario * Haz pruebas en un dispositivo real con Chrome instalado [Android App Links](https://developer.android.com/training/app-links) permiten que tu app se establezca como el controlador predeterminado para las URL de callback de Auth0, lo que proporciona una experiencia de autenticación más segura y fluida. Sin App Links, Android puede mostrar un cuadro de diálogo de desambiguación para que el usuario elija entre tu app y un navegador. App Links usa callbacks verificados con el esquema `https`. Esto es más seguro que los esquemas de URL personalizados, que pueden estar sujetos a [ataques de suplantación de cliente](https://datatracker.ietf.org/doc/html/rfc8252#section-8.6). ### Obtén la huella digital de tu certificado de firma Necesitas la huella digital SHA256 del certificado de firma de tu app. Ejecuta el siguiente comando en tu terminal: ```shellscript theme={null} # Para compilaciones de depuración keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android # Para compilaciones de lanzamiento keytool -list -v -keystore my-release-key.keystore ``` Copia el valor de la huella digital **SHA256** de la salida. ### Configurar en el Auth0 Dashboard 1. Ve a [Auth0 Dashboard > Applications > Applications](https://manage.auth0.com/#/applications) y selecciona tu aplicación 2. Desplázate hasta la parte inferior de la página **Settings** y selecciona **Show Advanced Settings** 3. Selecciona la pestaña **Device Settings** 4. En **Android**, proporciona: * **App Package Name**: Tu `applicationId` (por ejemplo, `com.auth0.samples.android`) * **SHA256 Cert Fingerprints**: La huella digital que copiaste antes 5. Haz clic en **Save Changes** ### Verifica la configuración Auth0 genera automáticamente el archivo `assetlinks.json` que Android usa para verificar tu app. Pruébalo navegando a: ``` https://{yourDomain}/.well-known/assetlinks.json ``` Deberías ver una respuesta JSON que contiene el nombre de tu paquete y la huella digital del certificado: ```json theme={null} [{ "relation": ["delegate_permission/common.handle_all_urls"], "target": { "namespace": "android_app", "package_name": "[YOUR_PACKAGE_NAME]", "sha256_cert_fingerprints": ["YOUR_SHA256_FINGERPRINT"] } }] ``` La guía de inicio rápido ya usa `https` como esquema en los marcadores de posición del manifiesto y en las llamadas a `WebAuthProvider`, lo cual es necesario para App Links. No hace falta cambiar el código si seguiste los pasos anteriores. Para obtener más información, consulta la documentación de [Enable Android App Links Support](/es/docs/get-started/applications/enable-android-app-links-support) y la guía de Android [Verify App Links](https://developer.android.com/training/app-links/verify-site-associations). Si no puedes usar Android App Links (por ejemplo, si trabajas con versiones de la API de Android anteriores a la 23), puedes configurar un esquema de URL personalizado en su lugar. Los esquemas de URL personalizados son menos seguros que App Links porque pueden ser vulnerables a [ataques de suplantación del cliente](https://datatracker.ietf.org/doc/html/rfc8252#section-8.6). Usa App Links siempre que sea posible. 1. Actualiza el marcador de posición del manifiesto `auth0Scheme` en tu `app/build.gradle.kts`: ```kotlin app/build.gradle.kts lines theme={null} android { defaultConfig { manifestPlaceholders += mapOf( "auth0Domain" to "@string/com_auth0_domain", "auth0Scheme" to "myapp" // Usa un esquema personalizado único ) } } ``` 2. Actualiza las **Allowed Callback URLs** y **Allowed Logout URLs** en la configuración de tu aplicación en el [Auth0 Dashboard](https://manage.auth0.com/#/applications) para usar el esquema personalizado: ``` myapp://{yourDomain}/android/PACKAGE_NAME/callback ``` 3. Pasa el esquema personalizado al llamar a `WebAuthProvider`: ```kotlin MainActivity.kt lines theme={null} WebAuthProvider.login(auth0) .withScheme("myapp") .withScope("openid profile email offline_access") .start(this, callback) ``` Los esquemas personalizados [solo pueden contener letras minúsculas](https://developer.android.com/guide/topics/manifest/data-element). ### Preparación para la tienda de aplicaciones * Configura Android App Links para una autenticación sin fricciones * Haz pruebas en varias versiones de Android y tamaños de pantalla * Implementa un manejo adecuado de errores para fallos de red * Añade reglas de ProGuard para el SDK de Auth0 si usas ofuscación de código * Sigue las políticas de Google Play Store para los flujos de autenticación ### Consideraciones de seguridad * Usa `SecureCredentialsManager` para almacenar credenciales en producción * Implementa certificate pinning para reforzar la seguridad de la API * Considera usar Android Keystore para una mayor protección de las credenciales * Habilita la autenticación biométrica para operaciones sensibles ### Seguridad reforzada de las credenciales Implementa autenticación biométrica para acceder a las credenciales: ```kotlin AuthenticationManager.kt expandable lines theme={null} class AuthenticationManager(private val context: Context) { private val credentialsManager: SecureCredentialsManager init { val authentication = AuthenticationAPIClient(auth0) val storage = SharedPreferencesStorage(context) credentialsManager = SecureCredentialsManager(context, authentication, storage) // Habilitar autenticación biométrica credentialsManager.requireAuthentication( context as FragmentActivity, REQUEST_CODE_BIOMETRIC, "Autenticación biométrica", "Autentícate para acceder a tu cuenta" ) } companion object { private const val REQUEST_CODE_BIOMETRIC = 321 } } ``` ### Scopes y audience personalizados Solicita scopes y audience específicos para tu API: ```kotlin AuthenticationManager.kt expandable lines theme={null} fun login() { WebAuthProvider.login(auth0) .withScheme("https") .withScope("openid profile email offline_access read:posts") .withAudience("https://myapi.example.com") .withParameter("prompt", "login") .start(context as MainActivity, loginCallback) } ``` ### Configuración de red Gestiona la seguridad de red y el certificate pinning: ```xml app/src/main/res/xml/network_security_config.xml expandable lines theme={null} your-auth0-domain.auth0.com AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= ``` Añádelo a `AndroidManifest.xml`: ```xml theme={null} ```