Tutoriel : Appeler une API dans une application Android à l’aide de l’authentification native

S’applique à : cercle vert avec un symbole de coche blanc qui indique que le contenu suivant s’applique aux locataires externes. Locataires externes (en savoir plus)

Dans ce tutoriel, vous allez apprendre à acquérir un jeton d’accès et à appeler une API dans votre application mobile Android. Microsoft Authentication Library (MSAL) native authentication SDK for Android vous permet d’acquérir plusieurs jetons d’accès avec une authentification unique. Cette fonctionnalité vous permet d’acquérir un ou plusieurs jetons d’accès sans demander à un utilisateur de se réauthentifier.

Dans ce tutoriel, vous allez :

  • Acquérir un ou plusieurs jetons d’accès.
  • Appeler une API

Conditions préalables

Acquérir un jeton d’accès

Une fois que l’utilisateur se connecte, vous obtenez un jeton d’accès en spécifiant les étendues pour lesquelles le jeton d’accès est valide.

Le SDK d’authentification native MSAL prend en charge plusieurs jetons d’accès. Vous pouvez donc spécifier plusieurs ensembles d’étendues, puis demander un jeton d’accès pour chaque ensemble d’étendues :

  1. Déclarez et définissez des valeurs pour un ensemble d’étendues d’API à l’aide de l’extrait de code suivant :

    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. Connecte l’utilisateur à l’aide de l’extrait de code suivant :

    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. Acquérir un ou plusieurs jetons d’accès à l’aide de l’extrait de code suivant :

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

    Définissez la getAccessToken() fonction comme indiqué dans le code suivant :

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

Appeler une API

Pour effectuer un appel d’API, utilisez le jeton d’accès que vous avez acquis dans Acquérir un jeton d’accès et une URL d’API :

  1. Déclarez et définissez des valeurs pour les URL d’API à l’aide de l’extrait de code suivant :

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

    Remplacez :

    • Espace réservé Enter_URL_Of_First_Web_API avec la valeur d’URL complète de votre première API.
    • Espace réservé Enter_URL_Of_Second_Web_API avec la valeur d’URL complète de votre deuxième API.

  2. Utilisez les extraits de code suivants pour appeler une 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)
    }
}

    Définissez la performGetApiRequest() fonction comme indiqué dans le code suivant :

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

Configurer un fournisseur de revendications personnalisé

Si vous souhaitez ajouter des revendications à partir d’un système externe au jeton émis pour votre application, utilisez un fournisseur de revendications personnalisé. Un fournisseur de revendications personnalisé est constitué d’une extension d’authentification personnalisée qui appelle une API REST externe pour récupérer des revendications provenant de systèmes externes.

Suivez les étapes détaillées dans Configurer un fournisseur de revendications personnalisé pour ajouter des revendications à partir d’un système externe dans vos jetons de sécurité.

Contenu connexe

  • Last updated on