Tutorial: Chamar uma API no aplicativo Android usando autenticação nativa

Aplica-se a: círculo verde com um símbolo de marca de seleção branco que indica que o conteúdo a seguir se aplica a locatários externos. Inquilinos externos (saiba mais)

Neste tutorial, você aprenderá como adquirir um token de acesso e chamar uma API em seu aplicativo móvel Android. O SDK de autenticação nativo da Biblioteca de Autenticação da Microsoft (MSAL) para Android permite que você adquira vários tokens de acesso com um único login. Esse recurso permite que você adquira um ou mais tokens de acesso sem exigir que um usuário se autentique novamente.

Neste tutorial, você:

  • Adquira um ou vários tokens de acesso.
  • Chamar uma API

Pré-requisitos

Adquira um token de acesso

Depois que o usuário entrar, você adquire um token de acesso especificando os escopos para os quais o token de acesso é válido.

O SDK de autenticação nativa do MSAL suporta vários tokens de acesso, para que você possa especificar vários conjuntos de escopos e, em seguida, solicitar token de acesso para cada conjunto de escopos:

  1. Declare e defina valores para um conjunto de escopos de API usando o seguinte trecho 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 sessão como utilizador usando o seguinte trecho 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. Adquira um ou vários tokens de acesso usando o seguinte trecho 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 a função getAccessToken() como mostrado no código a seguir:

    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")
    }
}

Chamar uma API

Para fazer uma chamada de API, use o token de acesso que você adquiriu em Adquirir um token de acesso e uma URL de API:

  1. Declare e defina valores para as URLs da API usando o seguinte trecho 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" 
}

    Substitua o:

    • Enter_URL_Of_First_Web_API marcador de posição com o valor completo do URL da sua primeira API.
    • Enter_URL_Of_Second_Web_API placeholder com o valor de URL da sua API secundária.

  2. Use os seguintes trechos de código para chamar uma 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 a função performGetApiRequest() como mostrado no código a seguir:

    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 provedor de declarações personalizado

Se você quiser adicionar declarações de um sistema externo ao token emitido para seu aplicativo, use um provedor de declarações personalizado . Um provedor de declarações personalizado é composto por uma extensão de autenticação personalizada que chama uma API REST externa para buscar declarações de sistemas externos.

Siga as etapas em Configurar um provedor de declarações personalizado para adicionar declarações de um sistema externo aos seus tokens de segurança.

Conteúdo relacionado

  • Last updated on