Lernprogramm: Aufrufen einer geschützten Web-API in der Android-App

In app>src>main>java>com.example(Name Ihrer App). Erstellen Sie die folgenden Android-Fragmente:

• MSGraphRequestWrapper

Öffnen Sie MSGraphRequestWrapper.java, und ersetzen Sie den Code durch den folgenden Codeschnipsel, um die Microsoft Graph-API mithilfe des von MSAL bereitgestellten Tokens aufzurufen:

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

Wenn Sie eine Web-API aus einer Android-Anwendung aufrufen möchten, um auf externe Daten oder Dienste zuzugreifen, erstellen Sie zunächst ein Begleitobjekt in Ihrer MainActivity Klasse. Das Begleitobjekt sollte den folgenden Code enthalten:

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

Das Begleitobjekt definiert zwei private Konstanten: WEB_API_BASE_URL, in denen Entwickler die URL ihrer Web-API setzen, und scopes, in denen Entwickler die entsprechende scopes ihrer Web-API anhängen.

Verwenden Sie den folgenden Code, um den Zugriff auf eine Web-API zu verarbeiten:

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

Der Code startet eine Coroutine im Hauptdispatcher. Es beginnt mit dem Löschen des Textprotokolls. Anschließend überprüft er, ob die Basis-URL der Web-API leer ist. Falls ja, wird eine Popupmeldung angezeigt, und der Vorgang wird abgeschlossen. Als Nächstes führt sie eine GET-Anforderung an die Web-API mithilfe des bereitgestellten Zugriffstokens in einem Hintergrundthread aus.

Nachdem die API-Antwort empfangen wurde, wird das Textprotokoll mit dem Antwortinhalt aktualisiert. Wenn während dieses Prozesses eine Ausnahme auftritt, protokolliert sie die Ausnahme und aktualisiert das Textprotokoll mit der entsprechenden Fehlermeldung.

Im Codeabschnitt, in dem wir unseren Rückruf angeben, verwenden wir eine Funktion, die genannt wird performGetApiRequest(). Die Funktion sollte den folgenden Code aufweisen:

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

Der Code erleichtert das Senden von GET Anforderungen an eine Web-API. Die Hauptmethode ist performGetApiRequest(), die die Web-API-Basis-URL und ein Zugriffstoken als Parameter verwendet. Innerhalb dieser Methode erstellt sie eine vollständige URL, indem sie an die Basis-URL anfügen /api/todolist . Anschließend wird eine HTTP-Anforderung mit den entsprechenden Headern erstellt, einschließlich des Autorisierungsheaders mit dem Zugriffstoken.

Schließlich wird die Anforderung synchron mit der OkHttp-Methode newCall() ausgeführt und die Antwort zurückgegeben. Das ApiClient Objekt verwaltet eine Instanz zum Verarbeiten von OkHttpClient HTTP-Anforderungen. Um OkHttpClient zu verwenden, müssen Sie der Android Gradle-Datei die Abhängigkeit implementation 'com.squareup.okhttp3:okhttp:4.9.0' hinzufügen.

Stellen Sie sicher, dass Sie die Importanweisungen hinzufügen. Android Studio sollte die Importanweisungen automatisch für Sie einfügen.