Tutorial: Preparación de la aplicación móvil Android para la autenticación nativa

Article
05/31/2024

En este tutorial, se muestra cómo agregar el SDK de autenticación nativa de la Biblioteca de autenticación de Microsoft (MSAL) a la aplicación móvil Android.

En este tutorial, aprenderá a:

Agregue dependencias de MSAL.
Cree un archivo de configuración.
Cree una instancia del SDK de MSAL.

Requisitos previos

Si aún no lo ha hecho, siga las instrucciones de Inicio de sesión de usuarios en una aplicación móvil de Android (Kotlin) de ejemplo mediante la autenticación nativa y registre una aplicación en el inquilino externo. Asegúrese de completar los pasos siguientes:
- Registrar una aplicación
- Habilite el cliente público y los flujos de autenticación nativos.
- Concesión de permisos de API.
- Crear un flujo de usuario:
- Asociación de la aplicación con el flujo de usuario.
Un proyecto de Android. Si no tiene un proyecto de Android, créelo.

Agregue dependencias de MSAL

Abra el proyecto en Android Studio o cree un nuevo proyecto.

Abra el build.gradle de su aplicación y agregue las siguientes dependencias:

allprojects {
    repositories {
        //Needed for com.microsoft.device.display:display-mask library
        maven {
            url 'https://pkgs.dev.azure.com/MicrosoftDeviceSDK/DuoSDK-Public/_packaging/Duo-SDK-Feed/maven/v1'
            name 'Duo-SDK-Feed'
        }
        mavenCentral()
        google()
    }
}
//...

dependencies { 
    implementation 'com.microsoft.identity.client:msal:5.+'
    //...
}

En Android Studio, seleccione File>Sync Project with Gradle Files.

Creación de un archivo de configuración

Pase los identificadores de inquilino necesarios, como el identificador de aplicación (cliente), al SDK de MSAL mediante una configuración JSON.

Use estos pasos para crear el archivo de configuración:

En el panel del proyecto de Android Studio, vaya a app\src\main\res.
Haga clic con el botón derecho en res y seleccione New>Directory. Escribe raw como el nombre del nuevo directorio y selecciona Aceptar.
En app\src\main\res\raw, cree un nuevo archivo JSON llamado auth_config_native_auth.json.

En el archivo auth_config_native_auth.json, agregue las siguientes configuraciones de MSAL:

{ 
  "client_id": "Enter_the_Application_Id_Here", 
  "authorities": [ 
    { 
      "type": "CIAM", 
      "authority_url": "https://Enter_the_Tenant_Subdomain_Here.ciamlogin.com/Enter_the_Tenant_Subdomain_Here.onmicrosoft.com/" 
    } 
  ], 
  "challenge_types": ["oob"], 
  "logging": { 
    "pii_enabled": false, 
    "log_level": "INFO", 
    "logcat_enabled": true 
  } 
} 
 //...

Reemplace los siguientes marcadores de posición por los valores de inquilino que obtuvo del Centro de administración Microsoft Entra:
- Reemplace el marcador de posición Enter_the_Application_Id_Here por el identificador de aplicación (cliente) de la aplicación que registró anteriormente.
- Reemplace Enter_the_Tenant_Subdomain_Here por el subdominio del directorio (inquilino). Por ejemplo, si el dominio principal del inquilino es contoso.onmicrosoft.com, use contoso. Si no tiene el nombre del inquilino, obtenga información sobre cómo leer los detalles del inquilino.
Los tipos de desafío son una lista de valores que la aplicación usa para notificar a Microsoft Entra sobre el método de autenticación que admite.
- Para flujos de registro e inicio de sesión con código de acceso de un solo uso de correo electrónico, use ["oob"].
- Para flujos de registro e inicio de sesión con correo electrónico y contraseña, use ["oob","password"].
- En el caso del autoservicio de restablecimiento de contraseña (SSPR), use ["oob"].
Obtenga más información sobre los tipos de desafío.

Opcional: Configuración de registro

Active el registro en la creación de la aplicación mediante la creación de una devolución de llamada de registro para que el SDK pueda generar registros.

import com.microsoft.identity.client.Logger

fun initialize(context: Context) {
        Logger.getInstance().setExternalLogger { tag, logLevel, message, containsPII ->
            Logs.append("$tag $logLevel $message")
        }
    }

Para configurar el registrador, debe agregar una sección en el archivo de configuración, auth_config_native_auth.json:

    //...
   { 
     "logging": { 
       "pii_enabled": false, 
       "log_level": "INFO", 
       "logcat_enabled": true 
     } 
   } 
    //...

logcat_enabled: habilita la funcionalidad de registro de la biblioteca.
pii_enabled: especifica si se registran los mensajes que contienen datos personales o datos de la organización. Cuando se establece en false, los registros no contendrán datos personales. Cuando se establece en true, los registros pueden contener datos personales.
log_level: se usa para decidir qué nivel de registro se va a habilitar. Android admite los siguientes niveles de registro:
1. ERROR
2. WARNING
3. INFO
4. VERBOSE

Para más información sobre el registro de MSAL, consulte Registro en MSAL para Android.

Creación de una instancia del SDK de MSAL de autenticación nativa

En el método onCreate(), cree una instancia de MSAL para que la aplicación pueda realizar la autenticación con el inquilino mediante la autenticación nativa. El método createNativeAuthPublicClientApplication() devuelve una instancia denominada authClient. Pase como parámetro el archivo de configuración JSON que creó anteriormente.

    //...
    authClient = PublicClientApplication.createNativeAuthPublicClientApplication( 
        this, 
        R.raw.auth_config_native_auth 
    )
    //...

El código debería tener un aspecto similar al siguiente fragmento de código:

    class MainActivity : AppCompatActivity() { 
        private lateinit var authClient: INativeAuthPublicClientApplication 
 
        override fun onCreate(savedInstanceState: Bundle?) { 
            super.onCreate(savedInstanceState) 
            setContentView(R.layout.activity_main) 
 
            authClient = PublicClientApplication.createNativeAuthPublicClientApplication( 
                this, 
                R.raw.auth_config_native_auth 
            ) 
            getAccountState() 
        } 
 
        private fun getAccountState() {
            CoroutineScope(Dispatchers.Main).launch {
                val accountResult = authClient.getCurrentAccount()
                when (accountResult) {
                    is GetAccountResult.AccountFound -> {
                        displaySignedInState(accountResult.resultValue)
                    }
                    is GetAccountResult.NoAccountFound -> {
                        displaySignedOutState()
                    }
                }
            }
        } 
 
        private fun displaySignedInState(accountResult: AccountState) { 
            val accountName = accountResult.getAccount().username 
            val textView: TextView = findViewById(R.id.accountText) 
            textView.text = "Cached account found: $accountName" 
        } 
 
        private fun displaySignedOutState() { 
            val textView: TextView = findViewById(R.id.accountText) 
            textView.text = "No cached account found" 
        } 
    }

Recupere la cuenta almacenada en caché mediante getCurrentAccount(), que devuelve el objeto accountResult.
Si se encuentra una cuenta en el almacenamiento de persistencia, use GetAccountResult.AccountFound para mostrar un estado de sesión iniciada.
De lo contrario, use GetAccountResult.NoAccountFound para mostrar un estado de sesión cerrada.

Asegúrese de incluir las instrucciones import. Android Studio debe incluir automáticamente las instrucciones import.

Paso siguiente

Tutorial: Incorporación del registro en una aplicación móvil Android mediante la autenticación nativa

Comparteix a través de