Delen via

Zelfstudie: Een API aanroepen in een Android-app met behulp van systeemeigen verificatie

  • Artikel

Van toepassing op: Witte cirkel met een grijs X-symbool. Werkforce-huurders Groene cirkel met een wit vinkje. Externe huurders (meer informatie)

In deze zelfstudie leert u hoe u een toegangstoken verkrijgt en een API aanroept in uw mobiele Android-app. Met de systeemeigen verificatie-SDK van Microsoft Authentication Library (MSAL) voor Android kunt u meerdere toegangstokens verkrijgen met eenmalige aanmelding. Met deze mogelijkheid kunt u een of meer toegangstokens verkrijgen zonder dat een gebruiker zich opnieuw moet verifiëren.

In deze handleiding leert u:

  • Een of meer toegangstokens verkrijgen.
  • Een API aanroepen

Voorwaarden

Een toegangstoken verkrijgen

Zodra de gebruiker zich heeft aangemeld, verkrijgt u een toegangstoken door de bereiken op te geven waarvoor het toegangstoken geldig is.

MSAL native authentication SDK ondersteunt meerdere toegangstokens, zodat u meerdere sets scopes kunt opgeven en vervolgens een toegangstoken kunt aanvragen voor elke set scopes.

  1. Declareer en stel waarden in voor een set API-bereiken met behulp van het volgende codefragment:

    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. Gebruikers aanmelden met behulp van het volgende codefragment:

    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. Haal een of meer toegangstokens op met behulp van het volgende codefragment:

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

    Definieer de functie getAccessToken(), zoals wordt weergegeven in de volgende code:

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

Een API aanroepen

Als u een API-aanroep wilt maken, gebruikt u het toegangstoken dat u hebt verkregen in Een toegangstoken verkrijgen en een API-URL:

  1. Declareer en stel waarden in voor de API-URL's met behulp van het volgende codefragment:

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

    Vervang het volgende:

    • Enter_URL_Of_First_Web_API tijdelijke aanduiding met de volledige URL-waarde van uw eerste API.
    • Enter_URL_Of_Second_Web_API tijdelijke aanduiding met de volledige URL-waarde van uw tweede API.

  2. Gebruik de volgende codefragmenten om een API aan te roepen:

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

    Definieer de functie performGetApiRequest(), zoals wordt weergegeven in de volgende code:

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

Aangepaste claimprovider configureren

Als u claims van een extern systeem wilt toevoegen aan het token dat is uitgegeven aan uw app, gebruikt u een aangepaste claimprovider. Een aangepaste claimprovider bestaat uit een aangepaste verificatie-extensie die een externe REST API aanroept om claims op te halen uit externe systemen.

Volg de stappen in Een aangepaste claimprovider configureren om claims van een extern systeem toe te voegen aan uw beveiligingstokens.

Verwante inhoud