Tutoriel : Appeler une API web protégée dans l’application Android

S’applique à : Locataires de main-d’œuvre Locataires externes (en savoir plus)

Il s’agit du troisième tutoriel de la série de tutoriels qui vous guide sur l’appel d’une API web protégée à l’aide de l’ID externe Microsoft Entra.

Dans ce tutoriel, vous allez :

• Appeler une API web protégée

Conditions préalables

Configuration du locataire Workforce

• Tutoriel : Ajouter une connexion à une application Android à l’aide de la plateforme d’identités Microsoft

Configuration du locataire externe

• Tutoriel : Ajouter une connexion à une application Android à l’aide de la plateforme d’identités Microsoft

• 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 d’appel d’une API dans un exemple d’application mobile Android pour avoir une API web de base protégée ASP.NET 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 un exemple d’API web
  • Configurer et exécuter un exemple d’API web

Appeler une API web protégée

Configuration du locataire Workforce

1. Dans app>src>main>java>com.example(your app name). Créez les fragments Android suivants :

   • MSGraphRequestWrapper

2. Ouvrez MSGraphRequestWrapper.java et remplacez le code par l’extrait de code suivant pour appeler l’API Microsoft Graph à l’aide du jeton fourni par MSAL :

    package com.azuresamples.msalandroidapp;
   
    import android.content.Context;
    import android.util.Log;
   
    import androidx.annotation.NonNull;
   
    import com.android.volley.DefaultRetryPolicy;
    import com.android.volley.Request;
    import com.android.volley.RequestQueue;
    import com.android.volley.Response;
    import com.android.volley.toolbox.JsonObjectRequest;
    import com.android.volley.toolbox.Volley;
   
    import org.json.JSONObject;
   
    import java.util.HashMap;
    import java.util.Map;
   
    public class MSGraphRequestWrapper {
        private static final String TAG = MSGraphRequestWrapper.class.getSimpleName();
   
        // See: https://docs.microsoft.com/en-us/graph/deployments#microsoft-graph-and-graph-explorer-service-root-endpoints
        public static final String MS_GRAPH_ROOT_ENDPOINT = "https://graph.microsoft.com/";
   
        /**
         * Use Volley to make an HTTP request with
         * 1) a given MSGraph resource URL
         * 2) an access token
         * to obtain MSGraph data.
         **/
        public static void callGraphAPIUsingVolley(@NonNull final Context context,
                                                   @NonNull final String graphResourceUrl,
                                                   @NonNull final String accessToken,
                                                   @NonNull final Response.Listener<JSONObject> responseListener,
                                                   @NonNull final Response.ErrorListener errorListener) {
            Log.d(TAG, "Starting volley request to graph");
   
            /* Make sure we have a token to send to graph */
            if (accessToken == null || accessToken.length() == 0) {
                return;
            }
   
            RequestQueue queue = Volley.newRequestQueue(context);
            JSONObject parameters = new JSONObject();
   
            try {
                parameters.put("key", "value");
            } catch (Exception e) {
                Log.d(TAG, "Failed to put parameters: " + e.toString());
            }
   
            JsonObjectRequest request = new JsonObjectRequest(Request.Method.GET, graphResourceUrl,
                    parameters, responseListener, errorListener) {
                @Override
                public Map<String, String> getHeaders() {
                    Map<String, String> headers = new HashMap<>();
                    headers.put("Authorization", "Bearer " + accessToken);
                    return headers;
                }
            };
   
            Log.d(TAG, "Adding HTTP GET to Queue, Request: " + request.toString());
   
            request.setRetryPolicy(new DefaultRetryPolicy(
                    3000,
                    DefaultRetryPolicy.DEFAULT_MAX_RETRIES,
                    DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));
            queue.add(request);
        }
    }
   

Configuration du locataire externe

1. Pour appeler une API web à partir d’une application Android pour accéder aux données ou services externes, commencez par créer un objet complémentaire dans votre MainActivity classe. 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 complémentaire 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 les respectives 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 d'alerte et revient. 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 GET de requêtes à 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, elle exécute la requête de façon synchrone à l’aide de la newCall() méthode d’OkHttp et retourne la réponse. L'objet ApiClient maintient une instance de OkHttpClient pour gérer les requêtes HTTP. Pour utiliser OkHttpClient, vous devez ajouter la dépendance implementation 'com.squareup.okhttp3:okhttp:4.9.0' à votre fichier Android Gradle.

   Veillez à inclure les instructions d'importation. Android Studio devrait inclure automatiquement les instructions d'importation pour vous.

Tester votre application

Générez et déployez l’application sur un appareil de test ou un émulateur. Vous devez être en mesure de vous connecter et d’obtenir des jetons pour l’ID Microsoft Entra.

Contenu connexe

• Scénario : Application mobile qui appelle des API web
• Exemple de code pour les scénarios complexes