Tutorial: Llamada a una API en una aplicación android mediante la autenticación nativa

Se aplica a: Círculo verde con un símbolo de marca de verificación blanca que indica que el siguiente contenido se aplica a los inquilinos externos. Inquilinos externos (más información)

En este tutorial, aprenderá a adquirir un token de acceso y a llamar a una API en la aplicación móvil Android. El SDK de autenticación nativa de la Biblioteca de autenticación de Microsoft (MSAL) para Android le permite adquirir varios tokens de acceso con un inicio de sesión único. Esta funcionalidad te permite adquirir uno o varios tokens de acceso sin necesidad de que un usuario vuelva a autenticarse.

En este tutorial, harás lo siguiente:

  • Adquirir uno o varios tokens de acceso.
  • Llamada a una API

Prerrequisitos

Adquisición de un token de acceso

Una vez que el usuario inicia sesión, adquiere un token de acceso especificando los ámbitos para los que el token de acceso es válido.

EL SDK de autenticación nativa de MSAL admite varios tokens de acceso, por lo que puede especificar varios conjuntos de ámbitos y, a continuación, solicitar el token de acceso para cada conjunto de ámbitos:

  1. Declara y establece valores para un conjunto de ámbitos de API mediante el siguiente fragmento de código:

    companion object {
    // Set values for respective API scopes for their web API resources here, for example: ["api://<Resource_App_ID>/ToDoList.Read", "api://<Resource_App_ID>/ToDoList.ReadWrite"]
    // A list of scope for API 1
    private val scopesForAPI1 = listOf<String>()
    // A list of scope for API 2
    private val scopesForAPI2 = listOf<String>()
}

  2. Inicia sesión mediante el siguiente fragmento de código:

    CoroutineScope(Dispatchers.Main).launch {
    val parameters = NativeAuthSignInParameters(username = email)
    parameters.password = password
    val actionResult: SignInResult = authClient.signIn(parameters)

    if (actionResult is SignInResult.Complete) -> {
        // Perform operations after successful sign-in
    } else if (actionResult is SignInError) {
        // Handle sign-in errors
    }
}

  3. Adquiere uno o varios tokens de acceso mediante el siguiente fragmento de código:

    CoroutineScope(Dispatchers.Main).launch {
    val accountResult = authClient.getCurrentAccount()
    when (accountResult) {
        is GetAccountResult.AccountFound -> {
            try {
                // Access token for API 1
                val accessTokenOne = getAccessToken(accountResult.resultValue, scopesForAPI1)
                // Access token for API 2
                val accessTokenTwo = getAccessToken(accountResult.resultValue, scopesForAPI2)
                // Proceed to make a call to an API
            } catch (e: Exception) {
                // Handle Exception
            }
        }
        is GetAccountResult.NoAccountFound -> {
            // Handle etAccountResult.NoAccountFound
        }
        is GetAccountError -> {
            // Handle GetAccountError 
        }
    }
}

    Defina la getAccessToken() función como se muestra en el código siguiente:

    private suspend fun getAccessToken(accountState: AccountState, scopes: List<String>): String {
    val parameters = NativeAuthGetAccessTokenParameters()
    parameters.scopes = scopes
    val accessTokenState = accountState.getAccessToken(parameters)

    return if (accessTokenState is GetAccessTokenResult.Complete) {
        accessTokenState.resultValue.accessToken
    } else {
        throw Exception("Failed to get access token")
    }
}

Llamada a una API

Para realizar una llamada API, use el token de acceso que adquirió en Adquisición de un token de acceso y una dirección URL de API:

  1. Declare y establezca valores para las URLs de la API mediante el siguiente fragmento de código:

    companion object {
    // Set values for respective API scopes for web API resources here, for example: ["api://<Resource_App_ID>/ToDoList.Read", "api://<Resource_App_ID>/ToDoList.ReadWrite"]
    // A list of scope for API 1
    private val scopesForAPI1 = listOf<String>()
    // A list of scope for API 2
    private val scopesForAPI2 = listOf<String>()
    // Set the URL of first web API resource here
    private const val WEB_API_URL_1 = "Enter_URL_Of_First_Web_API" 
    // Set the URL of second web API resource here
    private const val WEB_API_URL_2 = "Enter_URL_Of_Second_Web_API" 
}

    Reemplace el:

    • Marcador de posición Enter_URL_Of_First_Web_API con el valor de dirección URL completo de la primera API.
    • Marcador de posición Enter_URL_Of_Second_Web_API con el valor de dirección URL completo de la segunda API.

  2. Usa los fragmentos de código siguientes para llamar a una API:

    // After you acquire an access token, use it to call an API

val firstApiResponse = useAccessToken(WEB_API_URL_1, accessTokenOne)
val secondApiResponse = useAccessToken(WEB_API_URL_2, accessTokenTwo)

private suspend fun useAccessToken(WEB_API_URL: String, accessToken: String): Response {
    return withContext(Dispatchers.IO) {
        ApiClient.performGetApiRequest(WEB_API_URL, accessToken)
    }
}

    Defina la performGetApiRequest() función como se muestra en el código siguiente:

    object ApiClient {
    private val client = OkHttpClient()

    fun performGetApiRequest(WEB_API_URL: String, accessToken: String): Response {    
        val requestBuilder = Request.Builder()
                .url(WEB_API_URL)
                .addHeader("Authorization", "Bearer $accessToken")
                .get()

        val request = requestBuilder.build()

        client.newCall(request).execute().use { response -> return response }
    }
}

Configurar proveedor de reclamaciones personalizado

Si quieres agregar notificaciones de un sistema externo al token emitido a la aplicación, usa un proveedor de notificaciones personalizado. Un proveedor de notificaciones personalizado se compone de una extensión de autenticación personalizada que llama a una API REST externa para obtener notificaciones de sistemas externos.

Sigue los pasos descritos en Configuración de un proveedor de notificaciones personalizado para agregar notificaciones desde un sistema externo a los tokens de seguridad.

Contenido relacionado

  • Last updated on