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

Se aplica a: Inquilinos externos (más información)

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

En este tutorial, harás lo siguiente:

Prerrequisitos

• 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.
  • Conceda permisos de API.
  • Cree un flujo de usuario.
  • Asocie la aplicación al flujo de usuario.
• Un proyecto de Android. Si no tiene un proyecto de Android, créelo.

Agregue dependencias de MSAL

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

2. Abre su aplicación build.gradle y añade 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:6.+'
       //...
   }
   

3. En Android Studio, seleccione Archivo>Sincronizar proyecto con archivos Gradle.

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 a través de una configuración de JSON.

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

1. En el panel del proyecto de Android Studio, vaya a app\src\main\res.

2. Haga clic con el botón derecho en res y seleccione Nuevo>directorio. Escribe raw como el nombre del nuevo directorio y selecciona Aceptar.

3. En app\src\main\res\raw, cree un nuevo archivo JSON denominado auth_config_native_auth.json.

4. En el auth_config_native_auth.json archivo , 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 
     } 
   } 
    //...
   

5. Reemplace los siguientes marcadores de posición por los valores de inquilino que obtuvo del Centro de administración de 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 por Enter_the_Tenant_Subdomain_Here el subdominio de directorio (inquilino). Por ejemplo, si el dominio principal del cliente es contoso.onmicrosoft.com, utilice contoso. Si no tiene el nombre del inquilino, aprenda a 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 un código de uso único enviado por 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 
     } 
   } 
    //...

1. logcat_enabled: habilita la funcionalidad de registro de la biblioteca.
2. pii_enabled: especifica si se registran los mensajes que contienen datos personales o los 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.
3. log_level: Úselo para decidir qué nivel de registro se va a habilitar. Android admite los siguientes niveles de registro:
   1. ERROR
   2. Advertencia 
   3. INFORMACIÓN
   4. VERBOSO

Para obtener 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 onCreate() método , cree una instancia de MSAL para que la aplicación pueda realizar la autenticación con el inquilino a través de la autenticación nativa. El createNativeAuthPublicClientApplication() método devuelve una instancia denominada authClient. Pase el archivo de configuración JSON que creó anteriormente como parámetro.

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

El código debe 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 un 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 cierre de sesión.

Asegúrese de incluir las instrucciones de importación. Android Studio debe incluir automáticamente las instrucciones de importación.

Paso siguiente