Partager via

Tutoriel : Appeler une API Web protégée dans l'application Android (Kotlin)

  • Article

Il s'agit du quatrième didacticiel de la série de didacticiels qui vous guide dans l'appel d'une API Web protégée à l'aide de l'ID externe Microsoft Entra.

Dans ce didacticiel, vous allez :

  • Appeler une API web protégée

Prérequis

  • Tutoriel : Connecter les utilisateurs dans l'application mobile Android (Kotlin)

  • Une inscription d’API qui expose au moins une étendue (autorisations déléguées) et un rôle d’application (autorisation d’application) tel que ToDoList.Read. Si ce n’est déjà fait, suivez les instructions pour appeler une API dans un exemple d’application mobile Android pour avoir une API web ASP.NET Core protégée fonctionnelle. Veillez à effectuer les étapes suivantes :

    • Inscrire une application d’API web
    • Configurer des étendues d’API
    • Configurer les rôles d’application
    • Configurer des revendications facultatives
    • Cloner ou télécharger l’exemple d’API web
    • Configurer et exécuter un exemple d’API web

Appeler une API

  1. Pour appeler une API Web depuis une application Android pour accéder à des données ou à des services externes, commencez par créer un objet compagnon dans votre classe MainActivity. L’objet complémentaire doit inclure le code suivant :

    companion object {
    private const val WEB_API_BASE_URL = "" // Developers should set the respective URL of their web API here
    private const val scopes = "" // Developers should append the respective scopes of their web API.
}

    L'objet compagnon définit deux constantes privées : WEB_API_BASE_URL, où les développeurs définissent l'URL de leur API Web, et scopes, où les développeurs ajoutent le respectif scopes de leur API Web.

  2. Pour gérer le processus d’accès à une API web, utilisez le code suivant :

    private fun accessWebApi() {
    CoroutineScope(Dispatchers.Main).launch {
        binding.txtLog.text = ""
        try {
            if (WEB_API_BASE_URL.isBlank()) {
                Toast.makeText(this@MainActivity, getString(R.string.message_web_base_url), Toast.LENGTH_LONG).show()
                return@launch
            }
            val apiResponse = withContext(Dispatchers.IO) {
                ApiClient.performGetApiRequest(WEB_API_BASE_URL, accessToken)
            }
            binding.txtLog.text = getString(R.string.log_web_api_response)  + apiResponse.toString()
        } catch (exception: Exception) {
            Log.d(TAG, "Exception while accessing web API: $exception")

            binding.txtLog.text = getString(R.string.exception_web_api) + exception
        }
    }
}

    Le code lance une coroutine dans le répartiteur principal. Elle commence par effacer le journal de texte. Ensuite, il vérifie si l’URL de base de l’API web est vide ; le cas échéant, il affiche un message toast et retourne. Ensuite, il effectue une requête GET à l’API web à l’aide du jeton d’accès fourni dans un thread d’arrière-plan.

    Après avoir reçu la réponse de l’API, elle met à jour le journal texte avec le contenu de la réponse. Si une exception se produit pendant ce processus, elle enregistre l’exception et met à jour le journal texte avec le message d’erreur correspondant.

    Dans le code, où nous spécifions notre rappel, nous utilisons une fonction appelée performGetApiRequest(). La fonction doit avoir le code suivant :

    object ApiClient {
    private val client = OkHttpClient()

    fun performGetApiRequest(WEB_API_BASE_URL: String, accessToken: String?): Response {
        val fullUrl = "$WEB_API_BASE_URL/api/todolist"

        val requestBuilder = Request.Builder()
                .url(fullUrl)
                .addHeader("Authorization", "Bearer $accessToken")
                .get()

        val request = requestBuilder.build()

        client.newCall(request).execute().use { response -> return response }
    }
}

    Le code facilite l’exécution de requêtes GET à une API web. La méthode principale est performGetApiRequest(), qui prend l’URL de base de l’API web et un jeton d’accès en tant que paramètres. Dans cette méthode, elle construit une URL complète en ajoutant /api/todolist à l’URL de base. Ensuite, il génère une requête HTTP avec les en-têtes appropriés, y compris l’en-tête d’autorisation avec le jeton d’accès.

    Enfin, il exécute la requête de manière synchrone à l'aide de la méthode OkHttp newCall() et renvoie la réponse. L’objet ApiClient gère une instance de OkHttpClient pour gérer les requêtes HTTP. Pour utiliser OkHttpClient, vous devez ajouter la implementation 'com.squareup.okhttp3:okhttp:4.9.0' de dépendance à votre fichier Android Gradle.

    Veillez à inclure les instructions import. Android Studio doit inclure automatiquement les instructions import.

Contenu connexe