Lock.Android: Primeros pasos

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

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 proveedores de identidad sociales como Facebook, Google o X, así como con proveedores empresariales como Active Directory.

Consulte el repositorio de Lock.Android en GitHub.

Requisitos

Para usar la interfaz de usuario de Lock o tu propia interfaz de usuario mediante la biblioteca Auth0.Android library, 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.

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = '1.8'
    }
}

Instalación

Lock está disponible en Maven Central. 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 del repositorio o en Maven.

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

Configuración del Dashboard

Debe completar algunos ajustes en su Auth0 Dashboard antes de empezar.

URL de callback

Ve a tu Auth0 Dashboard 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.

Keystores y hashes de clave

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 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 para completar este paso.

Implementación de Lock (Social, Base de datos, Enterprise)

Las siguientes instrucciones explican cómo implementar Classic Lock para Android. Si lo que buscas específicamente es implementar Lock sin contraseña para Android, consulta Lock.Android: sin contraseña.

Configuración del SDK

En el archivo app/build.gradle, agregue los placeholders del Manifest 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.

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.

Uso del SDK

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.

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 para obtener más información.

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 audiencia, 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.

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

startActivity(lock.newIntent(this))

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

Android App Links - Esquema personalizado

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

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

Configuración de Lock

Para ver la lista completa de opciones de configuración de Lock, consulta Lock.Android: Configuración.

Mensajes de error

Si tu callback recibe una AuthenticationException, puedes consultar el código fuente para saber cómo identificar cada escenario de error.

Más información

• Lock.Android: Personalización del tema
• Lock.Android: Configuración
• Lock.Android: Campos personalizados en el registro
• Internacionalización de Lock.Android
• Cerrar sesión