Tutorial: Llamada a una API web protegida en la aplicación Android

Se aplica a: Inquilinos del personal Inquilinos externos (más información)

Este es el tercer tutorial de la serie de tutoriales que le guía en la llamada a una API web protegida mediante el identificador externo de Microsoft Entra.

En este tutorial, usted hará lo siguiente:

• Llamada a una API web protegida

Prerrequisitos

Configuración del inquilino de recursos

• Tutorial: Adición de un inicio de sesión a una aplicación android mediante la plataforma de identidad de Microsoft

Configuración de clientes externos

• Tutorial: Adición de un inicio de sesión a una aplicación android mediante la plataforma de identidad de Microsoft

• Registro de API que expone al menos un ámbito (permisos delegados) y un rol de aplicación (permiso de aplicación), como ToDoList.Read. Si aún no lo ha hecho, siga las instrucciones para llamar a una API en una aplicación móvil Android de ejemplo para tener una API web protegida funcional ASP.NET Core. Asegúrese de completar los pasos siguientes:

  • Registro de una aplicación de API web
  • Configuración de ámbitos de API
  • Configurar roles de la aplicación
  • Configurar reclamaciones opcionales
  • Clonación o descarga de la API web de ejemplo
  • Configuración y ejecución de la API web de ejemplo

Llamada a una API web protegida

Configuración del inquilino de recursos

1. En app>src>main>java>com.example(nombre de su aplicación). Crea los siguientes fragmentos de Android:

   • MSGraphRequestWrapper

2. Abra MSGraphRequestWrapper.java y reemplace el código por el siguiente fragmento de código para llamar a Microsoft Graph API mediante el token proporcionado por 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);
        }
    }
   

Configuración de clientes externos

1. Para llamar a una API web desde una aplicación Android para acceder a datos o servicios externos, empiece por crear un objeto complementario en la MainActivity clase . El objeto complementario debe incluir el código siguiente:

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

   El objeto complementario define dos constantes privadas: WEB_API_BASE_URL, donde los desarrolladores establecen la dirección URL de la API web y scopes, donde los desarrolladores anexan los respectivos scopes de su API web.

2. Para controlar el proceso de acceso a una API web, use el código siguiente:

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

   El código inicia una corrutina en el distribuidor principal. Comienza borrando el registro de texto. A continuación, comprueba si la URL base de la API web está vacía; si es así, muestra un mensaje de notificación y regresa. A continuación, realiza una solicitud GET a la API web mediante el token de acceso proporcionado en un subproceso en segundo plano.

   Después de recibir la respuesta de la API, actualiza el registro de texto con el contenido de la respuesta. Si se produce alguna excepción durante este proceso, registra la excepción y actualiza el registro de texto con el mensaje de error correspondiente.

   En el código, donde especificamos nuestra devolución de llamada, usamos una función denominada performGetApiRequest(). La función debe tener el código siguiente:

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

   El código facilita la solicitud de GET a una API web. El método principal es performGetApiRequest(), que toma la dirección URL base de la API web y un token de acceso como parámetros. Dentro de este método, crea una dirección URL completa anexando /api/todolist a la dirección URL base. A continuación, compila una solicitud HTTP con los encabezados adecuados, incluido el encabezado de autorización con el token de acceso.

   Por último, ejecuta la solicitud de forma sincrónica mediante el método okHttp newCall() y devuelve la respuesta. El ApiClient objeto mantiene una instancia de OkHttpClient para controlar las solicitudes HTTP. Para usar OkHttpClient, debe agregar la dependencia implementation 'com.squareup.okhttp3:okhttp:4.9.0' al archivo de Android Gradle.

   Asegúrate de incluir las declaraciones de importación. Android Studio debe incluir automáticamente las instrucciones de importación.

Prueba de la aplicación

Cree e implemente la aplicación en un emulador o dispositivo de prueba. Debería poder iniciar sesión y obtener tokens para el identificador de Microsoft Entra.

Contenido relacionado

• Escenario: aplicación móvil que llama a las API web
• Ejemplo de código para escenarios complejos