Compartilhar via

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

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

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

Neste tutorial, você:

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

Pré-requisitos

Adquirir um token de acesso

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

O SDK de autenticação nativa msal dá suporte a vários tokens de acesso, para que você possa especificar vários conjuntos de escopos e solicitar token de acesso para cada conjunto de escopos:

  1. Declare e defina valores para um conjunto de escopos de API usando o seguinte snippet 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. Faça login do usuário usando o seguinte snippet 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 snippet 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 getAccessToken() função conforme 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 à API, use o token de acesso adquirido em Adquirir um token de acesso e uma URL de API:

  1. Declare e defina valores para os URLs da API usando o seguinte snippet 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 espaço reservado com o valor completo do URL da sua primeira API.
    • espaço reservado Enter_URL_Of_Second_Web_API com o valor completo da URL da sua segunda API.

  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 performGetApiRequest() função conforme 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 a partir 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