Lernprogramm: Aufrufen einer API in der Android-App mithilfe der systemeigenen Authentifizierung

Gilt für: Grüner Kreis mit einem weißen Häkchensymbol, das angibt, dass der folgende Inhalt für externe Mandanten gilt. Externe Mandanten (weitere Informationen)

In diesem Lernprogramm erfahren Sie, wie Sie ein Zugriffstoken erwerben und eine API in Ihrer mobilen Android-App aufrufen. Mit dem systemeigenen MSAL-Authentifizierungs-SDK (Microsoft Authentication Library, MSAL) für Android können Sie mehrere Zugriffstoken mit einer einzigen Anmeldung abrufen. Mit dieser Funktion können Sie einzelne oder mehrere Zugriffstoken abrufen, ohne dass Benutzer:innen erneut authentifiziert werden müssen.

In diesem Tutorial führen Sie Folgendes durch:

  • Abrufen eines oder mehrerer Zugriffstoken.
  • Aufrufen einer API

Voraussetzungen

Abrufen eines Zugriffstokens

Sobald sich der Benutzer anmeldet, erwerben Sie ein Zugriffstoken, indem Sie die Bereiche angeben, für die das Zugriffstoken gültig ist.

DAS MSAL Native Authentication SDK unterstützt mehrere Zugriffstoken, sodass Sie mehrere Gruppen von Bereichen angeben und dann Zugriffstoken für jede Gruppe von Bereichen anfordern können:

  1. Verwenden Sie den folgenden Codeschnipsel, um Werte für mehrere API-Gültigkeitsbereiche zu deklarieren und festzulegen:

    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. Melden Sie Benutzende mit dem folgenden Codeschnipsel an:

    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. Rufen Sie ein oder mehrere Zugriffstoken mithilfe des folgenden Codeschnipsels ab.

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

    Definieren Sie die getAccessToken() Funktion wie im folgenden Code dargestellt:

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

Aufrufen einer API

Um einen API-Aufruf zu tätigen, verwenden Sie das zugriffstoken, das Sie im Abrufen eines Zugriffstokens und einer API-URL erworben haben:

  1. Deklarieren und Festlegen von Werten für die API-URLs mithilfe des folgenden Codeausschnitts:

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

    Ersetzen Sie Folgendes:

    • Enter_URL_Of_First_Web_API Platzhalter mit dem vollständigen URL-Wert Ihrer ersten API.
    • Enter_URL_Of_Second_Web_API Platzhalter mit dem vollständigen URL-Wert Ihrer zweiten API.

  2. Verwenden Sie die folgenden Codeschnipsel, um eine API aufzurufen:

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

    Definieren Sie die performGetApiRequest() Funktion wie im folgenden Code dargestellt:

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

Konfigurieren eines benutzerdefinierten Anspruchsanbieters

Wenn Sie Ansprüche aus einem externen System in das Token einfügen möchten, das an Ihre Anwendung ausgegeben wird, verwenden Sie einen benutzerdefinierten Anspruchsanbieter. Ein benutzerdefinierter Anspruchsanbieter besteht aus einer benutzerdefinierten Authentifizierungserweiterung, die eine externe REST-API aufruft, um Ansprüche aus externen Systemen abzurufen.

Führen Sie die Schritte unter Konfigurieren eines benutzerdefinierten Anspruchsanbieters durch, um Ansprüche aus einem externen System zu Ihren Sicherheitstoken hinzuzufügen.

Verwandte Inhalte

  • Last updated on