Självstudie: Anropa ett skyddat webb-API i Android-appen

In app>src>main>java>com.example(ditt appnamn). Skapa följande Android-fragment:

• MSGraphRequestWrapper

Öppna MSGraphRequestWrapper.java och ersätt koden med följande kodfragment för att anropa Microsoft Graph API med hjälp av den token som tillhandahålls av 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);
     }
 }

Om du vill anropa ett webb-API från ett Android-program för att få åtkomst till externa data eller tjänster börjar du med att skapa ett tillhörande objekt i din MainActivity-klass. Det tillhörande objektet bör innehålla följande kod:

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

Det tillhörande objektet definierar två privata konstanter: WEB_API_BASE_URL, där utvecklare anger webb-API:ens URL och scopes, där utvecklare lägger till respektive scopes för webb-API:et.

Använd följande kod för att hantera processen för att komma åt ett webb-API:

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

Koden startar en coroutine i huvudsändaren. Det börjar med att rensa textloggen. Sedan kontrollerar den om webb-API-bas-URL:en är tom. I så fall visas ett popup-meddelande och returneras. Därefter utför den en GET-begäran till webb-API:et med hjälp av den angivna åtkomsttoken i en bakgrundstråd.

När api-svaret har tagits emot uppdateras textloggen med svarsinnehållet. Om något undantag inträffar under den här processen loggar det undantaget och uppdaterar textloggen med motsvarande felmeddelande.

I koden, där vi anger vårt återanrop, använder vi en funktion som heter performGetApiRequest(). Funktionen bör ha följande kod:

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

Koden underlättar att göra GET-begäranden till ett webb-API. Huvudmetoden är performGetApiRequest(), som tar webb-API-bas-URL:en och en åtkomsttoken som parametrar. I den här metoden skapas en fullständig URL genom att lägga till /api/todolist till bas-URL:en. Sedan skapas en HTTP-begäran med lämpliga rubriker, inklusive ett auktoriseringshuvud med en åtkomsttoken.

Slutligen körs begäran synkront med okHttps newCall()-metod och returnerar svaret. ApiClient-objektet underhåller en instans av OkHttpClient för att hantera HTTP-begäranden. Om du vill använda OkHttpClientmåste du lägga till beroendet implementation 'com.squareup.okhttp3:okhttp:4.9.0' i Android Gradle-filen.

Se till att du inkluderar importinstruktionerna. Android Studio bör inkludera importinstruktionerna automatiskt.