Esercitazione: Chiamare un'API nell'app Android usando l'autenticazione nativa

Si applica a: cerchio verde con un simbolo di segno di spunta bianco che indica il contenuto seguente si applica ai tenant esterni. Tenant esterni (altre informazioni)

Questa esercitazione illustra come acquisire un token di accesso e chiamare un'API nell'app per dispositivi mobili Android. Microsoft Authentication Library (MSAL) native authentication SDK per Android consente di acquisire più token di accesso con un single sign-in. Questa funzionalità consente di acquisire uno o più token di accesso senza richiedere a un utente di ripetere l'autenticazione.

In questa esercitazione, farai:

  • Acquisire uno o più token di accesso.
  • Chiamare un'API

Prerequisiti

Acquisire un token di accesso

Dopo l'accesso dell'utente, si acquisisce un token di accesso specificando gli ambiti per i quali il token di accesso è valido.

MSAL native authentication SDK supporta più token di accesso, quindi è possibile specificare più set di ambiti, quindi richiedere il token di accesso per ogni set di ambiti:

  1. Dichiarare e impostare i valori per un set di ambiti API usando il frammento di codice seguente:

    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. Eseguire l'accesso dell'utente utilizzando il seguente frammento di codice:

    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. Acquisire uno o più token di accesso usando il frammento di codice seguente:

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

    Definire la funzione getAccessToken() come illustrato nel codice seguente:

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

Chiamare un'API

Per effettuare una chiamata API, usare il token di accesso acquisito in Acquisire un token di accesso e un URL DELL'API:

  1. Dichiarare e impostare i valori per gli URL dell'API usando il frammento di codice seguente:

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

    Sostituire:

    • Enter_URL_Of_First_Web_API segnaposto con il valore completo dell'URL della prima API.
    • Enter_URL_Of_Second_Web_API segnaposto con il valore completo dell'URL della tua seconda API.

  2. Usare i frammenti di codice seguenti per chiamare un'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)
    }
}

    Definire la funzione performGetApiRequest() come illustrato nel codice seguente:

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

Configurare un provider di attestazioni personalizzato

Se vuoi aggiungere attestazioni da un sistema esterno al token rilasciato all'app, usa un provider di attestazioni personalizzato . Un provider di attestazioni personalizzato è costituito da un'estensione di autenticazione personalizzata che chiama un'API REST esterna per recuperare le attestazioni da sistemi esterni.

Seguire la procedura descritta in Configurare un provider di attestazioni personalizzato per aggiungere attestazioni da un sistema esterno ai token di sicurezza.

Contenuto correlato

  • Last updated on